Arbeiten mit der Gradle-Registrierung

Bei GitHub Packages authentifizieren

Du benötigst ein Zugriffstoken, um private, interne und öffentliche Pakete zu veröffentlichen, zu installieren und zu löschen.

Du kannst ein personal access token (classic) für die Authentifizierung bei GitHub Packages oder bei der GitHub Enterprise Server-API verwenden. Wenn du ein personal access token (classic) erstellst, kannst du dem Token je nach Bedarf verschiedene Bereiche zuweisen. Weitere Informationen zu paketbezogenen Bereichen für ein personal access token (classic) findest du unter Informationen zu Berechtigungen für GitHub-Pakete.

Um dich bei einer GitHub Packages-Registrierung innerhalb eines GitHub Actions-Workflows zu authentifizieren, kannst du Folgendes verwenden:

• GITHUB_TOKEN, um Pakete zu veröffentlichen, die mit dem Workflowrepository verbunden sind.
• Ein personal access token (classic) (diesem muss mindestens der Bereich read:packages zugeordnet sein), um Pakete zu installieren, die zu anderen privaten Repositorys gehören (auf die GITHUB_TOKEN nicht zugreifen kann)

Weitere Informationen zum GITHUB_TOKEN, das in GitHub Actions-Workflows verwendet wird, findest du unter Automatische Tokenauthentifizierung. Weitere Informationen zum Verwenden von GITHUB_TOKEN mit Gradle findest du unter Java-Pakete mit Gradle veröffentlichen.

Authentifizieren mit einem personal access token

Du musst ein personal access token (classic) mit den entsprechenden Bereichen verwenden, um Pakete in GitHub Packages zu veröffentlichen und zu installieren. Weitere Informationen findest du unter Einführung in GitHub-Pakete.

Du kannst dich bei GitHub Packages mit Gradle über Gradle Groovy oder Kotlin DSL authentifizieren, indem du deine build.gradle-Datei (Gradle Groovy) oder build.gradle.kts-Datei (Kotlin DSL) so bearbeitest, dass sie dein personal access token (classic) enthält. Du kannst auch Gradle Groovy und Kotlin DSL konfigurieren, um ein einzelnes Paket oder mehrere Pakete in einem Repository zu erkennen.

Ersetze REGISTRY_URL durch die URL für die Maven-Registrierung deiner Instanz. Wenn die Unterdomänenisolation für deine Instanz aktiviert ist, verwende maven.HOSTNAME. Wenn Unterdomänenisolation für deine Instanz deaktiviert ist, verwende HOSTNAME/_registry/maven. In beiden Fällen musst du HOSTNAME durch den Hostnamen deiner GitHub Enterprise Server-Instanz ersetzen.

Ersetze USERNAME durch deinen GitHub-Benutzernamen, TOKEN durch dein personal access token (classic), REPOSITORY durch den Namen des Repositorys, in dem das zu veröffentlichende Paket enthalten ist, und OWNER durch den Namen des persönlichen Kontos oder der Organisation auf GitHub, das bzw. die Besitzer des Repositorys ist. Da Großbuchstaben nicht unterstützt werden, musst du für den oder die Repositorybesitzer*in Kleinbuchstaben verwenden, selbst wenn der Benutzer- oder Organisationsname auf GitHub Großbuchstaben enthält.

Beispiel für die Verwendung von Gradle Groovy für ein einzelnes Paket in einem Repository

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)
        }
    }
}

Beispiel für die Verwendung von Gradle Groovy für mehrere Pakete im gleichen Repository

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)
            }
        }
    }
}

Beispiel für die Verwendung von Kotlin DSL für ein einzelnes Paket im gleichen Repository

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"])
        }
    }
}

Beispiel für die Verwendung von Kotlin DSL für mehrere Pakete im gleichen Repository

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"])
            }
        }
    }
}

Veröffentlichen eines Pakets

Standardmäßig veröffentlicht GitHub das Paket in ein vorhandenes Repository mit dem gleichen Namen wie das Paket. Beispielsweise veröffentlicht GitHub ein Paket mit dem Namen com.example.test im Repository OWNER/test GitHub Packages.

Nachdem Du ein Paket veröffentlicht hast, kannst Du das Paket auf GitHub ansehen. Weitere Informationen findest du unter Pakete anzeigen.

1. Authentifizieren bei GitHub Packages. Weitere Informationen findest Du unter Authentifizieren bei GitHub Packages.

2. Nachdem du dein Paket erstellt hast, kannst du das Paket veröffentlichen.

    gradle publish
   

Verwenden eines veröffentlichten Pakets

Um ein veröffentlichtes Paket aus GitHub Packages zu verwenden, füge das Paket als Abhängigkeit hinzu und füge dem Projekt das Repository hinzu. Weitere Informationen findest du unter Deklarieren von Abhängigkeiten in der Gradle-Dokumentation.

1. Authentifizieren bei GitHub Packages. Weitere Informationen findest Du unter Authentifizieren bei GitHub Packages.

2. Füge die Paketabhängigkeiten deiner Build.gradle-Datei (Gradle Groovy) oder der Datei „Build.gradle.kts“ (Kotlin DSL) hinzu.

   Example using Grady Groovy:

   dependencies {
       implementation 'com.example:package'
   }
   

   Beispiel für die Verwendung von Kotlin DSL:

   dependencies {
       implementation("com.example:package")
   }
   

3. Füge das Repository deiner Build.gradle-Datei (Gradle Groovy) oder der Datei „Build.gradle.kts“ (Kotlin DSL) hinzu.

   Example using Grady 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")
           }
      }
   }
   

   Beispiel für die Verwendung von 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")
           }
       }
   }
   

Weiterführende Themen

• Arbeiten mit der Apache Maven-Registrierung
• Löschen und Wiederherstellen eines Pakets