Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Uso CodeArtifact con Gradle
Dopo aver inserito il token di CodeArtifact autenticazione in una variabile di ambiente, come descritto in [Passa un token di autenticazione utilizzando una variabile di ambiente](tokens-authentication.md#env-var), segui queste istruzioni per utilizzare i pacchetti Maven da e pubblicare nuovi pacchetti in un repository. CodeArtifact
**Topics**
+ [Recupera le dipendenze](#fetching-dependencies)
+ [Recupera i plugin](#fetching-plugins)
+ [Pubblica artefatti](#publishing-artifacts)
+ [Esegui una build Gradle in IntelliJ IDEA](#gradle-intellij)
## Recupera le dipendenze
Per recuperare le dipendenze da CodeArtifact una build Gradle, utilizzate la seguente procedura.
**Per recuperare le dipendenze da una build Gradle CodeArtifact**
1. In caso contrario, crea e archivia un token di CodeArtifact autenticazione in una variabile di ambiente seguendo la procedura in. [Passa un token di autenticazione utilizzando una variabile di ambiente](tokens-authentication.md#env-var)
1. Aggiungete una `maven` sezione alla `repositories` sezione del `build.gradle` file di progetto.
```
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password System.env.CODEARTIFACT_AUTH_TOKEN
}
}
```
L'`url`esempio precedente è l'endpoint del tuo CodeArtifact repository. Gradle utilizza l'endpoint per connettersi al tuo repository. Nell'esempio, `my_domain` è il nome del tuo dominio, `111122223333` è l'ID del proprietario del dominio ed `my_repo` è il nome del tuo repository. È possibile recuperare l'endpoint di un repository utilizzando il comando. `get-repository-endpoint` AWS CLI
Ad esempio, con un repository denominato {{my\_repo}} all'interno di un dominio denominato{{my\_domain}}, il comando è il seguente:
```
aws codeartifact get-repository-endpoint --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format maven
```
Il `get-repository-endpoint` comando restituirà l'endpoint del repository:
```
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
```
L'`credentials`oggetto nell'esempio precedente include il token di CodeArtifact autenticazione creato nel passaggio 1 che Gradle utilizza per l'autenticazione. CodeArtifact
**Nota**
Per utilizzare un endpoint dualstack, usa l'endpoint. `codeartifact.{{region}}.on.aws`
1. (Facoltativo): per utilizzare il CodeArtifact repository come unica fonte per le dipendenze del progetto, rimuovi tutte le altre sezioni in from. `repositories` `build.gradle` Se hai più di un repository, Gradle cerca in ogni repository le dipendenze nell'ordine in cui sono elencate.
1. Dopo aver configurato il repository, puoi aggiungere le dipendenze del progetto alla sezione con la sintassi Gradle standard. `dependencies`
```
dependencies {
implementation 'com.google.guava:guava:27.1-jre'
implementation 'commons-cli:commons-cli:1.4'
testImplementation 'org.testng:testng:6.14.3'
}
```
## Recupera i plugin
[Per impostazione predefinita, Gradle risolverà i plugin dal Gradle Plugin Portal pubblico.](https://plugins.gradle.org/) Per estrarre i plugin da un CodeArtifact repository, utilizzate la seguente procedura.
**Per estrarre i plugin da un repository CodeArtifact**
1. Se non l'hai fatto, crea e archivia un token di CodeArtifact autenticazione in una variabile di ambiente seguendo la procedura in. [Passa un token di autenticazione utilizzando una variabile di ambiente](tokens-authentication.md#env-var)
1. Aggiungi un `pluginManagement` blocco al tuo `settings.gradle` file. Il `pluginManagement` blocco deve apparire prima di qualsiasi altra istruzione`settings.gradle`, vedi il seguente frammento:
```
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
}
}
}
}
```
Ciò assicurerà che Gradle risolva i plugin dal repository specificato. Il repository deve avere un repository upstream con una connessione esterna al Gradle Plugin Portal (ad esempio`gradle-plugins-store`) in modo che i plugin Gradle comunemente richiesti siano disponibili per la build. [Per ulteriori informazioni, consultate la documentazione di Gradle.](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories)
## Pubblica artefatti
Questa sezione descrive come pubblicare una libreria Java creata con Gradle in un repository. CodeArtifact
Innanzitutto, aggiungi il `maven-publish` plugin alla `plugins` sezione del file del `build.gradle` progetto.
```
plugins {
id 'java-library'
id 'maven-publish'
}
```
Quindi, aggiungi una `publishing` sezione al `build.gradle` file di progetto.
```
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
}
}
}
}
```
Il `maven-publish` plugin genera un file POM basato su `groupId``artifactId`, e `version` specificato nella `publishing` sezione.
Una volta `build.gradle` completate queste modifiche, esegui il comando seguente per creare il progetto e caricarlo nel repository.
```
./gradlew publish
```
`list-package-versions`Utilizzatelo per verificare che il pacchetto sia stato pubblicato correttamente.
```
aws codeartifact list-package-versions --domain {{my_domain}} --domain-owner {{111122223333}} --repository {{my_repo}} --format {{maven}}\
--namespace {{com.company.framework}} --package {{my-package-name}}
```
Output di esempio:
```
{
"format": "{{maven}}",
"namespace": "{{com.company.framework}}",
"package": "{{example}}",
"versions": [
{
"version": "1.0",
"revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC",
"status": "Published"
}
]
}
```
Per ulteriori informazioni, consulta questi argomenti sul sito Web di Gradle:
+ [Creazione di librerie Java](https://guides.gradle.org/building-java-libraries/)
+ [Pubblicazione di un progetto come modulo](https://docs.gradle.org/current/userguide/publishing_setup.html)
## Esegui una build Gradle in IntelliJ IDEA
È possibile eseguire una build Gradle in IntelliJ IDEA da cui estrae le dipendenze. CodeArtifact Per eseguire l'autenticazione CodeArtifact, è necessario fornire a Gradle un token di autorizzazione. CodeArtifact Esistono tre metodi per fornire un token di autenticazione.
+ Metodo 1: memorizzazione del token di autenticazione in. `gradle.properties` Utilizzate questo metodo se siete in grado di sovrascrivere o aggiungere elementi al contenuto del `gradle.properties` file.
+ Metodo 2: memorizzazione del token di autenticazione in un file separato. Utilizzate questo metodo se non desiderate modificare il `gradle.properties` file.
+ Metodo 3: generazione di un nuovo token di autenticazione per ogni esecuzione eseguendolo `aws` come script in linea in. `build.gradle` Usa questo metodo se vuoi che lo script Gradle recuperi un nuovo token ad ogni esecuzione. Il token non verrà archiviato nel file system.
------
#### [ Token stored in gradle.properties ]
**Metodo 1: memorizzazione del token di autenticazione in `gradle.properties`**
**Nota**
L'esempio mostra il `gradle.properties` file che si trova in`GRADLE_USER_HOME`.
1. Aggiorna il `build.gradle` file con il seguente frammento:
```
repositories {
maven {
url 'https://{{my_domain}}-{{111122223333}}.d.codeartifact.{{region}}.amazonaws.com/maven/{{my_repo}}/'
credentials {
username "aws"
password "$codeartifactToken"
}
}
}
```
1. Per recuperare i plugin CodeArtifact, aggiungi un `pluginManagement` blocco al tuo file. `settings.gradle` Il `pluginManagement` blocco deve apparire prima di qualsiasi altra istruzione in. `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. Recupera un token di CodeArtifact autenticazione:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Scrivi il token di autenticazione nel file: `gradle.properties`
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties
```
------
#### [ Token stored in separate file ]
**Metodo 2: memorizzazione del token di autenticazione in un file separato**
1. Aggiorna il `build.gradle` file con il seguente frammento:
```
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. Per recuperare i plugin CodeArtifact, aggiungi un `pluginManagement` blocco al tuo file. `settings.gradle` Il `pluginManagement` blocco deve apparire prima di qualsiasi altra istruzione in. `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. Recupera un token di CodeArtifact autenticazione:
```
export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain {{my_domain}} --domain-owner {{111122223333}} --query authorizationToken --output text --profile {{profile-name}}`
```
1. Scrivi il token di autenticazione nel file specificato nel tuo file: `build.gradle`
```
echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > {{file}}
```
------
#### [ Token generated for each run in build.gradle ]
**Metodo 3: generazione di un nuovo token di autenticazione per ogni esecuzione eseguendolo `aws` come script in linea in `build.gradle`**
1. Aggiorna il `build.gradle` file con il seguente frammento:
```
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. Per recuperare i plugin CodeArtifact, aggiungi un `pluginManagement` blocco al tuo file. `settings.gradle` Il `pluginManagement` blocco deve apparire prima di qualsiasi altra istruzione in. `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
}
}
}
}
```
------