Utilisation du registre Gradle

Remarque : Ce type de package peut ne pas être disponible pour votre instance, car les administrateurs de site peuvent activer ou désactiver chaque type de package pris en charge. Pour plus d’informations, consultez « Configuration de la prise en charge de l’écosystème de packages pour votre entreprise ».

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 Enterprise Server. 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 REGISTRY_URL par l’URL du registre Maven de votre instance. Si l’isolation de sous-domaine est activée pour votre instance, utilisez maven.HOSTNAME. Si l’isolation de sous-domaine est désactivée pour votre instance, utilisez HOSTNAME/_registry/maven. Dans les deux cas, remplacez HOSTNAME par le nom d’hôte de votre instance GitHub Enterprise Server.

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://REGISTRY_URL/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://REGISTRY_URL/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://REGISTRY_URL/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://REGISTRY_URL/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 ».

Authentifiez-vous sur GitHub Packages. Pour plus d’informations, consultez « Authentification auprès de GitHub Packages ».
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.

Authentifiez-vous sur GitHub Packages. Pour plus d’informations, consultez « Authentification auprès de GitHub Packages ».
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")
}
```

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://REGISTRY_URL/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://REGISTRY_URL/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

« Utilisation du registre Apache Maven »
« Suppression et restauration d'un package »

Dans cet article