Skip to main content

Utilisation du registre Gradle

Vous pouvez configurer Gradle pour qu’il publie des packages dans le registre Gradle GitHub Packages et utilise les packages stockés dans GitHub Packages comme dépendances dans un projet Java.

Qui peut utiliser cette fonctionnalité ?

GitHub Packages est disponible avec GitHub Free, GitHub Pro, GitHub Free pour les organisations, GitHub Team, GitHub Enterprise Cloud, GitHub Enterprise Server 3.0 ou ultérieur et .
GitHub Packages n’est pas disponible pour les référentiels privés appartenant à des comptes qui utilisent des plans par référentiel hérités. Par ailleurs, les comptes utilisant des plans par dépôt hérités ne peuvent pas accéder aux registres qui prennent en charge les autorisations granulaires, car ces comptes sont facturés par dépôt. Pour obtenir la liste des registres prenant en charge les autorisations granulaires, consultez la section « À propos des autorisations pour les packages GitHub ». Pour plus d’informations, consultez « Plans de GitHub ».

Authentification auprès de GitHub Packages

GitHub Packages prend uniquement en charge l’authentification à l’aide d’un personal access token (classic). Pour plus d’informations, consultez « Gestion de vos jetons d'accès personnels ».

Vous avez besoin d’un jeton d’accès pour publier, installer et supprimer des packages privés, internes et publics.

Vous pouvez utiliser un personal access token (classic) pour vous authentifier sur GitHub Packages ou l’API GitHub. Quand vous créez un personal access token (classic), vous pouvez l’attribuer à différentes étendues selon vos besoins. Pour plus d’informations sur les étendues liées aux packages pour un personal access token (classic), consultez « À propos des autorisations pour les packages GitHub ».

Pour vous authentifier sur un registre GitHub Packages dans un workflow GitHub Actions, vous pouvez utiliser :

  • GITHUB_TOKEN pour publier des packages associés au dépôt du workflow.
  • un personal access token (classic) avec au moins l’étendue read:packages pour installer des packages associés à d’autres dépôts privés (auxquels GITHUB_TOKEN ne peut pas accéder).

Pour plus d’informations sur GITHUB_TOKEN utilisé dans les workflows GitHub Actions, consultez « Authentification par jeton automatique ». Pour plus d’informations sur l’utilisation de GITHUB_TOKEN avec Gradle, consultez « Publication de packages Java avec Gradle ».

Authentification avec un personal access token

Vous devez utiliser un personal access token (classic) avec les étendues appropriées pour publier et installer des packages dans GitHub Packages. Pour plus d’informations, consultez « Introduction aux packages GitHub ».

Vous pouvez vous authentifier auprès de GitHub Packages avec Gradle à l’aide de Gradle Groovy ou de Kotlin DSL en modifiant votre fichier build.gradle (Gradle Groovy) ou build.gradle.kts (Kotlin DSL) pour inclure votre personal access token (classic). Vous pouvez également configurer Gradle Groovy et Kotlin DSL pour reconnaître un package unique ou plusieurs packages dans un dépôt.

Remplacez USERNAME par votre nom d’utilisateur GitHub, TOKEN par votre personal access token (classic), REPOSITORY par le nom du dépôt contenant le package que vous souhaitez publier et OWNER par le nom du compte personnel ou de l’organisation sur GitHub qui est propriétaire du dépôt. Étant donné que les lettres majuscules ne sont pas prises en charge, vous devez utiliser des lettres minuscules pour le propriétaire du dépôt, même si le nom d’utilisateur ou d’organisation GitHub contient des lettres majuscules.

Remarque : GitHub Packages prend en charge les versions SNAPSHOT d’Apache Maven. Pour utiliser le dépôt GitHub Packages afin de télécharger les artefacts SNAPSHOT, activez SNAPSHOTS dans le POM du projet consommateur ou de votre fichier ~/.m2/settings.xml. Pour obtenir un exemple, consultez « Utilisation du registre Apache Maven ».

