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 Maven
El formato de repositorio Maven lo utilizan muchos lenguajes diferentes, incluidos Java, Kotlin, Scala y Clojure. Es compatible con muchas herramientas de compilación diferentes, como Maven, Gradle, Scala SBT, Apache Ivy y Leiningen.
Hemos probado y confirmado la compatibilidad con CodeArtifact para las siguientes versiones:
+ Última versión de **Maven**: 3.6.3.
+ También se probó la última versión de **Gradle**: 6.4.1. 5.5.1.
+ También se ha probado la última versión de **Clojure**: 1.11.1.
**Topics**
+ [Uso de CodeArtifact con Gradle](maven-gradle.md)
+ [Uso CodeArtifact con mvn](maven-mvn.md)
+ [Usar CodeArtifact con deps.edn](maven-deps.md)
+ [Publicación con curl](maven-curl.md)
+ [Uso de sumas de comprobación de Maven](maven-checksums.md)
+ [Uso de instantáneas de Maven](maven-snapshots.md)
+ [Solicitud de paquetes de Maven desde conexiones ascendentes y externas](maven-upstream-external-connections-request.md)
+ [Solución de problemas de Maven](maven-troubleshooting.md)
# 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\$1repo* dentro de un dominio llamado *my\$1domain*, 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
}
}
}
}
```
------
# Uso CodeArtifact con mvn
El comando `mvn` se usa para ejecutar compilaciones de Maven. En esta sección se muestra cómo `mvn` configurar el uso de un CodeArtifact repositorio.
**Topics**
+ [Extraer dependencias](#fetching-dependencies)
+ [Publicar artefactos](#publishing-artifacts)
+ [Publicación de artefactos de terceros](#publishing-third-party-artifacts)
+ [Restrinja las descargas de dependencias de Maven a un repositorio CodeArtifact](#restrict-maven-downloads)
+ [Información del proyecto Apache Maven](#apache-maven-project-info)
## Extraer dependencias
`mvn`Para configurar la búsqueda de dependencias de un CodeArtifact repositorio, debe editar el archivo de configuración de Maven y, si lo desea`settings.xml`, el POM de su proyecto.
1. Si no lo has hecho, crea y almacena un token de CodeArtifact autenticación 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) para configurar la autenticación en tu repositorio. CodeArtifact
1. En `settings.xml` (normalmente se encuentra en `~/.m2/settings.xml`), añada una sección `` con una referencia a la variable de entorno `CODEARTIFACT_AUTH_TOKEN` para que Maven pase el token en las solicitudes HTTP.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Añade el punto final de la URL de tu CodeArtifact repositorio en un `` elemento. Puede hacerlo en `settings.xml` o en el archivo POM de su proyecto.
Puedes recuperar el punto final de tu repositorio mediante el `get-repository-endpoint` AWS CLI comando.
Por ejemplo, si el nombre de un repositorio está *my\$1repo* dentro de un nombre de dominio*my\$1domain*, el comando es el siguiente:
```
aws codeartifact get-repository-endpoint --domain my_domain --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.us-west-2.amazonaws.com/maven/my_repo/'
```
**nota**
Si quiere utilizar un punto de conexión de pila doble, use el punto de conexión `codeartifact.region.on.aws`.
Añada el punto de conexión del repositorio a `settings.xml` de la siguiente manera.
```
...
default
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
default
...
```
O bien, puede añadir la `` sección a un archivo POM del proyecto CodeArtifact para utilizarla únicamente en ese proyecto.
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
**importante**
Puede usar cualquier valor en el elemento ``, pero debe ser el mismo en los elementos `` y ``. Esto permite incluir las credenciales especificadas en las solicitudes para CodeArtifact.
Después de realizar estos cambios de configuración, puede crear el proyecto.
```
mvn compile
```
Maven registra la URL completa de todas las dependencias que descarga en la consola.
```
[INFO] ------------------< com.example.example:myapp >-------------------
[INFO] Building myapp 1.0
[INFO] --------------------------------[ jar ]---------------------------------
Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.pom
Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.pom (11 kB at 3.9 kB/s)
Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom
Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom
Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/org/apache/commons/commons-parent/42/commons-parent-42.pom (68 kB at 123 kB/s)
Downloading from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.jar
Downloaded from codeartifact: https://.d.codeartifact.us-west-2.amazonaws.com/maven/myrepo/commons-cli/commons-cli/1.4/commons-cli-1.4.jar (54 kB at 134 kB/s)
```
## Publicar artefactos
Para publicar un artefacto de Maven en un CodeArtifact repositorio, también debes editar `~/.m2/settings.xml` y proyectar el POM. `mvn`
1. Si no lo has hecho, crea y almacena un token de CodeArtifact autenticación 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) para configurar la autenticación en tu repositorio. CodeArtifact
1. Agregue una sección `` a `settings.xml` con una referencia a la variable de entorno `CODEARTIFACT_AUTH_TOKEN` para que Maven pase el token en las solicitudes HTTP.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Agregue una sección `` al `pom.xml` de su proyecto.
```
...
codeartifact
codeartifact
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
...
```
Tras realizar estos cambios de configuración, puede crear el proyecto y publicarlo en el repositorio especificado.
```
mvn deploy
```
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:
```
{
"defaultDisplayVersion": null,
"format": "maven",
"namespace": "com.company.framework",
"package": "my-package-name",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
## Publicación de artefactos de terceros
Puedes publicar artefactos de Maven de terceros en un CodeArtifact repositorio con. `mvn deploy:deploy-file` Esto puede resultar útil para los usuarios que desean publicar artefactos y solo tienen archivos JAR y no tienen acceso al código fuente del paquete o a los archivos POM.
El comando `mvn deploy:deploy-file` generará un archivo POM en función de la información pasada en la línea de comandos.
**Publicación de artefactos Maven de terceros**
1. Si no lo has hecho, crea y almacena un token de CodeArtifact autenticación 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) para configurar la autenticación en tu CodeArtifact repositorio.
1. Cree un archivo `~/.m2/settings.xml` con los siguientes contenidos:
```
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
```
1. Ejecute el comando `mvn deploy:deploy-file`:
```
mvn deploy:deploy-file -DgroupId=commons-cli \
-DartifactId=commons-cli \
-Dversion=1.4 \
-Dfile=./commons-cli-1.4.jar \
-Dpackaging=jar \
-DrepositoryId=codeartifact \
-Durl=https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/repo-name/
```
**nota**
El ejemplo anterior publica `commons-cli 1.4`. Modifique los argumentos GroupID, ArtifactID, version y file para publicar un JAR diferente.
Estas instrucciones se basan en los ejemplos de la [guía para implementar un repositorio externo JARs en un repositorio remoto](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html) de la documentación de *Apache Maven*.
## Restrinja las descargas de dependencias de Maven a un repositorio CodeArtifact
Si un paquete no se puede recuperar de un repositorio configurado, de forma predeterminada, el comando `mvn` lo obtiene del central de Maven. Añade el `mirrors` elemento a `settings.xml` para que `mvn` siempre utilices tu CodeArtifact repositorio.
```
...
central-mirror
CodeArtifact Maven Central mirror
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
central
...
```
Si agrega un elemento `mirrors`, también debe tener un elemento `pluginRepository` en su `settings.xml` o `pom.xml`. El siguiente ejemplo busca las dependencias de la aplicación y los complementos de Maven de un repositorio. CodeArtifact
```
...
codeartifact
CodeArtifact Plugins
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/
true
true
...
```
En el siguiente ejemplo, se obtienen las dependencias de las aplicaciones de un CodeArtifact repositorio y se obtienen los complementos de Maven de Maven Central.
```
default
...
central-plugins
Central Plugins
https://repo.maven.apache.org/maven2/
true
true
....
```
## Información del proyecto Apache Maven
Para obtener más información sobre Maven, consulte estos temas en el sitio web del Proyecto Apache Maven:
+ [Setting up Multiple Repositories](https://maven.apache.org/guides/mini/guide-multiple-repositories.html)
+ [Settings Reference](https://maven.apache.org/settings.html)
+ [Distribution Management](https://maven.apache.org/pom.html#Distribution_Management)
+ [Profiles](https://maven.apache.org/pom.html#Profiles)
# Usar CodeArtifact con deps.edn
Se usa `deps.edn` con `clj` para administrar las dependencias de los proyectos de Clojure. En esta sección se muestra cómo configurar `deps.edn` para usar un repositorio de CodeArtifact.
**Topics**
+ [Extraer dependencias](#fetching-dependencies-deps)
+ [Publicar artefactos](#publishing-artifacts-deps)
## Extraer dependencias
Para configurar `Clojure` para recuperar dependencias de un repositorio de CodeArtifact, debe editar el archivo de configuración de Maven, `settings.xml`.
1. En `settings.xml`, añada una sección `` con una referencia a la variable de entorno `CODEARTIFACT_AUTH_TOKEN` para que Clojure pase el token en las solicitudes HTTP.
**nota**
Clojure espera que el archivo settings.xml esté ubicado en `~/.m2/settings.xml`. Si está en otro lugar, cree el archivo en esta ubicación.
```
...
codeartifact
aws
${env.CODEARTIFACT_AUTH_TOKEN}
...
```
1. Si aún no tiene uno, genere un XML POM para su proyecto utilizando `clj -Spom`.
1. En su archivo de configuración `deps.edn`, añada un repositorio que coincida con el identificador del servidor de Maven `settings.xml`.
```
:mvn/repos {
"clojars" nil
"central" nil
"codeartifact" {:url "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/"}
}
```
**nota**
`tools.deps` garantiza que los repositorios `central` y `clojars` se comprueben primero para ver si hay bibliotecas de Maven. Después, se revisarán los demás repositorios listados en `deps.edn`.
Para evitar que se descarguen directamente desde Clojars y Maven Central, hay que configurar `central` y `clojars` en `nil`.
Asegúrese de tener el token de autenticación de CodeArtifact en una variable de entorno (consulte [Pasar un token de autenticación mediante una variable de entorno](tokens-authentication.md#env-var)). Al compilar el paquete después de estos cambios, las dependencias en `deps.edn` se obtendrán de CodeArtifact.
**nota**
Si quiere utilizar un punto de conexión de pila doble, use el punto de conexión `codeartifact.region.on.aws`.
## Publicar artefactos
1. Actualice su configuración de Maven y `deps.edn` para incluir CodeArtifact como un servidor reconocido por Maven (consulte [Extraer dependencias](#fetching-dependencies-deps)). Puede usar una herramienta como [deps-deploy](https://github.com/slipset/deps-deploy) para cargar artefactos en CodeArtifact.
1. En su `build.clj`, añada una tarea `deploy` para cargar los artefactos necesarios en el repositorio `codeartifact` previamente configurado.
```
(ns build
(:require [deps-deploy.deps-deploy :as dd]))
(defn deploy [_]
(dd/deploy {:installer :remote
:artifact "PATH_TO_JAR_FILE.jar"
:pom-file "pom.xml" ;; pom containing artifact coordinates
:repository "codeartifact"}))
```
1. Publique el artefacto ejecutando el comando `clj -T:build deploy`:
Para obtener más información sobre la modificación de los repositorios predeterminados, consulte [Modificación de los repositorios predeterminados](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories) en *Clojure Deps y CLI Reference Rationale*.
# Publicación con curl
En esta sección se muestra cómo utilizar el cliente HTTP `curl` para publicar artefactos de Maven en un repositorio de CodeArtifact. Publicar artefactos con `curl` puede resultar útil si no tiene o no desea instalar el cliente Maven en sus entornos.
**Publicación de un artefacto de Maven con `curl`**
1. Obtenga un token de autorización de CodeArtifact siguiendo los pasos descritos en [Pasar un token de autenticación mediante una variable de entorno](tokens-authentication.md#env-var) y vuelva a estos pasos.
1. Utilice el siguiente comando `curl` para publicar el JAR en un repositorio de CodeArtifact:
En cada uno de los comandos `curl` de este procedimiento, sustituya los siguientes marcadores de posición:
+ Sustituya *my\$1domain* por su nombre de dominio de CodeArtifact.
+ Sustituya *111122223333* por el ID del propietario de su dominio CodeArtifact.
+ Sustituya *us-west-2* por la región en la que reside su dominio de CodeArtifact.
+ Sustituya *my\$1repo* por el nombre de su repositorio de CodeArtifact.
```
curl --request PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/1.0/my-app-1.0.jar \
--user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \
--data-binary @my-app-1.0.jar
```
**importante**
Debe anteponer el valor del parámetro `--data-binary` con un carácter `@`. Al escribir el valor entre comillas, `@` debe incluirse dentro de las comillas.
1. Utilice el siguiente comando `curl` para publicar el POM en un repositorio de CodeArtifact:
```
curl --request PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/1.0/my-app-1.0.pom \
--user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \
--data-binary @my-app-1.0.pom
```
1. En este punto, el artefacto Maven estará en su repositorio de CodeArtifact con un estado de `Unfinished`. Para poder consumir el paquete, debe estar en el estado `Published`. Puede mover el paquete de `Unfinished` a `Published` cargando un archivo `maven-metadata.xml` en el paquete o llamando a la API [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) para cambiar el estado.
1. Opción 1: use el siguiente comando `curl` para añadir un archivo `maven-metadata.xml` al paquete:
```
curl --request PUT https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/com/mycompany/app/my-app/maven-metadata.xml \
--user "aws:$CODEARTIFACT_AUTH_TOKEN" --header "Content-Type: application/octet-stream" \
--data-binary @maven-metadata.xml
```
El siguiente ejemplo muestra el contenido de un archivo `maven-metadata.xml`:
```
com.mycompany.app
my-app
1.0
1.0
1.0
20200731090423
```
1. Opción 2: actualice el estado del paquete a `Published` con la API `UpdatePackageVersionsStatus`.
```
aws codeartifact update-package-versions-status \
--domain my_domain \
--domain-owner 111122223333 \
--repository my_repo \
--format maven \
--namespace com.mycompany.app \
--package my-app \
--versions 1.0 \
--target-status Published
```
Si solo tiene el archivo JAR de un artefacto, puede publicar una versión de paquete consumible en un repositorio de CodeArtifact utilizando `mvn`. Esto puede resultar útil si no tiene acceso al código fuente o al POM del artefacto. Para obtener más información, consulte [Publicación de artefactos de terceros](maven-mvn.md#publishing-third-party-artifacts).
# Uso de sumas de comprobación de Maven
Cuando se publica un artefacto de Maven en un AWS CodeArtifact repositorio, la suma de comprobación asociada a cada *activo* o archivo del paquete se utiliza para validar la carga. Algunos ejemplos de activos son los archivos *jar*, *pom* y *war*. Para cada activo, el artefacto de Maven contiene varios archivos de suma de comprobación que utilizan el nombre del activo con una extensión adicional, como `md5` o `sha1`. Por ejemplo, los archivos de suma de comprobación de un archivo denominado `my-maven-package.jar` podrían ser `my-maven-package.jar.md5` y `my-maven-package.jar.sha1`.
**nota**
Maven usa el término `artifact`. En esta guía, un paquete de Maven es lo mismo que un artefacto de Maven. [Para obtener más información, consulte el paquete.AWS CodeArtifact](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package)
## Almacenamiento de sumas de comprobación
CodeArtifact no almacena las sumas de control de Maven como activos. [Esto significa que las sumas de verificación no aparecen como activos individuales en la salida de la API. ListPackageVersionAssets ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html) En su lugar, las sumas de verificación calculadas por CodeArtifact están disponibles para cada activo en todos los tipos de suma de verificación compatibles. Por ejemplo, parte de la respuesta al solicitar la versión ListPackageVersionAssets del paquete Maven es: `commons-lang:commons-lang 2.1`
```
{
"name": "commons-lang-2.1.jar",
"size": 207723,
"hashes": {
"MD5": "51591549f1662a64543f08a1d4a0cf87",
"SHA-1": "4763ecc9d78781c915c07eb03e90572c7ff04205",
"SHA-256": "2ded7343dc8e57decd5e6302337139be020fdd885a2935925e8d575975e480b9",
"SHA-512": "a312a5e33b17835f2e82e74ab52ab81f0dec01a7e72a2ba58bb76b6a197ffcd2bb410e341ef7b3720f3b595ce49fdd9994ea887ba08ff6fe21b2c714f8c405af"
}
},
{
"name": "commons-lang-2.1.pom",
"size": 9928,
"hashes": {
"MD5": "8e41bacdd69de9373c20326d231c8a5d",
"SHA-1": "a34d992202615804c534953aba402de55d8ee47c",
"SHA-256": "f1a709cd489f23498a0b6b3dfbfc0d21d4f15904791446dec7f8a58a7da5bd6a",
"SHA-512": "1631ce8fe4101b6cde857f5b1db9b29b937f98ba445a60e76cc2b8f2a732ff24d19b91821a052c1b56b73325104e9280382b2520edda4e7696698165c7e09161"
}
},
{
"name": "maven-metadata.xml",
"size": 121,
"hashes": {
"MD5": "11bb3d48d984f2f49cea1e150b6fa371",
"SHA-1": "7ef872be17357751ce65cb907834b6c5769998db",
"SHA-256": "d04d140362ea8989a824a518439246e7194e719557e8d701831b7f5a8228411c",
"SHA-512": "001813a0333ce4b2a47cf44900470bc2265ae65123a8c6b5ac5f2859184608596baa4d8ee0696d0a497755dade0f6bf5e54667215a06ceae1effdfb7a8d30f88"
}
}
```
Aunque las sumas de comprobación no se almacenan como activos, los clientes de Maven pueden publicar y descargar las sumas de comprobación en las ubicaciones esperadas. Por ejemplo, si `commons-lang:commons-lang 2.1` estuviera en un repositorio llamado `maven-repo`, la ruta URL de la suma de comprobación SHA-256 del archivo JAR sería:
```
/maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256
```
Si va a cargar paquetes de Maven existentes (por ejemplo, paquetes previamente almacenados en Amazon S3) CodeArtifact mediante un cliente HTTP genérico, por ejemplo`curl`, no es necesario cargar las sumas de comprobación. CodeArtifact los generará automáticamente. Si desea comprobar que los activos se han cargado correctamente, puede utilizar la operación de la ListPackageVersionAssets API para comparar las sumas de comprobación de la respuesta con los valores de las sumas de control originales de cada activo.
## La suma de comprobación no coincide durante la publicación
Además de los activos y las sumas de comprobación, los artefactos de Maven también contienen un archivo `maven-metadata.xml`. La secuencia de publicación normal de un paquete de Maven es que todos los activos y las sumas de comprobación se carguen primero y, a continuación, se cargue `maven-metadata.xml`. Por ejemplo, la secuencia de publicación de la versión `commons-lang 2.1` del paquete Maven descrita anteriormente, suponiendo que el cliente estuviera configurado para publicar archivos de suma de comprobación SHA-256, sería:
```
PUT commons-lang-2.1.jar
PUT commons-lang-2.1.jar.sha256
PUT commons-lang-2.1.pom
PUT commons-lang-2.1.pom.sha256
PUT maven-metadata.xml
PUT maven-metadata.xml.sha256
```
Al cargar el archivo de suma de control de un activo, como un archivo JAR, la solicitud de carga de la suma de control fallará y recibirá una respuesta de **400 (solicitud incorrecta)** si no coincide el valor de la suma de control cargado y el valor de la suma de control calculado por. CodeArtifact Si el activo correspondiente no existe, la solicitud fallará y generará una respuesta **404 (no encontrado).** Para evitar este error, primero debe cargar el activo y, a continuación, cargar la suma de comprobación.
Cuando `maven-metadata.xml` se carga, CodeArtifact normalmente cambia el estado de la versión del paquete Maven de a. `Unfinished` `Published` Si se detecta una discrepancia en la suma de comprobación de algún activo, CodeArtifact devolverá un **400 (solicitud errónea) en respuesta a la `maven-metadata.xml` solicitud** de publicación. Este error puede provocar que el cliente deje de cargar los archivos para esa versión del paquete. Si esto ocurre y el archivo `maven-metadata.xml` no se carga, no se podrá descargar ningún activo de la versión del paquete que ya se haya cargado. Esto se debe a que el estado de la versión del paquete no está establecido en `Published` y permanece `Unfinished`.
CodeArtifact permite añadir más recursos a una versión de un paquete de Maven incluso después `maven-metadata.xml` de haberla subido y de que el estado de la versión del paquete esté establecido en. `Published` En este estado, una solicitud para cargar un archivo de suma de comprobación que no coincida también fallará y recibirá una respuesta de **400 (solicitud errónea)**. Sin embargo, dado que el estado de la versión del paquete ya está establecido en `Published`, puede descargar cualquier recurso del paquete, incluidos aquellos en los que no se pudo cargar el archivo de suma de comprobación. Al descargar una suma de verificación para un activo en el que no se pudo cargar el archivo de suma de verificación, el valor de la suma de verificación que reciba el cliente será el valor de la suma de verificación calculado en CodeArtifact función de los datos del activo cargado.
CodeArtifact Las comparaciones de sumas de control distinguen mayúsculas de minúsculas y las sumas de verificación calculadas por ellas se escriben en minúsculas. CodeArtifact Por lo tanto, si `909FA780F76DA393E992A3D2D495F468` se carga la suma de comprobación, se producirá un error y la suma de comprobación no coincidirá porque CodeArtifact no se considerará igual a. `909fa780f76da393e992a3d2d495f468`
## Recuperarse de discrepancias en las sumas de comprobación
Si se produce un error al cargar una suma de comprobación debido a una discrepancia en la suma de comprobación, intente realizar una de las siguientes acciones para recuperarla:
+ Vuelva a ejecutar el comando que publica el artefacto de Maven. Esto podría funcionar si un problema de red dañara el archivo de suma de comprobación. Si esto resuelve el problema de la red, la suma de comprobación coincide y la descarga se ha realizado correctamente.
+ Elimine la versión del paquete y, a continuación, vuelva a publicarla. Para obtener más información, consulte [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)la *referencia de la CodeArtifact API de AWS*.
# Uso de instantáneas de Maven
Una *instantánea* de Maven es una versión especial de un paquete de Maven que hace referencia al código de rama de producción más reciente. Es una versión de desarrollo que precede a la versión de lanzamiento final. Puede identificar una versión instantánea de un paquete de Maven por el sufijo `SNAPSHOT` que se adjunta a la versión del paquete. Por ejemplo, la instantánea de la versión `1.1` es `1.1-SNAPSHOT`. Para obtener más información, consulte [What is a SNAPSHOT version?](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) en el sitio web del Proyecto Apache Maven.
AWS CodeArtifact admite la publicación y el consumo de instantáneas de Maven. Las instantáneas únicas que utilizan un número de versión basado en el tiempo son las únicas instantáneas compatibles. CodeArtifact no admite las instantáneas no únicas generadas por los clientes de Maven 2. Puedes publicar una instantánea de Maven compatible en cualquier repositorio. CodeArtifact
**Topics**
+ [Publicación de instantáneas en CodeArtifact](#maven-snapshot-publishing)
+ [Consumo de versiones de instantánea](#maven-consuming-snapshot-versions)
+ [Eliminación de versiones de instantánea](#maven-deleting-snapshot-versions)
+ [Publicación de instantáneas con curl](#maven-snapshot-publishing-curl)
+ [Instantáneas y conexiones externas](#maven-snapshot-external-connections)
+ [Instantáneas y repositorios originales](#maven-snapshot-upstream-repositories)
## Publicación de instantáneas en CodeArtifact
AWS CodeArtifact admite los patrones de solicitud que los clientes, por ejemplo`mvn`, utilizan al publicar instantáneas. Por eso, puede seguir la documentación de su herramienta de compilación o administrador de paquetes sin tener una comprensión detallada de cómo se publican las instantáneas de Maven. Si está haciendo algo más complejo, en esta sección se describe en detalle cómo CodeArtifact gestiona las instantáneas.
Cuando se publica una instantánea de Maven en un CodeArtifact repositorio, su versión anterior se conserva en una nueva versión denominada compilación. Cada vez que se publica una instantánea de Maven, se crea una nueva versión de compilación. Todas las versiones anteriores de una instantánea se mantienen en sus versiones de compilación. Cuando se publica una instantánea de Maven, el estado de la versión del paquete se establece en `Published` y el estado de la compilación que contiene la versión anterior se establece en `Unlisted`. Este comportamiento solo se aplica a las versiones del paquete de Maven en las que la versión del paquete tiene un sufijo `-SNAPSHOT`.
Por ejemplo, las versiones instantáneas de un paquete maven denominado se `com.mycompany.myapp:pkg-1` cargan en un CodeArtifact repositorio denominado. `my-maven-repo` La versión de instantánea es `1.0-SNAPSHOT`. Hasta el momento, no se ha publicado ninguna versión de `com.mycompany.myapp:pkg-1`. En primer lugar, los activos de la versión inicial se publican en las siguientes rutas:
```
PUT maven/my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210728.194552-1.jar
PUT maven/my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210728.194552-1.pom
```
Tenga en cuenta que la marca de tiempo `20210728.194552-1` la genera el cliente que publica las compilaciones instantáneas.
Una vez cargados los archivos .pom y .jar, la única versión de `com.mycompany.myapp:pkg-1` que existe en el repositorio es `1.0-20210728.194552-1`. Esto ocurre aunque lo sea la versión especificada en la ruta anterior sea `1.0-SNAPSHOT`. El estado de la versión del paquete en este momento es `Unfinished`.
```
aws codeartifact list-package-versions --domain my-domain --repository \
my-maven-repo --package pkg-1 --namespace com.mycompany.myapp --format maven
{
"versions": [
{
"version": "1.0-20210728.194552-1",
"revision": "GipMW+599JmwTcTLaXo9YvDsVQ2bcrrk/02rWJhoKUU=",
"status": "Unfinished"
}
],
"defaultDisplayVersion": null,
"format": "maven",
"package": "pkg-1",
"namespace": "com.mycompany.myapp"
}
```
A continuación, el cliente carga el archivo `maven-metadata.xml` de la versión del paquete:
```
PUT my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml
```
Cuando el archivo maven-metadata.xml se carga correctamente, CodeArtifact crea la versión `1.0-SNAPSHOT` del paquete y establece la `1.0-20210728.194552-1` versión en. `Unlisted`
```
aws codeartifact list-package-versions --domain my-domain --repository \
my-maven-repo --package pkg-1 --namespace com.mycompany.myapp --format maven
{
"versions": [
{
"version": "1.0-20210728.194552-1",
"revision": "GipMW+599JmwTcTLaXo9YvDsVQ2bcrrk/02rWJhoKUU=",
"status": "Unlisted"
},
{
"version": "1.0-SNAPSHOT",
"revision": "tWu8n3IX5HR82vzVZQAxlwcvvA4U/+S80edWNAkil24=",
"status": "Published"
}
],
"defaultDisplayVersion": "1.0-SNAPSHOT",
"format": "maven",
"package": "pkg-1",
"namespace": "com.mycompany.myapp"
}
```
En este punto, la versión de instantánea `1.0-SNAPSHOT` se puede consumir en una compilación. Si bien hay dos versiones de `com.mycompany.myapp:pkg-1` en el repositorio `my-maven-repo`, ambas contienen los mismos activos.
```
aws codeartifact list-package-version-assets --domain my-domain --repository \
my-maven-repo --format maven --namespace com.mycompany.myapp \
--package pkg-1 --package-version 1.0-SNAPSHOT--query 'assets[*].name'
[
"pkg-1-1.0-20210728.194552-1.jar",
"pkg-1-1.0-20210728.194552-1.pom"
]
```
Ejecutar el mismo comando `list-package-version-assets` como se mostró anteriormente con el parámetro `--package-version` cambiado a `1.0-20210728.194552-1` da como resultado una salida idéntica.
A medida que se añaden compilaciones adicionales de `1.0-SNAPSHOT` al repositorio, se crea una nueva versión del paquete `Unlisted` para cada nueva compilación. Los activos de la versión `1.0-SNAPSHOT` se actualizan cada vez para que la versión siempre haga referencia a la última compilación de esa versión. La actualización de `1.0-SNAPSHOT` con los activos más recientes se inicia cargando el archivo `maven-metadata.xml` de la nueva compilación.
## Consumo de versiones de instantánea
Si solicita una instantánea, se devuelve la versión con el estado `Published`. Esta es siempre la versión más reciente de la instantánea de Maven. También puede solicitar una compilación concreta de una instantánea utilizando el número de versión de la compilación (por ejemplo, `1.0-20210728.194552-1`) en lugar de la versión de la instantánea (por ejemplo, `1.0-SNAPSHOT`) en la ruta URL. Para ver las versiones compiladas de una instantánea de Maven, usa la [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API de la *Guía de CodeArtifact API* y establece el parámetro de estado en. `Unlisted`
## Eliminación de versiones de instantánea
Para eliminar todas las versiones compiladas de una instantánea de Maven, usa la [DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API y especifica las versiones que deseas eliminar.
## Publicación de instantáneas con curl
Si tiene versiones instantáneas existentes almacenadas en Amazon Simple Storage Service (Amazon S3) o en otro producto de repositorio de artefactos, puede que desee volver a publicarlas en. AWS CodeArtifact Debido a la compatibilidad CodeArtifact con las instantáneas de Maven (consulte[Publicación de instantáneas en CodeArtifact](#maven-snapshot-publishing)), publicar las instantáneas con un cliente HTTP genérico, por ejemplo, `curl` es más complejo que publicar las versiones de lanzamiento de Maven, tal como se describe en. [Publicación con curl](maven-curl.md) Tenga en cuenta que esta sección no es relevante si está creando e implementando versiones instantáneas con un cliente Maven como `mvn` o `gradle`. Debe seguir la documentación de ese cliente.
La publicación de una versión instantánea implica publicar una o más compilaciones de una versión instantánea. Si hay *n* compilaciones de una versión instantánea, habrá *n \$1 1 CodeArtifact versiones: *n** versiones de compilación, todas con el estado de`Unlisted`, y una versión instantánea (la última compilación publicada) con el estado de. CodeArtifact `Published` La versión instantánea (es decir, la versión con una cadena de versión que contiene «-SNAPSHOT») contiene un conjunto de activos idéntico al de la última compilación publicada. La forma más sencilla de crear esta estructura usando `curl` es la siguiente:
1. Publique todos los activos de todas las compilaciones utilizando `curl`.
1. Publique el archivo `maven-metadata.xml` de la última compilación (es decir, la compilación con la marca de fecha y hora más reciente) con `curl`. Esto creará una versión con «`-SNAPSHOT`» en la cadena de la versión y con el conjunto correcto de activos.
1. Usa la [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API para establecer el estado de todas las versiones de compilación que no sean las más recientes. `Unlisted`
Use los siguientes comandos `curl` para publicar activos de instantáneas (como archivos.jar y .pom) para la versión `1.0-SNAPSHOT` de instantánea de un paquete `com.mycompany.app:pkg-1`:
```
curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \
-X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210729.171330-2.jar \
--data-binary @pkg-1-1.0-20210728.194552-1.jar
```
```
curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \
-X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/pkg-1-1.0-20210729.171330-2.pom \
--data-binary @pkg-1-1.0-20210728.194552-1.pom
```
Al usar estos ejemplos:
+ *my\$1domain*Sustitúyalo por tu nombre CodeArtifact de dominio.
+ *111122223333*Sustitúyelo por el Cuenta de AWS ID del propietario de su CodeArtifact dominio.
+ *us-west-2*Sustitúyalo por el nombre Región de AWS en el que se encuentra tu CodeArtifact dominio.
+ *my\$1maven\$1repo*Sustitúyalo por el nombre de tu CodeArtifact repositorio.
**importante**
Debe anteponer el valor del parámetro `--data-binary` con el carácter `@`. Al escribir el valor entre comillas, `@` debe incluirse dentro de las comillas.
Es posible que tenga que cargar más de dos recursos para cada compilación. Por ejemplo, puede haber archivos Javadoc y JAR de origen además del JAR principal y `pom.xml`. No es necesario publicar archivos de suma de verificación para los activos de la versión del paquete, ya que genera CodeArtifact automáticamente sumas de verificación para cada activo cargado. Para verificar que los activos se cargaron correctamente, busque las sumas de verificación generadas mediante el comando `list-package-version-assets` y compárelas con las sumas de verificación originales. Para obtener más información sobre cómo se gestionan CodeArtifact las sumas de comprobación de Maven, consulte. [Uso de sumas de comprobación de Maven](maven-checksums.md)
Utilice el siguiente comando curl para publicar el archivo `maven-metadata.xml` de la última versión de compilación:
```
curl --user "aws:$CODEARTIFACT_AUTH_TOKEN" -H "Content-Type: application/octet-stream" \
-X PUT https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_maven_repo/com/mycompany/app/pkg-1/1.0-SNAPSHOT/maven-metadata.xml \
--data-binary @maven-metadata.xml
```
El archivo `maven-metadata.xml` debe hacer referencia al menos a uno de los activos de la última versión de compilación del elemento ``. Además, el valor `` debe estar presente y debe coincidir con la marca de tiempo de los nombres de los archivos de los activos. Por ejemplo, para la compilación `20210729.171330-2` publicada anteriormente, el contenido de `maven-metadata.xml` sería:
```
com.mycompany.app
pkg-1
1.0-SNAPSHOT
20210729.171330
2
20210729171330
jar
1.0-20210729.171330-2
20210729171330
pom
1.0-20210729.171330-2
20210729171330
```
Una vez publicada `maven-metadata.xml`, el último paso consiste en configurar todas las demás versiones de compilación (es decir, todas las versiones de compilación excepto la última) para que tengan un estado de versión de paquete de `Unlisted`. Por ejemplo, si la versión `1.0-SNAPSHOT` tiene dos compilaciones, siendo la primera compilación `20210728.194552-1`, el comando para configurar esa compilación en `Unlisted` es:
```
aws codeartifact update-package-versions-status --domain my-domain --domain-owner 111122223333 \
--repository my-maven-repo --format maven --namespace com.mycompany.app --package pkg-1 \
--versions 1.0-20210728.194552-1 --target-status Unlisted
```
## Instantáneas y conexiones externas
Las instantáneas de Maven no se pueden obtener de un repositorio público de Maven a través de una conexión externa. AWS CodeArtifact solo admite la importación de versiones de lanzamiento de Maven.
## Instantáneas y repositorios originales
En general, las instantáneas de Maven funcionan de la misma manera que las versiones de lanzamiento de Maven cuando se utilizan con repositorios originales, pero existe una limitación si planea publicar instantáneas de la misma versión de paquete en dos repositorios que tienen una relación ascendente. Por ejemplo, supongamos que hay dos repositorios en un AWS CodeArtifact dominio `R` y`U`, donde `U` hay un upstream de. `R` Si publicas una nueva versión`R`, cuando un cliente de Maven solicite la última compilación de esa versión instantánea, CodeArtifact devolverá la última versión de. `U` Esto puede chocar, porque la última versión ya está disponible en `R`, no en `U`. Hay dos formas de evitar esto:
1. No publique compilaciones de una versión de instantánea como, por ejemplo, `1.0-SNAPSHOT` en `R` si existe `1.0-SNAPSHOT` en `U`.
1. Usa los controles de origen CodeArtifact del paquete para deshabilitar las secuencias ascendentes de ese paquete. `R` Esto último le va a permitir publicar compilaciones propias de `1.0-SNAPSHOT` en `R`, pero también evitará que `R` obtenga otras versiones de dicho paquete desde `U` que ya no se conserven.
# Solicitud de paquetes de Maven desde conexiones ascendentes y externas
## Importación de nombres de activos estándar
Al importar una versión de paquete de Maven desde un repositorio público, como Maven Central, AWS CodeArtifact intenta importar todos los activos de esa versión de paquete. Como se describe en [Solicitar una versión de paquete con repositorios ascendentes](repo-upstream-behavior.md), la importación se produce cuando:
+ Un cliente solicita un activo de Maven desde un repositorio. CodeArtifact
+ La versión del paquete aún no está presente en el repositorio ni en sus fuentes de distribución.
+ Hay una conexión externa accesible a un repositorio público de Maven.
Aunque el cliente solo haya solicitado un activo, CodeArtifact intenta importar todos los activos que encuentra para esa versión del paquete. La forma CodeArtifact de descubrir qué activos están disponibles para una versión de paquete de Maven depende del repositorio público en particular. Algunos repositorios públicos de Maven admiten la solicitud de una lista de activos, pero otros no. Para los repositorios que no proporcionan una forma de enumerar los activos, CodeArtifact genera un conjunto de nombres de activos que probablemente existan. Por ejemplo, cuando se solicite cualquier activo de la versión `junit 4.13.2` del paquete Maven, CodeArtifact intentará importar los siguientes activos:
+ `junit-4.13.2.pom`
+ `junit-4.13.2.jar`
+ `junit-4.13.2-javadoc.jar`
+ `junit-4.13.2-sources.jar`
## Importación de nombres de activos no estándar
Cuando un cliente de Maven solicita un activo que no coincide con uno de los patrones descritos anteriormente, CodeArtifact comprueba si ese activo está presente en el repositorio público. Si el activo está presente, se importará y se añadirá al registro de versiones del paquete existente, si existe alguno. Por ejemplo, la versión `com.android.tools.build:aapt2 7.3.1-8691043` del paquete Maven contiene los siguientes activos:
+ `aapt2-7.3.1-8691043.pom`
+ `aapt2-7.3.1-8691043-windows.jar`
+ `aapt2-7.3.1-8691043-osx.jar`
+ `aapt2-7.3.1-8691043-linux.jar`
Cuando un cliente solicita el archivo POM y no puede enumerar los activos de la versión del paquete, el POM será el único activo importado. CodeArtifact Esto se debe a que ninguno de los demás activos coincide con los patrones de nombres de activos estándar. Sin embargo, cuando el cliente solicite uno de los activos del JAR, ese activo se importará y se agregará a la versión del paquete existente almacenada en ella CodeArtifact. Las versiones de los paquetes tanto en el repositorio más avanzado (el repositorio en el que el cliente realizó la solicitud) como en el repositorio con la conexión externa adjunta se actualizarán para incluir el nuevo activo, tal y como se describe en [Retención de paquetes de repositorios ascendentes](repo-upstream-behavior.md#package-retention-upstream-repos).
Normalmente, una vez que la versión de un paquete se conserva en un CodeArtifact repositorio, no se ve afectada por los cambios en los repositorios anteriores. Para obtener más información, consulte [Retención de paquetes de repositorios ascendentes](repo-upstream-behavior.md#package-retention-upstream-repos). Sin embargo, el comportamiento de los activos de Maven con nombres no estándar descritos anteriormente es una excepción a esta regla. Si bien la versión posterior del paquete no cambiará sin que un cliente solicite un activo adicional, en esta situación, la versión del paquete retenido se modifica después de ser retenida inicialmente y, por lo tanto, no es inmutable. Este comportamiento es necesario porque, de lo contrario, no se podría acceder a los activos de Maven con nombres no estándar. CodeArtifact Este comportamiento también se activa si se añaden a una versión de paquete de Maven en un repositorio público después de conservar la versión del paquete en un repositorio. CodeArtifact
## Comprobar el origen de los activos
Al agregar un nuevo activo a una versión de paquete de Maven previamente retenida, CodeArtifact confirma que el origen de la versión de paquete retenida es el mismo que el origen del nuevo activo. Esto evita crear una versión de paquete «mixta» en la que los diferentes activos se originen en diferentes repositorios públicos. Sin esta comprobación, podría producirse una mezcla de activos si la versión de un paquete de Maven se publica en más de un repositorio público y esos repositorios forman parte del gráfico ascendente de un CodeArtifact repositorio.
## Importación de nuevos activos y el estado de las versiones de los paquetes en los repositorios originales
El [estado](packages-overview.md#package-version-status) de las versiones de paquetes de los repositorios ascendentes puede impedir que se conserven esas versiones en los repositorios CodeArtifact descendentes.
Por ejemplo, supongamos que un dominio tiene tres repositorios: `repo-A`, `repo-B` y `repo-C`, donde `repo-B` es una fuente ascendente de `repo-A` y `repo-C` ascendente de `repo-B`.
![\[Diagrama de cómo funcionan los activos y las versiones de paquetes nuevos en los repositorios originales.\]](http://docs.aws.amazon.com/es_es/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png)
La versión de paquete `7.3.1` del paquete `com.android.tools.build:aapt2` de Maven está presente en `repo-B` y tiene un estado de `Published`. No está presente en `repo-A`. Si un cliente solicita un activo de esta versión de paquete de `repo-A`, la respuesta será 200 (OK) y se conservará la versión `7.3.1` del paquete de Maven en `repo-A`. Sin embargo, si el estado de la versión del paquete `7.3.1` en `repo-B` es `Archived` o `Disposed`, la respuesta será 404 (No encontrado) porque los activos de las versiones del paquete en esos dos estados no se pueden descargar.
Tenga en cuenta que si configura el [control de origen del paquete](package-origin-controls.md) como `upstream=BLOCK` en `com.android.tools.build:aapt2`, `repo-A`, `repo-B` y `repo-C` evitarán que se obtengan nuevos recursos para todas las versiones de ese paquete de `repo-A`, independientemente del estado de la versión del paquete.
# Solución de problemas de Maven
La siguiente información puede ayudarle a solucionar problemas comunes con Maven y CodeArtifact.
## Deshabilite las transferencias paralelas para corregir el error 429: demasiadas solicitudes
A partir de la versión 3.9.0, Maven carga los artefactos del paquete en paralelo (hasta 5 archivos a la vez). Esto puede provocar que CodeArtifact responda ocasionalmente con un código de respuesta de error 429 (Demasiadas solicitudes). Si encuentra este error, puede desactivar las transferencias paralelas para solucionarlo.
Para deshabilitar las transferencias paralelas, establezca la propiedad `aether.connector.basic.parallelPut` en `false` en su perfil en su archivo `settings.xml` como se muestra en el siguiente ejemplo:
```
default
false
```
Para obtener más información, consulte las [opciones de configuración de Artifact Resolver](https://maven.apache.org/resolver/configuration.html) en la documentación de Maven.