Skip to main content

Trabalhando com o registro do Gradle

Você pode configurar o Gradle para publicar pacotes no registro do Gradle de GitHub Packages e usar pacotes armazenados em GitHub Packages como dependências de um projeto Java.

Quem pode usar esse recurso?

O GitHub Packages está disponível com GitHub Free, GitHub Pro, GitHub Free para organizações, GitHub Team, GitHub Enterprise Cloud e GitHub Enterprise Server 3.0 ou superior.
O GitHub Packages não está disponível para repositórios privados de contas que utilizam planos antigos por-repositório. Além disso, contas que usam planos por repositório herdados não podem acessar Registros que dão suporte a permissões granulares, pois essas contas são cobradas pelo repositório. Para ver a lista dos registros que dão suporte a permissões granulares, confira "Sobre permissões para o GitHub Packages". Para mais informações, confira "Planos do GitHub".

Autenticar-se no GitHub Packages

O GitHub Packages dá suporte apenas à autenticação que usa um personal access token (classic). Para obter mais informações, confira "Gerenciar seus tokens de acesso pessoal".

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.

Observação: O GitHub Packages dá suporte às versões de SNAPSHOT do Apache Maven. Para usar o repositório do GitHub Packages para baixar artefatos SNAPSHOT, habilite SNAPSHOTS no POM do projeto de consumo ou no arquivo ~/.m2/settings.xml. Para obter um exemplo, confira "Trabalhando com o registro do Apache Maven".

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