Exemple d’utilisation de Gradle Groovy pour un seul package dans un dépôt

plugins {
    id("maven-publish")
}
publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
            }
        }
    }
    publications {
        gpr(MavenPublication) {
            from(components.java)
        }
    }
}

Exemple d’utilisation de Gradle Groovy pour plusieurs packages dans le même dépôt

plugins {
    id("maven-publish") apply false
}
subprojects {
    apply plugin: "maven-publish"
    publishing {
        repositories {
            maven {
                name = "GitHubPackages"
                url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
                credentials {
                    username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                    password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
                }
            }
        }
        publications {
            gpr(MavenPublication) {
                from(components.java)
            }
        }
    }
}

Exemple d’utilisation de Kotlin DSL pour un seul package dans le même dépôt

plugins {
    `maven-publish`
}
publishing {
    repositories {
        maven {
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
            credentials {
                username = project.findProperty("gpr.user") as String? ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") as String? ?: System.getenv("TOKEN")
            }
        }
    }
    publications {
        register<MavenPublication>("gpr") {
            from(components["java"])
        }
    }
}

Exemple d’utilisation de Kotlin DSL pour plusieurs packages dans le même dépôt

plugins {
    `maven-publish` apply false
}
subprojects {
    apply(plugin = "maven-publish")
    configure<PublishingExtension> {
        repositories {
            maven {
                name = "GitHubPackages"
                url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
                credentials {
                    username = project.findProperty("gpr.user") as String? ?: System.getenv("USERNAME")
                    password = project.findProperty("gpr.key") as String? ?: System.getenv("TOKEN")
                }
            }
        }
        publications {
            register<MavenPublication>("gpr") {
                from(components["java"])
            }
        }
    }
}

Publication d’un package

Par défaut, GitHub publie le package dans un dépôt existant portant le même nom que le package. Par exemple, GitHub publie un package nommé com.example.test dans le dépôt OWNER/test GitHub Packages.

Après avoir publié un package, vous pouvez l’afficher sur GitHub. Pour plus d’informations, consultez « Affichage de packages ».

  1. Authentifiez-vous sur GitHub Packages. Pour plus d’informations, consultez « Authentification auprès de GitHub Packages ».

  2. Après avoir créé votre package, vous pouvez publier le package.

     gradle publish
    

Utilisation d’un package publié

Pour utiliser un package publié à partir de GitHub Packages, ajoutez le package en tant que dépendance et ajoutez le dépôt à votre projet. Pour plus d’informations, consultez « Déclaration de dépendances » dans la documentation Gradle.

  1. Authentifiez-vous sur GitHub Packages. Pour plus d’informations, consultez « Authentification auprès de GitHub Packages ».

  2. Ajoutez les dépendances de package à votre fichier build.gradle (Gradle Groovy) ou build.gradle.kts (Kotlin DSL).

    Exemple d’utilisation de Gradle Groovy :

    dependencies {
        implementation 'com.example:package'
    }
    

    Exemple d’utilisation de Kotlin DSL :

    dependencies {
        implementation("com.example:package")
    }
    
  3. Ajoutez le dépôt à votre fichier build.gradle (Gradle Groovy) ou build.gradle.kts (Kotlin DSL).

    Exemple d’utilisation de Gradle Groovy :

    repositories {
        maven {
            url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
            credentials {
                username = project.findProperty("gpr.user") ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") ?: System.getenv("TOKEN")
            }
       }
    }
    

    Exemple d’utilisation de Kotlin DSL :

    repositories {
        maven {
            url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
            credentials {
                username = project.findProperty("gpr.user") as String? ?: System.getenv("USERNAME")
                password = project.findProperty("gpr.key") as String? ?: System.getenv("TOKEN")
            }
        }
    }
    

Pour aller plus loin