Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Utilisation CodeArtifact avec Maven Le format de dépôt Maven est utilisé par de nombreux langages, notamment Java, Kotlin, Scala et Clojure. Il est pris en charge par de nombreux outils de construction différents, notamment Maven, Gradle, Scala SBT, Apache Ivy et Leiningen. Nous avons testé et confirmé la compatibilité avec CodeArtifact les versions suivantes : + Dernière version **de Maven** : 3.6.3. + Dernière version de **Gradle** : 6.4.1. 5.5.1 a également été testée. + La dernière version de **Clojure** : 1.11.1 a également été testée. **Topics** + [Utiliser CodeArtifact avec Gradle](maven-gradle.md) + [Utiliser CodeArtifact avec MVN](maven-mvn.md) + [À utiliser CodeArtifact avec deps.edn](maven-deps.md) + [Publier avec curl](maven-curl.md) + [Utiliser les checksums Maven](maven-checksums.md) + [Utiliser les instantanés Maven](maven-snapshots.md) + [Demande de packages Maven depuis des connexions en amont et externes](maven-upstream-external-connections-request.md) + [Résolution des problèmes liés à Maven](maven-troubleshooting.md) # Utiliser CodeArtifact avec Gradle Une fois que vous avez le jeton d' CodeArtifact authentification dans une variable d'environnement, comme décrit dans [Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var), suivez ces instructions pour utiliser les packages Maven depuis un référentiel et y publier de nouveaux packages. CodeArtifact **Topics** + [Récupérer les dépendances](#fetching-dependencies) + [Plug-ins de récupération](#fetching-plugins) + [Publier des artefacts](#publishing-artifacts) + [Exécuter une compilation Gradle dans IntelliJ IDEA](#gradle-intellij) ## Récupérer les dépendances Pour récupérer les dépendances CodeArtifact dans une version Gradle, utilisez la procédure suivante. **Pour récupérer les dépendances CodeArtifact dans une version Gradle** 1. Si ce n'est pas le cas, créez et stockez un jeton d' CodeArtifact authentification dans une variable d'environnement en suivant la procédure décrite dans[Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var). 1. Ajoutez une `maven` section à la `repositories` section du `build.gradle` fichier de projet. ``` maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password System.env.CODEARTIFACT_AUTH_TOKEN } } ``` `url`Dans l'exemple précédent, il s'agit du point de terminaison de votre CodeArtifact dépôt. Gradle utilise le point de terminaison pour se connecter à votre référentiel. Dans l'exemple, `my_domain` il s'agit du nom de votre domaine, `111122223333` de l'identifiant du propriétaire du domaine et `my_repo` du nom de votre référentiel. Vous pouvez récupérer le point de terminaison d'un dépôt à l'aide de la `get-repository-endpoint` AWS CLI commande. Par exemple, avec un dépôt nommé *my\$1repo* dans un domaine nommé*my\$1domain*, la commande est la suivante : ``` aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven ``` La `get-repository-endpoint` commande renverra le point de terminaison du référentiel : ``` url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' ``` L'`credentials`objet de l'exemple précédent inclut le jeton d' CodeArtifact authentification que vous avez créé à l'étape 1 et que Gradle utilise pour s'authentifier. CodeArtifact **Note** Pour utiliser un point de terminaison à double pile, utilisez le `codeartifact.region.on.aws` point de terminaison. 1. (Facultatif) - Pour utiliser le CodeArtifact référentiel comme seule source pour les dépendances de votre projet, supprimez toutes les autres sections `repositories` de`build.gradle`. Si vous avez plusieurs référentiels, Gradle recherche les dépendances dans chaque référentiel dans l'ordre dans lequel elles sont répertoriées. 1. Après avoir configuré le référentiel, vous pouvez ajouter des dépendances de projet à la `dependencies` section avec la syntaxe Gradle standard. ``` dependencies { implementation 'com.google.guava:guava:27.1-jre' implementation 'commons-cli:commons-cli:1.4' testImplementation 'org.testng:testng:6.14.3' } ``` ## Plug-ins de récupération Par défaut, Gradle résoudra les plugins à partir du portail public des [plugins Gradle](https://plugins.gradle.org/). Pour extraire des plugins d'un CodeArtifact dépôt, procédez comme suit. **Pour extraire des plugins d'un CodeArtifact référentiel** 1. Si ce n'est pas le cas, créez et stockez un jeton d' CodeArtifact authentification dans une variable d'environnement en suivant la procédure décrite dans[Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var). 1. Ajoutez un `pluginManagement` bloc à votre `settings.gradle` fichier. Le `pluginManagement` bloc doit apparaître avant toute autre instruction dans`settings.gradle`, voir l'extrait suivant : ``` 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 } } } } ``` Cela garantira que Gradle résout les plugins à partir du référentiel spécifié. Le référentiel doit avoir un référentiel en amont avec une connexion externe au portail des plugins Gradle (par exemple`gradle-plugins-store`) afin que les plugins Gradle couramment requis soient disponibles pour la compilation. Pour plus d'informations, consultez la [documentation Gradle](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories). ## Publier des artefacts Cette section décrit comment publier une bibliothèque Java créée avec Gradle dans un CodeArtifact référentiel. Ajoutez d'abord le `maven-publish` plugin dans la `plugins` section du `build.gradle` fichier du projet. ``` plugins { id 'java-library' id 'maven-publish' } ``` Ajoutez ensuite une `publishing` section au `build.gradle` fichier de projet. ``` 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 } } } } ``` Le `maven-publish` plugin génère un fichier POM basé sur le `groupId``artifactId`, et `version` spécifié dans la `publishing` section. Une fois ces modifications `build.gradle` terminées, exécutez la commande suivante pour créer le projet et le télécharger dans le référentiel. ``` ./gradlew publish ``` `list-package-versions`À utiliser pour vérifier que le package a bien été publié. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven\ --namespace com.company.framework --package my-package-name ``` Exemple de sortie : ``` { "format": "maven", "namespace": "com.company.framework", "package": "example", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` Pour plus d'informations, consultez les rubriques suivantes sur le site Web de Gradle : + [Création de bibliothèques Java](https://guides.gradle.org/building-java-libraries/) + [Publier un projet sous forme de module](https://docs.gradle.org/current/userguide/publishing_setup.html) ## Exécuter une compilation Gradle dans IntelliJ IDEA Vous pouvez exécuter une version Gradle dans IntelliJ IDEA qui extrait les dépendances de. CodeArtifact Pour vous authentifier CodeArtifact, vous devez fournir à Gradle un jeton d' CodeArtifact autorisation. Il existe trois méthodes pour fournir un jeton d'authentification. + Méthode 1 : Stockage du jeton d'authentification dans`gradle.properties`. Utilisez cette méthode si vous êtes en mesure de remplacer ou d'ajouter du contenu au `gradle.properties` fichier. + Méthode 2 : Stockage du jeton d'authentification dans un fichier séparé. Utilisez cette méthode si vous ne souhaitez pas modifier votre `gradle.properties` fichier. + Méthode 3 : Génération d'un nouveau jeton d'authentification pour chaque exécution en l'exécutant en `aws` tant que script en ligne dans. `build.gradle` Utilisez cette méthode si vous souhaitez que le script Gradle récupère un nouveau jeton à chaque exécution. Le jeton ne sera pas stocké dans le système de fichiers. ------ #### [ Token stored in gradle.properties ] **Méthode 1 : Stockage du jeton d'authentification dans `gradle.properties`** **Note** L'exemple montre le `gradle.properties` fichier situé dans`GRADLE_USER_HOME`. 1. Mettez à jour votre `build.gradle` fichier avec l'extrait suivant : ``` repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password "$codeartifactToken" } } } ``` 1. Pour récupérer des plugins CodeArtifact, ajoutez un `pluginManagement` bloc à votre `settings.gradle` fichier. Le `pluginManagement` bloc doit apparaître avant toute autre instruction dans`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. Récupérez un jeton d' CodeArtifact authentification : ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Écrivez le jeton d'authentification dans le `gradle.properties` fichier : ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties ``` ------ #### [ Token stored in separate file ] **Méthode 2 : Stockage du jeton d'authentification dans un fichier séparé** 1. Mettez à jour votre `build.gradle` fichier avec l'extrait suivant : ``` 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. Pour récupérer des plugins CodeArtifact, ajoutez un `pluginManagement` bloc à votre `settings.gradle` fichier. Le `pluginManagement` bloc doit apparaître avant toute autre instruction dans`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. Récupérez un jeton d' CodeArtifact authentification : ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Écrivez le jeton d'authentification dans le fichier spécifié dans votre `build.gradle` fichier : ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > file ``` ------ #### [ Token generated for each run in build.gradle ] **Méthode 3 : Génération d'un nouveau jeton d'authentification pour chaque exécution en exécutant un script `aws` en ligne dans `build.gradle`** 1. Mettez à jour votre `build.gradle` fichier avec l'extrait suivant : ``` 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. Pour récupérer des plugins CodeArtifact, ajoutez un `pluginManagement` bloc à votre `settings.gradle` fichier. Le `pluginManagement` bloc doit apparaître avant toute autre instruction dans`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 } } } } ``` ------ # Utiliser CodeArtifact avec MVN Vous utilisez la `mvn` commande pour exécuter les builds de Maven. Cette section explique comment configurer l'utilisation `mvn` d'un CodeArtifact référentiel. **Topics** + [Extraire les dépendances](#fetching-dependencies) + [Publier des artefacts](#publishing-artifacts) + [Publier des artefacts tiers](#publishing-third-party-artifacts) + [Restreindre les téléchargements de dépendances Maven à un référentiel CodeArtifact](#restrict-maven-downloads) + [Informations sur le projet Apache Maven](#apache-maven-project-info) ## Extraire les dépendances Pour configurer `mvn` afin d'extraire les dépendances d'un CodeArtifact référentiel, vous devez modifier le fichier de configuration Maven et, éventuellement`settings.xml`, le POM de votre projet. 1. Si ce n'est pas le cas, créez et stockez un jeton d' CodeArtifact authentification dans une variable d'environnement, comme décrit dans la section [Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var) pour configurer l'authentification auprès de votre CodeArtifact référentiel. 1. Dans `settings.xml` (généralement trouvé à`~/.m2/settings.xml`), ajoutez une `` section avec une référence à la variable d'`CODEARTIFACT_AUTH_TOKEN`environnement afin que Maven transmette le jeton dans les requêtes HTTP. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Ajoutez le point de terminaison URL de votre CodeArtifact référentiel dans un `` élément. Vous pouvez le faire dans le `settings.xml` fichier POM de votre projet. Vous pouvez récupérer le point de terminaison de votre dépôt à l'aide de la `get-repository-endpoint` AWS CLI commande. Par exemple, avec un dépôt nommé *my\$1repo* à l'intérieur d'un domaine nommé*my\$1domain*, la commande est la suivante : ``` aws codeartifact get-repository-endpoint --domain my_domain --repository my_repo --format maven ``` La `get-repository-endpoint` commande renverra le point de terminaison du référentiel : ``` url 'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/' ``` **Note** Pour utiliser un point de terminaison à double pile, utilisez le `codeartifact.region.on.aws` point de terminaison. Ajoutez le point de terminaison du référentiel `settings.xml` comme suit. ``` ... default codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ default ... ``` Vous pouvez également ajouter la `` section à un fichier POM de projet CodeArtifact pour l'utiliser uniquement pour ce projet. ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` **Important** Vous pouvez utiliser n'importe quelle valeur dans l'``élément, mais elle doit être identique dans les `` éléments `` et. Cela permet d'inclure les informations d'identification spécifiées dans les demandes adressées à CodeArtifact. Après avoir apporté ces modifications de configuration, vous pouvez créer le projet. ``` mvn compile ``` Maven enregistre l'URL complète de toutes les dépendances qu'il télécharge sur la console. ``` [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) ``` ## Publier des artefacts Pour publier un artefact Maven dans un CodeArtifact dépôt, vous devez également modifier `~/.m2/settings.xml` le POM du projet. `mvn` 1. Si ce n'est pas le cas, créez et stockez un jeton d' CodeArtifact authentification dans une variable d'environnement, comme décrit dans la section [Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var) pour configurer l'authentification auprès de votre CodeArtifact référentiel. 1. Ajoutez une `` section à `settings.xml` avec une référence à la variable d'`CODEARTIFACT_AUTH_TOKEN`environnement afin que Maven transmette le jeton dans les requêtes HTTP. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Ajoutez une `` section à celle de votre projet`pom.xml`. ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` Après avoir apporté ces modifications de configuration, vous pouvez créer le projet et le publier dans le référentiel spécifié. ``` mvn deploy ``` `list-package-versions`À utiliser pour vérifier que le package a bien été publié. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven \ --namespace com.company.framework --package my-package-name ``` Exemple de sortie : ``` { "defaultDisplayVersion": null, "format": "maven", "namespace": "com.company.framework", "package": "my-package-name", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` ## Publier des artefacts tiers Vous pouvez publier des artefacts Maven tiers dans un CodeArtifact référentiel avec`mvn deploy:deploy-file`. Cela peut être utile aux utilisateurs qui souhaitent publier des artefacts et qui ne disposent que de fichiers JAR et qui n'ont pas accès au code source du package ou aux fichiers POM. La `mvn deploy:deploy-file` commande générera un fichier POM basé sur les informations transmises dans la ligne de commande. **Publier des artefacts Maven tiers** 1. Si ce n'est pas le cas, créez et stockez un jeton d' CodeArtifact authentification dans une variable d'environnement, comme décrit dans la section [Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var) pour configurer l'authentification auprès de votre CodeArtifact référentiel. 1. Créez un `~/.m2/settings.xml` fichier avec le contenu suivant : ``` codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ``` 1. Exécutez la commande `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/ ``` **Note** L'exemple ci-dessus publie`commons-cli 1.4`. Modifiez les arguments groupId, artifactID, version et fichier pour publier un JAR différent. Ces instructions sont basées sur des exemples du [Guide de déploiement d'un tiers JARs sur un dépôt distant](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html), extrait de la *documentation d'Apache Maven*. ## Restreindre les téléchargements de dépendances Maven à un référentiel CodeArtifact Si un package ne peut pas être extrait d'un référentiel configuré, par défaut, la `mvn` commande le récupère depuis Maven Central. Ajoutez l'`mirrors`élément `settings.xml` to pour `mvn` toujours utiliser votre CodeArtifact dépôt. ``` ... central-mirror CodeArtifact Maven Central mirror https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ central ... ``` Si vous ajoutez un `mirrors` élément, vous devez également en avoir un `pluginRepository` dans votre `settings.xml` ou`pom.xml`. L'exemple suivant extrait les dépendances des applications et les plug-ins Maven depuis un CodeArtifact référentiel. ``` ... codeartifact CodeArtifact Plugins https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ true true ... ``` L'exemple suivant extrait les dépendances des applications depuis un CodeArtifact référentiel et extrait les plug-ins Maven depuis Maven Central. ``` default ... central-plugins Central Plugins https://repo.maven.apache.org/maven2/ true true .... ``` ## Informations sur le projet Apache Maven Pour plus d'informations sur Maven, consultez les rubriques suivantes sur le site Web du projet Apache Maven : + [Configuration de plusieurs référentiels](https://maven.apache.org/guides/mini/guide-multiple-repositories.html) + [Référence des paramètres](https://maven.apache.org/settings.html) + [Gestion de la distribution](https://maven.apache.org/pom.html#Distribution_Management) + [Profilés](https://maven.apache.org/pom.html#Profiles) # À utiliser CodeArtifact avec deps.edn Vous utilisez `deps.edn` with `clj` pour gérer les dépendances des projets Clojure. Cette section explique comment configurer l'utilisation `deps.edn` d'un CodeArtifact référentiel. **Topics** + [Extraire les dépendances](#fetching-dependencies-deps) + [Publier des artefacts](#publishing-artifacts-deps) ## Extraire les dépendances Pour configurer `Clojure` afin de récupérer les dépendances d'un CodeArtifact référentiel, vous devez modifier le fichier de configuration Maven,. `settings.xml` 1. Dans`settings.xml`, ajoutez une `` section avec une référence à la variable d'`CODEARTIFACT_AUTH_TOKEN`environnement afin que Clojure transmette le jeton dans les requêtes HTTP. **Note** Clojure s'attend à ce que le fichier settings.xml se trouve à l'`~/.m2/settings.xml`adresse. Si ce n'est pas le cas, créez le fichier à cet emplacement. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Si vous n'en avez pas déjà un, générez un XML POM pour votre projet à l'aide de`clj -Spom`. 1. Dans votre fichier `deps.edn` de configuration, ajoutez un dépôt correspondant à l'identifiant du serveur 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/"} } ``` **Note** `tools.deps`garantit que les `clojars` référentiels `central` et seront d'abord vérifiés pour les bibliothèques Maven. Ensuite, les autres référentiels répertoriés dans `deps.edn` seront vérifiés. Pour empêcher le téléchargement directement depuis Clojars et Maven Central, `central` `clojars` vous devez le configurer sur. `nil` Assurez-vous d'avoir le jeton CodeArtifact Auth dans une variable d'environnement (voir[Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var)). Lors de la création du package après ces modifications, les dépendances `deps.edn` seront CodeArtifact extraites. **Note** Pour utiliser un point de terminaison à double pile, utilisez le `codeartifact.region.on.aws` point de terminaison. ## Publier des artefacts 1. Mettez à jour vos paramètres Maven et `deps.edn` incluez-les en CodeArtifact tant que serveur reconnu par Maven (voir). [Extraire les dépendances](#fetching-dependencies-deps) Vous pouvez utiliser un outil tel que [deps-deploy](https://github.com/slipset/deps-deploy) pour télécharger des artefacts vers. CodeArtifact 1. Dans votre`build.clj`, ajoutez une `deploy` tâche pour télécharger les artefacts requis dans le `codeartifact` référentiel précédemment configuré. ``` (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. Publiez l'artefact en exécutant la commande suivante : `clj -T:build deploy` Pour plus d'informations sur la modification des référentiels par défaut, consultez [la section Modification des référentiels par défaut dans les documents](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories) *Clojure Deps et la justification de référence de la CLI*. # Publier avec curl Cette section explique comment utiliser le client HTTP `curl` pour publier des artefacts Maven dans un CodeArtifact référentiel. La publication d'artefacts avec `curl` peut être utile si vous ne possédez pas ou ne souhaitez pas installer le client Maven dans vos environnements. **Publiez un artefact Maven avec `curl`** 1. Récupérez un jeton CodeArtifact d'autorisation en suivant les étapes indiquées [Transmettre un jeton d'authentification à l'aide d'une variable d'environnement](tokens-authentication.md#env-var) et revenez à ces étapes. 1. Utilisez la `curl` commande suivante pour publier le fichier JAR dans un CodeArtifact référentiel : Dans chacune des `curl` commandes de cette procédure, remplacez les espaces réservés suivants : + *my\$1domain*Remplacez-le par votre nom de CodeArtifact domaine. + *111122223333*Remplacez-le par l'ID du propriétaire de votre CodeArtifact domaine. + Remplacez *us-west-2* par la région dans laquelle se trouve votre CodeArtifact domaine. + Remplacez *my\$1repo* par le nom de votre CodeArtifact dépôt. ``` 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 ``` **Important** Vous devez préfixer la valeur du `--data-binary` paramètre par un `@` caractère. Lorsque vous mettez la valeur entre guillemets, `@` celle-ci doit être incluse entre guillemets. 1. Utilisez la `curl` commande suivante pour publier le POM dans un CodeArtifact référentiel : ``` 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. À ce stade, l'artefact Maven sera dans votre CodeArtifact dépôt avec un statut de. `Unfinished` Pour pouvoir consommer le package, celui-ci doit être en bon `Published` état. Vous pouvez déplacer le package de `Unfinished` vers `Published` en téléchargeant un `maven-metadata.xml` fichier dans votre package ou en appelant l'[UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) pour modifier le statut. 1. Option 1 : utilisez la `curl` commande suivante pour ajouter un `maven-metadata.xml` fichier à votre package : ``` 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 ``` Voici un exemple du contenu d'un `maven-metadata.xml` fichier : ``` com.mycompany.app my-app 1.0 1.0 1.0 20200731090423 ``` 1. Option 2 : mettez à jour le statut du package `Published` avec l'`UpdatePackageVersionsStatus`API. ``` 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 vous ne disposez que du fichier JAR d'un artefact, vous pouvez publier une version de package consommable dans un CodeArtifact référentiel à l'aide de. `mvn` Cela peut être utile si vous n'avez pas accès au code source ou au POM de l'artefact. Consultez [Publier des artefacts tiers](maven-mvn.md#publishing-third-party-artifacts) pour plus de détails. # Utiliser les checksums Maven Lorsqu'un artefact Maven est publié dans un AWS CodeArtifact référentiel, la somme de contrôle associée à chaque *ressource* ou fichier du package est utilisée pour valider le téléchargement. Les fichiers *jar*, *pom* et *war* sont des exemples d'actifs. Pour chaque ressource, l'artefact Maven contient plusieurs fichiers de somme de contrôle qui utilisent le nom de la ressource avec une extension supplémentaire, telle que ou. `md5` `sha1` Par exemple, les fichiers de somme de contrôle d'un fichier nommé `my-maven-package.jar` peuvent être `my-maven-package.jar.md5` et`my-maven-package.jar.sha1`. **Note** Maven utilise le terme`artifact`. Dans ce guide, un package Maven est identique à un artefact Maven. Pour plus d'informations, consultez le [AWS CodeArtifactpackage](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package). ## Stockage de Checksum CodeArtifact ne stocke pas les sommes de contrôle Maven en tant qu'actifs. Cela signifie que les checksums n'apparaissent pas sous forme d'actifs individuels dans le résultat de l'[ListPackageVersionAssets API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html). Au lieu de cela, les sommes de contrôle calculées par CodeArtifact sont disponibles pour chaque actif dans tous les types de somme de contrôle pris en charge. Par exemple, une partie de la réponse à l'appel de ListPackageVersionAssets la version du package Maven `commons-lang:commons-lang 2.1` est la suivante : ``` { "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" } } ``` Même si les sommes de contrôle ne sont pas stockées en tant qu'actifs, les clients Maven peuvent toujours publier et télécharger les sommes de contrôle aux emplacements prévus. Par exemple, `commons-lang:commons-lang 2.1` s'il se trouve dans un référentiel appelé`maven-repo`, le chemin URL de la somme de contrôle SHA-256 du fichier JAR serait : ``` /maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256 ``` Si vous téléchargez des packages Maven existants (par exemple, des packages précédemment stockés dans Amazon S3) à CodeArtifact l'aide d'un client HTTP générique tel que`curl`, il n'est pas nécessaire de télécharger les checksums. CodeArtifact les générera automatiquement. Si vous souhaitez vérifier que les actifs ont été chargés correctement, vous pouvez utiliser l'opération ListPackageVersionAssets API pour comparer les sommes de contrôle de la réponse aux valeurs de contrôle d'origine de chaque ressource. ## Incompatibilité des checksum lors de la publication Outre les actifs et les checksums, les artefacts Maven contiennent également un `maven-metadata.xml` fichier. La séquence de publication normale d'un package Maven consiste à télécharger d'abord tous les actifs et les sommes de contrôle, puis à. `maven-metadata.xml` Par exemple, la séquence de publication de la version du package Maven `commons-lang 2.1` décrite précédemment, en supposant que le client ait été configuré pour publier des fichiers de somme de contrôle SHA-256, serait la suivante : ``` 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 ``` Lors du téléchargement du fichier de somme de contrôle pour un actif, tel qu'un fichier JAR, la demande de téléchargement de somme de contrôle échouera avec une réponse de **400 (mauvaise demande)** en cas de non-correspondance entre la valeur de la somme de contrôle téléchargée et la valeur de la somme de contrôle calculée par. CodeArtifact Si l'actif correspondant n'existe pas, la demande échouera avec une réponse **404 (introuvable)**. Pour éviter cette erreur, vous devez d'abord télécharger la ressource, puis télécharger la somme de contrôle. Lorsqu'il `maven-metadata.xml` est téléchargé, le statut de la version du package Maven passe CodeArtifact normalement de `Unfinished` à`Published`. Si une incompatibilité de somme de contrôle est détectée pour un actif, CodeArtifact renvoie un **400 (mauvaise demande)** en réponse à la demande de `maven-metadata.xml` publication. Cette erreur peut empêcher le client de télécharger les fichiers correspondant à cette version du package. Si cela se produit et que le `maven-metadata.xml` fichier n'est pas chargé, aucune ressource de la version du package déjà téléchargée ne peut être téléchargée. Cela est dû au fait que le statut de la version du package n'est pas défini sur `Published` et reste le même`Unfinished`. CodeArtifact permet d'ajouter d'autres actifs à une version de package Maven même après `maven-metadata.xml` le téléchargement et le statut de la version du package défini sur. `Published` Dans ce statut, une demande de téléchargement d'un fichier de somme de contrôle non concordant échouera également avec une réponse **400 (mauvaise demande)**. Toutefois, comme le statut de version du package a déjà été défini sur`Published`, vous pouvez télécharger n'importe quelle ressource du package, y compris celles pour lesquelles le téléchargement du fichier de somme de contrôle a échoué. Lors du téléchargement d'une somme de contrôle pour une ressource dont le téléchargement du fichier de somme de contrôle a échoué, la valeur de la somme de contrôle que le client reçoit est la valeur de la somme de contrôle calculée sur la CodeArtifact base des données de l'actif téléchargées. CodeArtifact les comparaisons de checksum font la distinction majuscules/minuscules, et les checksums calculés par CodeArtifact sont formatés en minuscules. Par conséquent, si la somme de contrôle `909FA780F76DA393E992A3D2D495F468` est téléchargée, elle échouera en raison d'une incompatibilité de somme de contrôle, car elle CodeArtifact n'est pas traitée comme égale à. `909fa780f76da393e992a3d2d495f468` ## Réparation après des incohérences entre les checksum Si le téléchargement d'un checksum échoue en raison d'une incompatibilité de checksum, essayez l'une des méthodes suivantes pour le récupérer : + Exécutez à nouveau la commande qui publie l'artefact Maven. Cela peut fonctionner si un problème réseau a endommagé le fichier checksum. Si cela résout le problème réseau, la somme de contrôle correspond et le téléchargement est réussi. + Supprimez la version du package, puis republiez-la. Pour plus d'informations, consultez [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)le manuel de *référence des CodeArtifact API AWS*. # Utiliser les instantanés Maven Un *instantané* Maven est une version spéciale d'un package Maven qui fait référence au dernier code de branche de production. Il s'agit d'une version de développement qui précède la version finale. Vous pouvez identifier une version instantanée d'un package Maven à l'aide du suffixe `SNAPSHOT` ajouté à la version du package. Par exemple, l'instantané de la version `1.1` est`1.1-SNAPSHOT`. Pour plus d'informations, voir [Qu'est-ce qu'une version SNAPSHOT ?](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) sur le site Web du projet Apache Maven. AWS CodeArtifact prend en charge la publication et la consommation d'instantanés Maven. Les instantanés uniques qui utilisent un numéro de version basé sur le temps sont les seuls instantanés pris en charge. CodeArtifact ne prend pas en charge les instantanés non uniques générés par les clients Maven 2. Vous pouvez publier un instantané Maven compatible dans n'importe quel CodeArtifact référentiel. **Topics** + [Publication d'instantanés dans CodeArtifact](#maven-snapshot-publishing) + [Consommation de versions instantanées](#maven-consuming-snapshot-versions) + [Supprimer des versions de snapshots](#maven-deleting-snapshot-versions) + [Publication d'instantanés avec curl](#maven-snapshot-publishing-curl) + [Instantanés et connexions externes](#maven-snapshot-external-connections) + [Instantanés et référentiels en amont](#maven-snapshot-upstream-repositories) ## Publication d'instantanés dans CodeArtifact AWS CodeArtifact prend en charge les modèles de demande que les clients, par exemple`mvn`, utilisent lors de la publication de snapshots. De ce fait, vous pouvez suivre la documentation de votre outil de génération ou de votre gestionnaire de packages sans avoir une compréhension détaillée de la manière dont les instantanés Maven sont publiés. Si vous effectuez une opération plus complexe, cette section décrit en détail comment CodeArtifact gérer les instantanés. Lorsqu'un instantané Maven est publié dans un CodeArtifact référentiel, sa version précédente est préservée dans une nouvelle version appelée build. Chaque fois qu'un instantané Maven est publié, une nouvelle version de build est créée. Toutes les versions précédentes d'un instantané sont conservées dans ses versions de compilation. Lorsqu'un instantané Maven est publié, le statut de la version de son package est défini sur `Published` et le statut de la version contenant la version précédente est défini sur. `Unlisted` Ce comportement s'applique uniquement aux versions de package Maven dont le suffixe est `-SNAPSHOT` la version du package. Par exemple, les versions instantanées d'un package maven appelé `com.mycompany.myapp:pkg-1` sont téléchargées dans un CodeArtifact référentiel appelé`my-maven-repo`. La version instantanée est`1.0-SNAPSHOT`. Jusqu'à présent, aucune version de `com.mycompany.myapp:pkg-1` n'a été publiée. Tout d'abord, les actifs de la version initiale sont publiés sur les chemins suivants : ``` 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 ``` Notez que l'horodatage `20210728.194552-1` est généré par le client qui publie les versions instantanées. Une fois les fichiers .pom et .jar chargés, la seule version `com.mycompany.myapp:pkg-1` qui existe dans le référentiel est. `1.0-20210728.194552-1` Cela se produit même si la version spécifiée dans le chemin précédent est`1.0-SNAPSHOT`. L'état de la version du package à ce stade est`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" } ``` Ensuite, le client télécharge le `maven-metadata.xml` fichier correspondant à la version du package : ``` PUT my-maven-repo/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml ``` Lorsque le fichier maven-metadata.xml est correctement chargé, CodeArtifact crée la version `1.0-SNAPSHOT` du package et définit la `1.0-20210728.194552-1` version sur`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" } ``` À ce stade, la version instantanée `1.0-SNAPSHOT` peut être utilisée dans une version. Bien qu'il existe deux versions de `com.mycompany.myapp:pkg-1` dans le référentiel`my-maven-repo`, elles contiennent toutes les deux les mêmes actifs. ``` 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" ] ``` L'exécution de la même `list-package-version-assets` commande que celle indiquée précédemment avec le `--package-version` paramètre modifié `1.0-20210728.194552-1` permet d'obtenir une sortie identique. Au fur et à mesure que des versions supplémentaires de `1.0-SNAPSHOT` sont ajoutées au référentiel, une nouvelle version de `Unlisted` package est créée pour chaque nouvelle version. Les actifs de la version `1.0-SNAPSHOT` sont mis à jour à chaque fois afin que la version fasse toujours référence à la dernière version pour cette version. La mise à jour du `1.0-SNAPSHOT` avec les dernières ressources est lancée en téléchargeant le `maven-metadata.xml` fichier pour la nouvelle version. ## Consommation de versions instantanées Si vous demandez un instantané, la version avec le statut `Published` est renvoyée. Il s'agit toujours de la version la plus récente de l'instantané Maven. Vous pouvez également demander une version particulière d'un instantané en utilisant le numéro de version du build (par exemple,`1.0-20210728.194552-1`) au lieu de la version instantanée (par exemple,`1.0-SNAPSHOT`) dans le chemin URL. Pour voir les versions de compilation d'un instantané Maven, utilisez l'[ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API du *guide des CodeArtifact API* et définissez le paramètre d'`Unlisted`état sur. ## Supprimer des versions de snapshots Pour supprimer toutes les versions de build d'un instantané Maven, utilisez l'[DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API en spécifiant les versions que vous souhaitez supprimer. ## Publication d'instantanés avec curl Si vous avez des versions de snapshots stockées dans Amazon Simple Storage Service (Amazon S3) ou dans un autre produit de référentiel d'artefacts, vous souhaiterez peut-être les republier sur. AWS CodeArtifact En raison de la prise CodeArtifact en charge des instantanés Maven (voir[Publication d'instantanés dans CodeArtifact](#maven-snapshot-publishing)), la publication d'instantanés avec un client HTTP générique tel que la publication de versions de Maven `curl` est plus complexe que la publication de versions de Maven, comme décrit dans. [Publier avec curl](maven-curl.md) Notez que cette section n'est pas pertinente si vous créez et déployez des versions de snapshots avec un client Maven tel que `mvn` ou`gradle`. Vous devez suivre la documentation relative à ce client. La publication d'une version instantanée implique la publication d'une ou de plusieurs versions d'une version instantanée. Dans CodeArtifact, s'il existe *n* versions d'une version instantanée, il y aura *n \$1 1* CodeArtifact versions : *n* versions de version avec un statut de`Unlisted`, et une version instantanée (la dernière version publiée) avec un statut de`Published`. La version instantanée (c'est-à-dire la version dont la chaîne de version contient « -SNAPSHOT ») contient un ensemble d'actifs identique à celui de la dernière version publiée. La méthode la plus simple pour créer cette structure `curl` est la suivante : 1. Publiez tous les actifs de toutes les versions à l'aide de`curl`. 1. Publiez le `maven-metadata.xml` fichier de la dernière version (c'est-à-dire la version avec l'horodatage le plus récent) avec. `curl` Cela créera une version avec « `-SNAPSHOT` » dans la chaîne de version et avec le bon ensemble d'actifs. 1. Utilisez l'[UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API pour définir le statut de toutes les versions de version non récentes sur`Unlisted`. Utilisez les `curl` commandes suivantes pour publier les actifs de capture d'écran (tels que les fichiers .jar et .pom) pour la version instantanée `1.0-SNAPSHOT` d'un package : `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 ``` Lorsque vous utilisez ces exemples : + *my\$1domain*Remplacez-le par votre nom de CodeArtifact domaine. + *111122223333*Remplacez-le par l' Compte AWS ID du propriétaire de votre CodeArtifact domaine. + *us-west-2*Remplacez-le par celui Région AWS dans lequel se trouve votre CodeArtifact domaine. + *my\$1maven\$1repo*Remplacez-le par le nom de votre CodeArtifact dépôt. **Important** Vous devez préfixer la valeur du `--data-binary` paramètre par le `@` caractère. Lorsque vous mettez la valeur entre guillemets, `@` celle-ci doit être incluse entre guillemets. Vous pouvez avoir plus de deux actifs à télécharger pour chaque build. Par exemple, il peut y avoir des fichiers Javadoc et JAR source en plus du JAR principal et. `pom.xml` Il n'est pas nécessaire de publier des fichiers de somme de contrôle pour les actifs de la version du package, car des sommes de contrôle CodeArtifact sont automatiquement générées pour chaque ressource téléchargée. Pour vérifier que les actifs ont été chargés correctement, récupérez les sommes de contrôle générées à l'aide de la `list-package-version-assets` commande et comparez-les aux sommes de contrôle d'origine. Pour plus d'informations sur la façon dont CodeArtifact les sommes de contrôle Maven sont gérées, consultez. [Utiliser les checksums Maven](maven-checksums.md) Utilisez la commande curl suivante pour publier le `maven-metadata.xml` fichier correspondant à la dernière version de build : ``` 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 ``` Le `maven-metadata.xml` fichier doit faire référence à au moins un des actifs de la dernière version de build de l'``élément. En outre, la `` valeur doit être présente et correspondre à l'horodatage figurant dans les noms des fichiers d'actifs. Par exemple, pour le `20210729.171330-2` build publié précédemment, le contenu de `maven-metadata.xml` serait : ``` 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 ``` Après `maven-metadata.xml` la publication, la dernière étape consiste à définir toutes les autres versions de build (c'est-à-dire toutes les versions de build à l'exception de la dernière version) pour qu'elles aient le statut de version du package de`Unlisted`. Par exemple, si la `1.0-SNAPSHOT` version comporte deux versions, la première étant la version`20210728.194552-1`, la commande permettant de définir cette version `Unlisted` est la suivante : ``` 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 ``` ## Instantanés et connexions externes Les instantanés Maven ne peuvent pas être récupérés depuis un dépôt public Maven via une connexion externe. AWS CodeArtifact ne prend en charge que l'importation des versions de Maven. ## Instantanés et référentiels en amont En général, les instantanés Maven fonctionnent de la même manière que les versions de Maven lorsqu'ils sont utilisés avec des référentiels en amont, mais il existe une limite si vous prévoyez de publier des instantanés de la même version de package dans deux référentiels ayant une relation en amont. Supposons, par exemple, qu'il existe deux référentiels dans un AWS CodeArtifact domaine `R` et `U` que se `U` trouve un dépôt en amont de`R`. Si vous publiez une nouvelle version dans`R`, lorsqu'un client Maven demande la dernière version de cette version instantanée, CodeArtifact renvoie la dernière version de`U`. Cela peut être inattendu puisque la dernière version est maintenant disponible`R`, non`U`. Il existe deux moyens d'éviter cela : 1. Ne publiez pas de versions d'une version instantanée telle que `1.0-SNAPSHOT` dans`R`, si `1.0-SNAPSHOT` elle existe dans`U`. 1. Utilisez les contrôles d'origine CodeArtifact du package pour désactiver les flux ascendants sur ce package dans`R`. Ce dernier vous permettra de publier des versions de `1.0-SNAPSHOT` in`R`, mais cela `R` empêchera également d'obtenir d'autres versions de ce package `U` qui ne sont pas déjà conservées. # Demande de packages Maven depuis des connexions en amont et externes ## Importation de noms d'actifs standard Lors de l'importation d'une version de package Maven depuis un référentiel public, tel que Maven Central, AWS CodeArtifact tente d'importer toutes les ressources de cette version de package. Comme décrit dans[Demande d'une version de package avec des référentiels en amont](repo-upstream-behavior.md), l'importation a lieu lorsque : + Un client demande un actif Maven à partir d'un CodeArtifact référentiel. + La version du package n'est pas déjà présente dans le référentiel ou dans ses flux ascendants. + Il existe une connexion externe accessible à un dépôt Maven public. Même si le client n'a demandé qu'une seule ressource, il CodeArtifact tente d'importer toutes les ressources qu'il trouve pour cette version de package. La CodeArtifact manière de découvrir quels actifs sont disponibles pour une version de package Maven dépend du référentiel public concerné. Certains référentiels Maven publics permettent de demander une liste d'actifs, mais d'autres ne le font pas. Pour les référentiels qui ne permettent pas de répertorier les actifs, CodeArtifact génère un ensemble de noms d'actifs susceptibles d'exister. Par exemple, lorsqu'un actif de la version du package Maven `junit 4.13.2` est demandé, CodeArtifact il tente d'importer les actifs suivants : + `junit-4.13.2.pom` + `junit-4.13.2.jar` + `junit-4.13.2-javadoc.jar` + `junit-4.13.2-sources.jar` ## Importation de noms d'actifs non standard Lorsqu'un client Maven demande un actif qui ne correspond pas à l'un des modèles décrits ci-dessus, CodeArtifact vérifie si cet actif est présent dans le référentiel public. Si la ressource est présente, elle sera importée et ajoutée à l'enregistrement de version du package existant, le cas échéant. Par exemple, la version du package Maven `com.android.tools.build:aapt2 7.3.1-8691043` contient les actifs suivants : + `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` Lorsqu'un client demande le fichier POM, s'il n' CodeArtifact est pas en mesure de répertorier les actifs de la version du package, le POM sera le seul actif importé. Cela est dû au fait qu'aucun des autres actifs ne correspond aux modèles de noms d'actifs standard. Toutefois, lorsque le client demande l'une des ressources JAR, cette ressource est importée et ajoutée à la version du package existante stockée dans CodeArtifact. Les versions du package du référentiel le plus en aval (le référentiel contre lequel le client a fait la demande) et du référentiel associé à la connexion externe seront mises à jour pour contenir le nouvel actif, comme décrit dans. [Conservation des packages depuis les référentiels en amont](repo-upstream-behavior.md#package-retention-upstream-repos) Normalement, une fois qu'une version de package est conservée dans un CodeArtifact référentiel, elle n'est pas affectée par les modifications apportées aux référentiels en amont. Pour de plus amples informations, veuillez consulter [Conservation des packages depuis les référentiels en amont](repo-upstream-behavior.md#package-retention-upstream-repos). Cependant, le comportement des actifs Maven avec des noms non standard décrit précédemment constitue une exception à cette règle. Bien que la version du package en aval ne change pas sans qu'un actif supplémentaire ne soit demandé par un client, dans ce cas, la version du package conservée est modifiée après avoir été initialement conservée et n'est donc pas immuable. Ce comportement est nécessaire car les actifs Maven portant des noms non standard ne seraient autrement pas accessibles via. CodeArtifact Ce comportement est également activé s'ils sont ajoutés à une version de package Maven sur un référentiel public une fois que la version du package a été conservée dans un CodeArtifact référentiel. ## Vérifier l'origine des actifs Lorsque vous ajoutez un nouvel actif à une version de package Maven précédemment conservée, vous CodeArtifact confirmez que l'origine de la version de package conservée est la même que celle du nouvel actif. Cela empêche de créer une version de package « mixte » dans laquelle différents actifs proviennent de différents référentiels publics. Sans cette vérification, un mélange d'actifs peut se produire si une version de package Maven est publiée dans plusieurs référentiels publics et que ces référentiels font partie du graphe en amont d'un CodeArtifact référentiel. ## Importation de nouveaux actifs et de l'état de la version du package dans les référentiels en amont L'[état des versions](packages-overview.md#package-version-status) de package des versions de package dans les référentiels en amont peut CodeArtifact empêcher de conserver ces versions dans les référentiels en aval. Par exemple, supposons qu'un domaine possède trois référentiels :`repo-A`,`repo-B`, et`repo-C`, où se `repo-B` trouve en amont `repo-A` et `repo-C` en amont de. `repo-B` ![\[Schéma illustrant le fonctionnement des nouvelles ressources et des nouvelles versions de packages dans les référentiels en amont.\]](http://docs.aws.amazon.com/fr_fr/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png) La version `7.3.1` du package Maven `com.android.tools.build:aapt2` est présente dans `repo-B` et a un statut de`Published`. Il n'est pas présent dans`repo-A`. Si un client demande un actif de cette version de package`repo-A`, la réponse sera 200 (OK) et la version du package Maven `7.3.1` sera conservée`repo-A`. Toutefois, si le statut de la version `7.3.1` du package `repo-B` est `Archived` ou`Disposed`, la réponse sera 404 (Introuvable) car les actifs des versions du package correspondant à ces deux statuts ne sont pas téléchargeables. Notez que le [fait de définir le contrôle d'origine du package](package-origin-controls.md) sur `upstream=BLOCK` for `com.android.tools.build:aapt2` in `repo-A``repo-B`, et `repo-C` empêchera la récupération de nouveaux actifs pour toutes les versions de ce package`repo-A`, quel que soit le statut de la version du package. # Résolution des problèmes liés à Maven Les informations suivantes peuvent vous aider à résoudre les problèmes courants liés à Maven et. CodeArtifact ## Désactivez les mises en parallèle pour corriger l'erreur 429 : Too Many Requests À partir de la version 3.9.0, Maven télécharge les artefacts du package en parallèle (jusqu'à 5 fichiers à la fois). Cela peut CodeArtifact entraîner une réponse occasionnelle avec un code de réponse d'erreur 429 (trop de demandes). Si vous rencontrez cette erreur, vous pouvez désactiver les mises en parallèle pour la corriger. Pour désactiver les sorties parallèles, définissez la `aether.connector.basic.parallelPut` propriété sur `false` dans votre profil dans votre `settings.xml` fichier, comme illustré dans l'exemple suivant : ``` default false ``` Pour plus d'informations, consultez les [options de configuration d'Artifact Resolver](https://maven.apache.org/resolver/configuration.html) dans la documentation Maven.