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.

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 version ultérieure et GitHub AE.
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. En outre, les comptes qui utilisent des plans par référentiel hérités n’ont pas accès au Container registry puisque ces comptes sont facturés par référentiel. Pour plus d’informations, consultez « Produits 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 « Création d’un personal access token ».

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 le GITHUB_TOKEN utilisé dans les workflows GitHub Actions, consultez « Authentification dans un workflow ». 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 « À propos de GitHub Packages ».

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 référentiel contenant le package que vous souhaitez publier et OWNER par le nom du compte d’utilisateur ou d’organisation sur GitHub propriétaire du référentiel. É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 « Configuration d’Apache Maven pour une utilisation avec GitHub Packages ».

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