Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Uso de CodeArtifact con Gradle
Después de tener el token de autenticación de CodeArtifact en una variable de entorno, como se describe en [Pasar un token de autenticación mediante una variable de entorno](tokens-authentication.md#env-var), siga estas instrucciones para consumir paquetes Maven desde un repositorio de CodeArtifact y publicar nuevos paquetes en él.
**Topics**
+ [Extraer dependencias](#fetching-dependencies)
+ [Obtención de complementos](#fetching-plugins)
+ [Publicar artefactos](#publishing-artifacts)
+ [Ejecutar una compilación de Gradle en IntelliJ IDEA](#gradle-intellij)
## Extraer dependencias
Para obtener las dependencias de CodeArtifact en una compilación de Gradle, use el siguiente procedimiento.
**Para obtener dependencias de CodeArtifact en una compilación de Gradle**
1. Si no lo ha hecho, cree y almacene un token de autenticación de CodeArtifact en una variable de entorno siguiendo el procedimiento descrito en [Pasar un token de autenticación mediante una variable de entorno](tokens-authentication.md#env-var).
1. Añada una sección `maven` a la sección `repositories` del archivo `build.gradle` del proyecto.
```
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
```
La `url` del ejemplo anterior es el punto de conexión de su repositorio de CodeArtifact. Gradle usa el punto de conexión para conectarse al repositorio. En el ejemplo, `my_domain` es el nombre de tu dominio, `111122223333` es el ID del propietario del dominio y `my_repo` es el nombre de su repositorio. Puede recuperar un punto de conexión de su repositorio mediante el comando `get-repository-endpoint` AWS CLI.
Por ejemplo, con un repositorio llamado {{my\_repo}} dentro de un dominio llamado {{my\_domain}}, el comando es el siguiente:
```
aws codeartifact get-repository-endpoint --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format maven
```
El comando `get-repository-endpoint` devolverá el punto de conexión del repositorio:
```
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
```
El objeto `credentials` del ejemplo anterior incluye el token de autenticación de CodeArtifact que creó en el paso 1 y que Gradle usa para autenticarse en CodeArtifact.
**nota**
Si quiere utilizar un punto de conexión de pila doble, use el punto de conexión `codeartifact.{{region}}.on.aws`.
1. (Opcional) Para usar el repositorio de CodeArtifact como la única fuente de las dependencias de su proyecto, elimine cualquier otra sección en `repositories` de `build.gradle`. Si tiene más de un repositorio, Gradle busca las dependencias en cada repositorio en el orden en que aparecen en la lista.
1. Después de configurar el repositorio, puede agregar las dependencias del proyecto a la sección `dependencies` con la sintaxis estándar de Gradle.
```
dependencies {
implementation 'com.google.guava:guava:27.1-jre'
implementation 'commons-cli:commons-cli:1.4'
testImplementation 'org.testng:testng:6.14.3'
}
```
## Obtención de complementos
De forma predeterminada, Gradle resolverá los complementos desde el [portal de complementos de Gradle](https://plugins.gradle.org/) público. Para extraer complementos de un repositorio de CodeArtifact, utilice el siguiente procedimiento.
**Para extraer complementos de un repositorio de CodeArtifact**
1. Si no lo ha hecho, cree y almacene un token de autenticación de CodeArtifact en una variable de entorno siguiendo el procedimiento descrito en [Pasar un token de autenticación mediante una variable de entorno](tokens-authentication.md#env-var).
1. Agregue un bloque `pluginManagement` a su archivo `settings.gradle`. El bloque `pluginManagement` debe aparecer antes de cualquier otra declaración en `settings.gradle`; consulte el siguiente fragmento:
```
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
}
}
}
}
```
Esto garantizará que Gradle resuelva los complementos del repositorio especificado. El repositorio debe tener un repositorio principal con una conexión externa al portal de complementos de Gradle (por ejemplo, `gradle-plugins-store`) para que los complementos de Gradle que se requieren con más frecuencia estén disponibles en la compilación. Para obtener más información, consulte la [documentación de Gradle](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories).
## Publicar artefactos
En esta sección, se describe cómo publicar una biblioteca Java creada con Gradle en un repositorio de CodeArtifact.
Primero, añada el complemento `maven-publish` a la sección `plugins` del archivo `build.gradle` del proyecto.
```
plugins {
id 'java-library'
id 'maven-publish'
}
```
A continuación, añada una sección `publishing` al archivo `build.gradle` del proyecto.
```
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
}
}
}
}
```
El complemento `maven-publish` genera un archivo POM basado en los valores `groupId`, `artifactId` y `version` especificados en la sección `publishing`.
Una vez completados estos cambios en `build.gradle`, ejecute el siguiente comando para crear el proyecto y subirlo al repositorio.
```
./gradlew publish
```
Utilice `list-package-versions` para comprobar que el paquete se ha publicado correctamente.
```
aws codeartifact list-package-versions --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format {{maven}}\
--namespace {{com.company.framework}} --package {{my-package-name}}
```
Código de salida de ejemplo:
```
{
"format": "{{maven}}",
"namespace": "{{com.company.framework}}",
"package": "{{example}}",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
Para obtener más información, consulte estos temas en el sitio web de Gradle:
+ [Building Java Libraries](https://guides.gradle.org/building-java-libraries/)
+ [Publishing a project as a module](https://docs.gradle.org/current/userguide/publishing_setup.html)
## Ejecutar una compilación de Gradle en IntelliJ IDEA
Puede ejecutar una compilación de Gradle en IntelliJ IDEA que extraiga dependencias de CodeArtifact. Para autenticarse con CodeArtifact, debe proporcionar a Gradle un token de autorización de CodeArtifact. Existen tres métodos para proporcionar un token de autenticación.
+ Método 1: almacenar el token de autenticación en `gradle.properties`. Utilice este método si puede sobrescribir o añadir contenido al archivo `gradle.properties`.
+ Método 2: almacenar el token de autenticación en un archivo independiente. Utilice este método si no desea modificar el archivo `gradle.properties`.
+ Método 3: generar un nuevo token de autenticación para cada ejecución ejecutando `aws` como un script en línea en `build.gradle`. Utilice este método si quiere que el script de Gradle busque un nuevo token en cada ejecución. El token no se almacenará en el sistema de archivos.
------
#### [ Token stored in gradle.properties ]
**Método 1: almacenar el token de autenticación en `gradle.properties`**
**nota**
El ejemplo muestra el archivo `gradle.properties` ubicado en `GRADLE_USER_HOME`.
1. Actualice el archivo `build.gradle` con el siguiente fragmento de código:
```
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password "$codeartifactToken"
}
}
}
```
1. Para obtener complementos de CodeArtifact, agregue un bloque `pluginManagement` a su archivo `settings.gradle`. El bloque `pluginManagement` debe aparecer antes de cualquier otra declaración en `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. Obtenga un token de autorización de CodeArtifact:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Escriba el token de autenticación en el archivo `gradle.properties`:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties
```
------
#### [ Token stored in separate file ]
**Método 2: almacenar el token de autenticación en un archivo independiente**
1. Actualice el archivo `build.gradle` con el siguiente fragmento de código:
```
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 obtener complementos de CodeArtifact, agregue un bloque `pluginManagement` a su archivo `settings.gradle`. El bloque `pluginManagement` debe aparecer antes de cualquier otra declaración en `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. Obtenga un token de autorización de CodeArtifact:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Escriba el token de autenticación en el archivo que se especificó en su archivo `build.gradle`:
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > {{file}}
```
------
#### [ Token generated for each run in build.gradle ]
**Método 3: generar un nuevo token de autenticación para cada ejecución ejecutando `aws` como un script en línea en `build.gradle`**
1. Actualice el archivo `build.gradle` con el siguiente fragmento:
```
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 obtener complementos de CodeArtifact, agregue un bloque `pluginManagement` a su archivo `settings.gradle`. El bloque `pluginManagement` debe aparecer antes de cualquier otra declaración en `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
}
}
}
}
```
------