As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usar o CodeArtifact com o Gradle
Depois que o token de autenticação do CodeArtifact estiver em uma variável de ambiente, conforme descrito em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var), siga estas instruções para consumir pacotes Maven e publicar novos pacotes em um repositório do CodeArtifact.
**Topics**
+ [Buscar dependências](#fetching-dependencies)
+ [Buscar plug-ins](#fetching-plugins)
+ [Publicar artefatos](#publishing-artifacts)
+ [Executar uma compilação do Gradle no IntelliJ IDEA](#gradle-intellij)
## Buscar dependências
Para buscar dependências do CodeArtifact em uma compilação do Gradle, use o procedimento a seguir.
**Para buscar dependências do CodeArtifact em uma compilação do Gradle**
1. Caso contrário, crie e armazene um token de autorização do CodeArtifact em uma variável de ambiente seguindo o procedimento em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var).
1. Adicione uma seção `maven` à seção `repositories` no arquivo `build.gradle` do projeto.
```
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
```
O `url` exemplo anterior é o endpoint do seu repositório do CodeArtifact. O Gradle usa o endpoint para se conectar ao repositório. No exemplo, `my_domain` é o nome do seu domínio; `111122223333`, o ID do proprietário do domínio e `my_repo`, o nome do seu repositório. Você pode recuperar o endpoint de um repositório usando o comando `get-repository-endpoint` AWS CLI.
Por exemplo, com um repositório chamado {{my\_repo}} dentro de um domínio chamado {{my\_domain}}, o comando é o seguinte:
```
aws codeartifact get-repository-endpoint --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format maven
```
O comando `get-repository-endpoint` retornará o endpoint do repositório:
```
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
```
O objeto `credentials` no exemplo anterior inclui o token de autorização do CodeArtifact criado na Etapa 1, que o Gradle usa para se autenticar no CodeArtifact.
**nota**
Para usar um endpoint de pilha dupla, use o endpoint `codeartifact.{{region}}.on.aws`.
1. (Opcional) - Para usar o repositório do CodeArtifact como a única fonte para as dependências do seu projeto, remova todas as outras seções de `repositories` `build.gradle`. Se você tiver mais de um repositório, o Gradle pesquisará dependências em cada repositório, na ordem em que estão listadas.
1. Depois de configurar o repositório, você pode adicionar dependências do projeto à seção `dependencies` com a sintaxe padrão do Gradle.
```
dependencies {
implementation 'com.google.guava:guava:27.1-jre'
implementation 'commons-cli:commons-cli:1.4'
testImplementation 'org.testng:testng:6.14.3'
}
```
## Buscar plug-ins
Por padrão, o Gradle resolverá plug-ins do [Portal de plug-ins do Gradle](https://plugins.gradle.org/) público. Para extrair plug-ins de um repositório do CodeArtifact, use o procedimento a seguir.
**Para extrair plug-ins de um repositório do CodeArtifact**
1. Caso contrário, crie e armazene um token de autorização do CodeArtifact em uma variável de ambiente seguindo o procedimento em [Passar um token de autenticação usando uma variável de ambiente](tokens-authentication.md#env-var).
1. Adicione um bloco `pluginManagement` ao seu arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`; consulte o seguinte trecho:
```
pluginManagement {
repositories {
maven {
name 'my_repo'
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username 'aws'
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
}
}
```
Isso garantirá que o Gradle resolva plug-ins do repositório especificado. O repositório deve ter um repositório upstream com uma conexão externa com o Portal de plug-ins do Gradle (por exemplo, `gradle-plugins-store`) para que os plug-ins do Gradle normalmente exigidos estejam disponíveis para a compilação. Para obter mais informações, consulte a [documentação do Gradle](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories).
## Publicar artefatos
Esta seção descreve como publicar uma biblioteca Java criada com o Gradle em um repositório do CodeArtifact.
Primeiro, adicione o plug-in `maven-publish` à seção `plugins` do arquivo `build.gradle` do projeto.
```
plugins {
id 'java-library'
id 'maven-publish'
}
```
Em seguida, adicione uma seção `publishing` ao arquivo `build.gradle` do projeto.
```
publishing {
publications {
mavenJava(MavenPublication) {
groupId = '{{group-id}}'
artifactId = '{{artifact-id}}'
version = '{{version}}'
from components.java
}
}
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
}
}
```
O plug-in `maven-publish` gera um arquivo POM com base no `groupId`, `artifactId` e `version` especificados na seção `publishing`.
Depois que essas alterações em `build.gradle` forem concluídas, execute o comando a seguir para criar o projeto e carregá-lo no repositório.
```
./gradlew publish
```
Use `list-package-versions` para verificar se o pacote foi publicado com sucesso.
```
aws codeartifact list-package-versions --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format {{maven}}\
--namespace {{com.company.framework}} --package {{my-package-name}}
```
Exemplo de resultado:
```
{
"format": "{{maven}}",
"namespace": "{{com.company.framework}}",
"package": "{{example}}",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
Para obter mais informações, consulte os tópicos a seguir no site do Gradle:
+ [Criar bibliotecas Java](https://guides.gradle.org/building-java-libraries/)
+ [Publicar um projeto como um módulo](https://docs.gradle.org/current/userguide/publishing_setup.html)
## Executar uma compilação do Gradle no IntelliJ IDEA
Você pode executar uma compilação do Gradle no IntelliJ IDEA que extraia dependências do CodeArtifact. Para se autenticar com o CodeArtifact, você precisa fornecer ao Gradle um token de autorização do CodeArtifact. Há três métodos para fornecer um token de autorização.
+ Método 1: armazenar o token de autorização em `gradle.properties`. Use esse método se você conseguir fazer a substituição ou adição ao conteúdo do arquivo `gradle.properties`.
+ Método 2: armazenar o token de autorização em um arquivo separado. Use esse método se você não quiser modificar o arquivo `gradle.properties`.
+ Método 3: gerar um novo token de autorização para cada execução usando `aws` como um script em linha no `build.gradle`. Use esse método se quiser que o script do Gradle busque um novo token a cada execução. O token não será armazenado no sistema de arquivos.
------
#### [ Token stored in gradle.properties ]
**Método 1: armazenar o token de autorização em `gradle.properties`**
**nota**
O exemplo mostra o arquivo `gradle.properties` localizado em `GRADLE_USER_HOME`.
1. Atualize o arquivo `build.gradle` com o seguinte trecho:
```
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password "$codeartifactToken"
}
}
}
```
1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`.
```
pluginManagement {
repositories {
maven {
name 'my_repo'
url 'https://{{my_domain}}-{{111122223333}}.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username 'aws'
password "$codeartifactToken"
}
}
}
}
```
1. Obtenha um token de autorização do CodeArtifact:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Grave o token de autorização no arquivo `gradle.properties`:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties
```
------
#### [ Token stored in separate file ]
**Método 2: armazenar o token de autorização em um arquivo separado**
1. Atualize o arquivo `build.gradle` com o seguinte trecho:
```
def props = new Properties()
file("{{file}}").withInputStream { props.load(it) }
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password props.getProperty("codeartifactToken")
}
}
}
```
1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`.
```
pluginManagement {
def props = new Properties()
file("{{file}}").withInputStream { props.load(it) }
repositories {
maven {
name 'my_repo'
url 'https://{{my_domain}}-{{111122223333}}.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username 'aws'
password props.getProperty("codeartifactToken")
}
}
}
}
```
1. Obtenha um token de autorização do CodeArtifact:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Grave o token de autorização no arquivo que foi especificado em seu arquivo `build.gradle`:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > {{file}}
```
------
#### [ Token generated for each run in build.gradle ]
**Método 3: gerar um novo token de autenticação para cada execução usando `aws` como um script em linha no `build.gradle`**
1. Atualize o arquivo `build.gradle` com o seguinte trecho:
```
def codeartifactToken = "aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}".execute().text
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password codeartifactToken
}
}
}
```
1. Para obter plug-ins do CodeArtifact, adicione um bloco `pluginManagement` ao arquivo `settings.gradle`. O bloco `pluginManagement` deve aparecer antes de qualquer outra declaração em `settings.gradle`.
```
pluginManagement {
def codeartifactToken = "aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}".execute().text
repositories {
maven {
name 'my_repo'
url 'https://{{my_domain}}-{{111122223333}}.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username 'aws'
password codeartifactToken
}
}
}
}
```
------