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.
# 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
}
}
}
}
```
------