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à.
# Usa le istantanee di Maven
Un'*istantanea* Maven è una versione speciale di un pacchetto Maven che si riferisce all'ultimo codice filiale di produzione. È una versione di sviluppo che precede la versione di rilascio finale. È possibile identificare una versione istantanea di un pacchetto Maven dal suffisso `SNAPSHOT` aggiunto alla versione del pacchetto. Ad esempio, l'istantanea della versione è. `1.1` `1.1-SNAPSHOT` Per ulteriori informazioni, consulta [Cos'è una versione SNAPSHOT](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version)? sul sito Web del progetto Apache Maven.
AWS CodeArtifact supporta la pubblicazione e l'utilizzo di istantanee Maven. Le istantanee uniche che utilizzano un numero di versione basato sul tempo sono le uniche istantanee supportate. CodeArtifact non supporta istantanee non univoche generate dai client Maven 2. È possibile pubblicare un'istantanea Maven supportata in qualsiasi repository. CodeArtifact
**Topics**
+ [Pubblicazione di istantanee in CodeArtifact](#maven-snapshot-publishing)
+ [Consumo di versioni istantanee](#maven-consuming-snapshot-versions)
+ [Eliminazione delle versioni istantanee](#maven-deleting-snapshot-versions)
+ [Pubblicazione di istantanee con curl](#maven-snapshot-publishing-curl)
+ [Istantanee e connessioni esterne](#maven-snapshot-external-connections)
+ [Istantanee e repository upstream](#maven-snapshot-upstream-repositories)
## Pubblicazione di istantanee in CodeArtifact
AWS CodeArtifact supporta i modelli di richiesta utilizzati dai client, ad esempio`mvn`, per la pubblicazione di istantanee. Per questo motivo, è possibile seguire la documentazione dello strumento di compilazione o del gestore di pacchetti senza avere una comprensione dettagliata di come vengono pubblicate le istantanee di Maven. Se state facendo qualcosa di più complesso, questa sezione descrive in dettaglio come CodeArtifact gestisce le istantanee.
Quando un'istantanea di Maven viene pubblicata in un CodeArtifact repository, la sua versione precedente viene conservata in una nuova versione chiamata build. Ogni volta che viene pubblicata un'istantanea di Maven, viene creata una nuova versione di build. Tutte le versioni precedenti di un'istantanea vengono mantenute nelle relative versioni di build. Quando viene pubblicata un'istantanea di Maven, lo stato della versione del pacchetto è impostato su `Published` e lo stato della build che contiene la versione precedente è impostato su. `Unlisted` Questo comportamento si applica solo alle versioni del pacchetto Maven in cui la versione del pacchetto ha come suffisso. `-SNAPSHOT`
Ad esempio, le versioni snapshot di un pacchetto Maven chiamato `com.mycompany.myapp:pkg-1` vengono caricate in un repository chiamato. CodeArtifact `my-maven-repo` La versione snapshot è. `1.0-SNAPSHOT` Finora non è stata pubblicata alcuna versione di`com.mycompany.myapp:pkg-1`. Innanzitutto, le risorse della build iniziale vengono pubblicate nei seguenti percorsi:
```
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
```
Nota che il timestamp `20210728.194552-1` viene generato dal client che pubblica le build di snapshot.
Dopo il caricamento dei file.pom e.jar, l'unica versione esistente nel repository è. `com.mycompany.myapp:pkg-1` `1.0-20210728.194552-1` Ciò accade anche se la versione specificata nel percorso precedente è. `1.0-SNAPSHOT` Lo stato della versione del pacchetto a questo punto è`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"
}
```
Successivamente, il client carica il `maven-metadata.xml` file per la versione del pacchetto:
```
PUT {{my-maven-repo}}/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml
```
Quando il file maven-metadata.xml viene caricato correttamente, CodeArtifact crea la versione del `1.0-SNAPSHOT` pacchetto e imposta la `1.0-20210728.194552-1` versione su`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"
}
```
A questo punto, la versione snapshot `1.0-SNAPSHOT` può essere utilizzata in una build. Sebbene `com.mycompany.myapp:pkg-1` nel repository siano presenti due versioni`my-maven-repo`, entrambe contengono le stesse risorse.
```
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'esecuzione dello stesso `list-package-version-assets` comando mostrato in precedenza con il `--package-version` parametro modificato in `1.0-20210728.194552-1` restituisce un output identico.
Man mano che `1.0-SNAPSHOT` vengono aggiunte altre versioni di al repository, viene creata una nuova versione `Unlisted` del pacchetto per ogni nuova build. Le risorse della versione `1.0-SNAPSHOT` vengono aggiornate ogni volta in modo che la versione faccia sempre riferimento alla build più recente di quella versione. L'aggiornamento `1.0-SNAPSHOT` con le risorse più recenti viene avviato caricando il `maven-metadata.xml` file per la nuova build.
## Consumo di versioni istantanee
Se si richiede un'istantanea, viene restituita la versione con lo stato`Published`. Questa è sempre la versione più recente dell'istantanea di Maven. Puoi anche richiedere una build particolare di un'istantanea utilizzando il numero di versione della build (ad esempio,`1.0-20210728.194552-1`) anziché la versione dell'istantanea (ad esempio,`1.0-SNAPSHOT`) nel percorso URL. Per vedere le versioni di build di un'istantanea Maven, usa l'[ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API nella *Guida CodeArtifact API* e imposta il parametro status su. `Unlisted`
## Eliminazione delle versioni istantanee
Per eliminare tutte le versioni di build di un'istantanea di Maven, usa l'[DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API, specificando le versioni che desideri eliminare.
## Pubblicazione di istantanee con curl
Se disponi di versioni di snapshot esistenti archiviate in Amazon Simple Storage Service (Amazon S3) o in un altro prodotto di artifact repository, potresti volerle ripubblicare su. AWS CodeArtifact A causa del modo in cui CodeArtifact supporta le istantanee Maven (vedi[Pubblicazione di istantanee in CodeArtifact](#maven-snapshot-publishing)), la pubblicazione di istantanee con un client HTTP generico come ad esempio `curl` è più complessa rispetto alla pubblicazione di versioni di release di Maven, come descritto in. [Pubblicazione con curl](maven-curl.md) Tieni presente che questa sezione non è rilevante se stai creando e distribuendo versioni di snapshot con un client Maven come o. `mvn` `gradle` È necessario seguire la documentazione relativa a quel client.
La pubblicazione di una versione snapshot implica la pubblicazione di una o più build di una versione snapshot. In CodeArtifact, se ci sono *n* build di una versione snapshot, ci saranno *n\+1 CodeArtifact versioni: *n** versioni di build tutte con uno stato di `Unlisted` e una versione snapshot (l'ultima build pubblicata) con uno stato di. `Published` La versione snapshot (ovvero la versione con una stringa di versione che contiene «-SNAPSHOT») contiene un set di risorse identico all'ultima build pubblicata. Il modo più semplice per creare questa struttura utilizzando `curl` è il seguente:
1. Pubblica tutte le risorse di tutte le build utilizzando`curl`.
1. Pubblica il `maven-metadata.xml` file dell'ultima build (ovvero la build con il timbro data-ora più recente) con. `curl` Questo creerà una versione con «`-SNAPSHOT`» nella stringa della versione e con il set di risorse corretto.
1. Utilizza l'[UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API per impostare lo stato di tutte le versioni di build non più recenti su`Unlisted`.
Utilizzate i seguenti `curl` comandi per pubblicare risorse snapshot (come i file.jar e .pom) per la versione snapshot di un pacchetto: `1.0-SNAPSHOT` `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}}
```
Quando si utilizzano questi esempi:
+ {{my\_domain}}Sostituiscilo con il tuo nome di CodeArtifact dominio.
+ Sostituiscilo {{111122223333}} con l' Account AWS ID del proprietario del tuo CodeArtifact dominio.
+ Sostituiscilo {{us-west-2}} con quello Regione AWS in cui si trova il tuo CodeArtifact dominio.
+ {{my\_maven\_repo}}Sostituiscilo con il nome CodeArtifact del tuo repository.
**Importante**
È necessario anteporre il carattere al valore del `--data-binary` parametro. `@` Quando si inserisce il valore tra virgolette, `@` deve essere incluso tra virgolette.
Potresti avere più di due risorse da caricare per ogni build. Ad esempio, potrebbero esserci Javadoc e file JAR di origine oltre ai file JAR principali e. `pom.xml` Non è necessario pubblicare file di checksum per gli asset della versione del pacchetto perché genera CodeArtifact automaticamente i checksum per ogni risorsa caricata. Per verificare che le risorse siano state caricate correttamente, recuperate i checksum generati utilizzando il `list-package-version-assets` comando e confrontateli con i checksum originali. Per ulteriori informazioni su come CodeArtifact gestisce i checksum di Maven, consulta. [Usa i checksum Maven](maven-checksums.md)
Utilizzate il seguente comando curl per pubblicare il `maven-metadata.xml` file per l'ultima versione di 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
```
Il `maven-metadata.xml` file deve fare riferimento ad almeno una delle risorse nell'ultima versione di build dell'``elemento. Inoltre, il `` valore deve essere presente e deve corrispondere al timestamp riportato nei nomi dei file delle risorse. Ad esempio, per la `20210729.171330-2` build pubblicata in precedenza, il contenuto di `maven-metadata.xml` sarebbe:
```
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
```
Dopo `maven-metadata.xml` la pubblicazione, l'ultimo passaggio consiste nell'impostare tutte le altre versioni di build (ovvero tutte le versioni di build tranne la build più recente) per avere lo stato della versione del pacchetto di`Unlisted`. Ad esempio, se la `1.0-SNAPSHOT` versione ha due build, di cui la prima build è`20210728.194552-1`, il comando su cui impostare quella build `Unlisted` è:
```
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
```
## Istantanee e connessioni esterne
Le istantanee di Maven non possono essere recuperate da un archivio pubblico Maven tramite una connessione esterna. AWS CodeArtifact supporta solo l'importazione di versioni di release di Maven.
## Istantanee e repository upstream
In generale, le istantanee di Maven funzionano allo stesso modo delle versioni di release di Maven se utilizzate con repository upstream, ma esiste una limitazione se si prevede di pubblicare istantanee della stessa versione del pacchetto su due repository che hanno una relazione a monte. Ad esempio, supponiamo che ci siano due repository in un dominio e che dove sia un upstream di. AWS CodeArtifact `R` `U` `U` `R` Se pubblichi una nuova build in`R`, quando un client Maven richiede l'ultima build di quella versione snapshot, CodeArtifact restituisce la versione più recente da. `U` Questo può essere inaspettato poiché l'ultima versione è ora disponibile, no. `R` `U` Esistono due modi per evitarlo:
1. Non pubblicate build di una versione istantanea come `1.0-SNAPSHOT` in`R`, se `1.0-SNAPSHOT` esiste in. `U`
1. Usa i controlli di origine CodeArtifact del pacchetto per disabilitare gli upstream su quel pacchetto in. `R` Quest'ultimo ti permetterà di pubblicare versioni di `1.0-SNAPSHOT` in`R`, ma `R` impedirà anche di recuperare altre versioni di quel pacchetto `U` che non siano già state conservate.