Trabalhando com o registro do Gradle

Autenticar-se no GitHub Packages

Você precisa de um token de acesso para publicar, instalar e excluir pacotes privados, públicos e internos.

Você pode usar um personal access token (classic) para se autenticar no GitHub Packages ou na API do GitHub. Ao criar um personal access token (classic), você pode atribuir diferentes escopos de token, dependendo da sua necessidade. Para obter mais informações sobre escopos relacionados a pacotes para personal access token (classic), confira "Sobre permissões para o GitHub Packages".

Para efetuar a autenticação em um registro do GitHub Packages dentro de um fluxo de trabalho de GitHub Actions, você pode utilizar:

• GITHUB_TOKEN para publicar pacotes associados ao repositório do fluxo de trabalho.
• um personal access token (classic) com pelo menos escopo read:packages para instalar pacotes associados a outros repositórios privados (que não podem ser acessados por GITHUB_TOKEN).

Para obter mais informações sobre o GITHUB_TOKEN usado em fluxos de trabalho do GitHub Actions, confira "Autenticação automática de token". Para obter mais informações sobre como usar o GITHUB_TOKEN com o Gradle, confira "Publicar pacotes Java com Gradle".

Autenticar com um personal access token

Você precisa usar um personal access token (classic) com os escopos apropriados para publicar e instalar pacotes no GitHub Packages. Para obter mais informações, confira "Introdução ao GitHub Packages".

Autentique-se no GitHub Packages com o Gradle usando o Gradle Groovy ou o Kotlin DSL editando o arquivo build.gradle (Gradle Groovy) ou o arquivo build.gradle.kts (Kotlin DSL) para incluir seu personal access token (classic). Também é possível configurar o Gradle Groovy e o Kotlin DSL para reconhecer um único pacote ou vários pacotes em um repositório.

Substitua USERNAME pelo seu nome de usuário do GitHub, TOKEN pelo personal access token (classic), REPOSITORY pelo nome do repositório que contém o pacote que deseja publicar e OWNER pelo nome da conta pessoal ou organização no GitHub que é o proprietário do repositório. Como não é permitido usar letras maiúsculas, é preciso usar letras minúsculas no nome do proprietário do repositório, mesmo que o nome do usuário ou da organização no GitHub contenha letras maiúsculas.

Exemplo de uso do Gradle Groovy para um único pacote em um repositório

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

Exemplo de uso do Gradle Groovy para vários pacotes no mesmo repositório

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

Exemplo de uso do Kotlin DSL para um único pacote no mesmo repositório

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

Exemplo de uso do Kotlin DSL para vários pacotes no mesmo repositório

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

Publicando um pacote

Por padrão, o GitHub publica o pacote em um repositório existente com o mesmo nome do pacote. Por exemplo, o GitHub publicará um pacote chamado com.example.test no repositório OWNER/test do GitHub Packages.

Após publicar um pacote, você poderá visualizá-lo no GitHub. Para obter mais informações, confira "Visualizar pacotes".

1. Autenticar para GitHub Packages. Para obter mais informações, confira "Autenticação no GitHub Packages".

2. Depois de criar seu pacote, você poderá publicá-lo.

    gradle publish
   

Usando um pacote publicado

Para usar um pacote publicado a partir de GitHub Packages, adicione o pacote como uma dependência e adicione o repositório ao seu projeto. Para obter mais informações, confira "Como declarar dependências" na documentação do Gradle.

1. Autenticar para GitHub Packages. Para obter mais informações, confira "Autenticação no GitHub Packages".

2. Adicione as dependências do pacote ao arquivo build.gradle (Gradle Groovy) ou ao arquivo build.gradle.kts (Kotlin DSL).

   Exemplo do uso do Gradle Groovy:

   dependencies {
       implementation 'com.example:package'
   }
   

   Exemplo de uso do Kotlin DSL:

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

3. Adicione o repositório ao arquivo build.gradle (Gradle Groovy) ou ao arquivo build.gradle.kts (Kotlin DSL).

   Exemplo do uso do 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")
           }
      }
   }
   

   Exemplo de uso do 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")
           }
       }
   }
   

Leitura adicional

• "Trabalhando com o registro do Apache Maven"
• "Excluir e restaurar um pacote"