

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie Maven-Snapshots
<a name="maven-snapshots"></a>

 Ein *Maven-Snapshot* ist eine spezielle Version eines Maven-Pakets, die sich auf den neuesten Produktions-Branch-Code bezieht. Es ist eine Entwicklungsversion, die der endgültigen Release-Version vorausgeht. Sie können eine Snapshot-Version eines Maven-Pakets anhand des Suffix identifizieren, das an `SNAPSHOT` die Paketversion angehängt wird. Der Snapshot der Version lautet beispielsweise. `1.1` `1.1-SNAPSHOT` Weitere Informationen finden Sie unter [Was ist eine SNAPSHOT-Version?](https://maven.apache.org/guides/getting-started/index.html#What_is_a_SNAPSHOT_version) auf der Website des Apache Maven Project. 

 AWS CodeArtifact unterstützt das Veröffentlichen und Verwenden von Maven-Snapshots. Eindeutige Snapshots, die eine zeitbasierte Versionsnummer verwenden, sind die einzigen Snapshots, die unterstützt werden. CodeArtifact unterstützt keine uneindeutigen Snapshots, die von Maven 2-Clients generiert werden. Sie können einen unterstützten Maven-Snapshot in einem beliebigen Repository veröffentlichen. CodeArtifact 

**Topics**
+ [Veröffentlichung von Snapshots in CodeArtifact](#maven-snapshot-publishing)
+ [Snapshot-Versionen werden konsumiert](#maven-consuming-snapshot-versions)
+ [Löschen von Snapshot-Versionen](#maven-deleting-snapshot-versions)
+ [Veröffentlichung von Snapshots mit Curl](#maven-snapshot-publishing-curl)
+ [Schnappschüsse und externe Verbindungen](#maven-snapshot-external-connections)
+ [Snapshots und Upstream-Repositorys](#maven-snapshot-upstream-repositories)

## Veröffentlichung von Snapshots in CodeArtifact
<a name="maven-snapshot-publishing"></a>

AWS CodeArtifact unterstützt die Anforderungsmuster, die Clients `mvn` beispielsweise beim Veröffentlichen von Snapshots verwenden. Aus diesem Grund können Sie der Dokumentation für Ihr Build-Tool oder Ihren Paketmanager folgen, ohne genau zu wissen, wie Maven-Snapshots veröffentlicht werden. Wenn Sie etwas komplexeres tun, wird in diesem Abschnitt detailliert beschrieben, wie mit Snapshots CodeArtifact umgegangen wird. 

 Wenn ein Maven-Snapshot in einem CodeArtifact Repository veröffentlicht wird, wird seine vorherige Version in einer neuen Version, einem sogenannten Build, aufbewahrt. Jedes Mal, wenn ein Maven-Snapshot veröffentlicht wird, wird eine neue Build-Version erstellt. Alle vorherigen Versionen eines Snapshots werden in seinen Build-Versionen beibehalten. Wenn ein Maven-Snapshot veröffentlicht wird, wird sein Paketversionsstatus auf gesetzt `Published` und der Status des Builds, der die vorherige Version enthält, wird auf `Unlisted` gesetzt. Dieses Verhalten gilt nur für Maven-Paketversionen, bei denen die Paketversion ein `-SNAPSHOT` Suffix hat. 

Beispielsweise werden Snapshot-Versionen eines Maven-Pakets namens in ein `com.mycompany.myapp:pkg-1` CodeArtifact Repository namens hochgeladen. `my-maven-repo` Die Snapshot-Version ist`1.0-SNAPSHOT`. Bisher wurden keine Versionen von `com.mycompany.myapp:pkg-1` veröffentlicht. Zunächst werden die Assets des ersten Builds unter den folgenden Pfaden veröffentlicht:

```
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
```

Beachten Sie, dass der Zeitstempel vom Client generiert `20210728.194552-1` wird, der die Snapshot-Builds veröffentlicht.

Nachdem die .pom- und .jar-Dateien hochgeladen wurden, ist die einzige Version davon, `com.mycompany.myapp:pkg-1` die im Repository vorhanden ist. `1.0-20210728.194552-1` Dies geschieht, obwohl es sich bei der im vorherigen Pfad angegebenen Version handelt. `1.0-SNAPSHOT` Der Status der Paketversion ist zu diesem Zeitpunkt`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"
}
```

Als Nächstes lädt der Client die `maven-metadata.xml` Datei für die Paketversion hoch:

```
PUT {{my-maven-repo}}/com/mycompany/myapp/pkg-1/1.0-SNAPSHOT/maven-metadata.xml
```

Wenn die Datei maven-metadata.xml erfolgreich hochgeladen wurde, wird die `1.0-SNAPSHOT` Paketversion CodeArtifact erstellt und die `1.0-20210728.194552-1` Version auf `Unlisted` gesetzt.

```
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"
}
```

Zu diesem Zeitpunkt `1.0-SNAPSHOT` kann die Snapshot-Version in einem Build verwendet werden. Es gibt zwar zwei Versionen von `com.mycompany.myapp:pkg-1` im Repository`my-maven-repo`, aber beide enthalten dieselben Ressourcen.

```
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"
]
```

Die Ausführung desselben `list-package-version-assets` Befehls wie zuvor gezeigt mit `--package-version` geändertem Parameter `1.0-20210728.194552-1` führt zu einer identischen Ausgabe.

Wenn dem Repository weitere Builds von hinzugefügt `1.0-SNAPSHOT` werden, wird für jeden neuen Build eine neue `Unlisted` Paketversion erstellt. Die Ressourcen der Version `1.0-SNAPSHOT` werden jedes Mal aktualisiert, sodass sich die Version immer auf den neuesten Build für diese Version bezieht. Die Aktualisierung von `1.0-SNAPSHOT` mit den neuesten Assets wird durch das Hochladen der `maven-metadata.xml` Datei für den neuen Build initiiert. 

## Snapshot-Versionen werden konsumiert
<a name="maven-consuming-snapshot-versions"></a>

Wenn Sie einen Snapshot anfordern, `Published` wird die Version mit dem Status zurückgegeben. Dies ist immer die neueste Version des Maven-Snapshots. Sie können auch einen bestimmten Build eines Snapshots anfordern, indem Sie die Build-Versionsnummer (z. B.`1.0-20210728.194552-1`) anstelle der Snapshot-Version (z. B.`1.0-SNAPSHOT`) im URL-Pfad verwenden. Um die Build-Versionen eines Maven-Snapshots zu sehen, verwenden Sie die [ListPackageVersions ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersions.html)API im *CodeArtifact API-Leitfaden* und setzen Sie den Status-Parameter auf`Unlisted`.

## Löschen von Snapshot-Versionen
<a name="maven-deleting-snapshot-versions"></a>

Um alle Build-Versionen eines Maven-Snapshots zu löschen, verwenden Sie die [DeletePackageVersions](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_DeletePackageVersions.html)API und geben Sie die Versionen an, die Sie löschen möchten.

## Veröffentlichung von Snapshots mit Curl
<a name="maven-snapshot-publishing-curl"></a>

Wenn Sie bestehende Snapshot-Versionen in Amazon Simple Storage Service (Amazon S3) oder einem anderen Artefakt-Repository-Produkt gespeichert haben, möchten Sie diese möglicherweise erneut veröffentlichen. AWS CodeArtifact Aufgrund der CodeArtifact Unterstützung von Maven-Snapshots (siehe[Veröffentlichung von Snapshots in CodeArtifact](#maven-snapshot-publishing)) `curl` ist das Veröffentlichen von Snapshots mit einem generischen HTTP-Client komplexer als das Veröffentlichen von Maven-Release-Versionen, wie unter beschrieben. [Publizieren mit curl](maven-curl.md) Beachten Sie, dass dieser Abschnitt nicht relevant ist, wenn Sie Snapshot-Versionen mit einem Maven-Client wie oder erstellen und bereitstellen. `mvn` `gradle` Sie müssen der Dokumentation für diesen Client folgen.

Das Veröffentlichen einer Snapshot-Version beinhaltet das Veröffentlichen eines oder mehrerer Builds einer Snapshot-Version. Wenn es *n* Builds einer Snapshot-Version gibt, gibt es *n \+ 1* CodeArtifact Versionen: *n* Build-Versionen, alle mit dem Status`Unlisted`, und eine Snapshot-Version (der letzte veröffentlichte Build) mit dem Status`Published`. CodeArtifact Die Snapshot-Version (d. h. die Version mit einer Versionszeichenfolge, die „-SNAPSHOT“ enthält) enthält einen identischen Satz von Assets wie der zuletzt veröffentlichte Build. Die einfachste Methode, diese Struktur zu erstellen, `curl` ist wie folgt:

1. Veröffentlichen Sie alle Assets aller Builds mit`curl`. 

1. Veröffentlichen Sie die `maven-metadata.xml` Datei des letzten Builds (d. h. den Build mit dem aktuellsten Datums- und Zeitstempel) mit. `curl` Dadurch wird eine Version mit „`-SNAPSHOT`“ in der Versionszeichenfolge und mit den richtigen Elementen erstellt.

1. Verwenden Sie die [UpdatePackageVersionsStatus](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html)API, um den Status aller nicht neuesten Build-Versionen auf `Unlisted` festzulegen. 

 Verwenden Sie die folgenden `curl` Befehle, um Snapshot-Assets (wie .jar- und .pom-Dateien) für die Snapshot-Version `1.0-SNAPSHOT` eines Pakets zu veröffentlichen: `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}}
```

Wenn Sie diese Beispiele verwenden:
+ Ersetze es {{my\_domain}} durch deinen CodeArtifact Domainnamen.
+ {{111122223333}}Ersetzen Sie es durch die AWS-Konto ID des Inhabers Ihrer CodeArtifact Domain.
+ {{us-west-2}}Ersetzen Sie durch die, AWS-Region in der sich Ihre CodeArtifact Domain befindet.
+ Ersetze es {{my\_maven\_repo}} durch deinen CodeArtifact Repository-Namen.

**Wichtig**  
Sie müssen dem Wert des `--data-binary` Parameters das `@` Zeichen voranstellen. Wenn Sie den Wert in Anführungszeichen setzen, `@` muss er innerhalb der Anführungszeichen stehen.

Möglicherweise müssen Sie für jeden Build mehr als zwei Assets hochladen. Beispielsweise könnten neben den Haupt-JAR- und Javadoc-Dateien auch Javadoc- und JAR-Quelldateien vorhanden sein. `pom.xml` Es ist nicht notwendig, Prüfsummendateien für die Paketversions-Assets zu veröffentlichen, da CodeArtifact automatisch Prüfsummen für jedes hochgeladene Asset generiert werden. Um zu überprüfen, ob die Assets korrekt hochgeladen wurden, rufen Sie die generierten Prüfsummen mit dem `list-package-version-assets` Befehl ab und vergleichen Sie sie mit den ursprünglichen Prüfsummen. Weitere Informationen zum CodeArtifact Umgang mit Maven-Prüfsummen finden Sie unter. [Verwenden Sie Maven-Prüfsummen](maven-checksums.md)

Verwenden Sie den folgenden curl-Befehl, um die `maven-metadata.xml` Datei für die neueste Build-Version zu veröffentlichen:

```
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
```

Die `maven-metadata.xml` Datei muss auf mindestens eines der Assets in der neuesten Build-Version im `<snapshotVersions>` Element verweisen. Darüber hinaus muss der `<timestamp>` Wert vorhanden sein und mit dem Zeitstempel in den Asset-Dateinamen übereinstimmen. Für den zuvor veröffentlichten `20210729.171330-2` Build `maven-metadata.xml` wäre der Inhalt von beispielsweise: 

```
<?xml version="1.0" encoding="UTF-8"?>
<metadata>
  <groupId>com.mycompany.app</groupId>
  <artifactId>pkg-1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <versioning>
    <snapshot>
      <timestamp>20210729.171330</timestamp>
      <buildNumber>2</buildNumber>
    </snapshot>
    <lastUpdated>20210729171330</lastUpdated>
    <snapshotVersions>
      <snapshotVersion>
        <extension>jar</extension>
        <value>1.0-20210729.171330-2</value>
        <updated>20210729171330</updated>
      </snapshotVersion>
      <snapshotVersion>
        <extension>pom</extension>
        <value>1.0-20210729.171330-2</value>
        <updated>20210729171330</updated>
      </snapshotVersion>
    </snapshotVersions>
  </versioning>
</metadata>
```

Nach der Veröffentlichung `maven-metadata.xml` besteht der letzte Schritt darin, allen anderen Build-Versionen (d. h. allen Build-Versionen außer dem letzten Build) den Paketversionsstatus von zuzuweisen`Unlisted`. Wenn die `1.0-SNAPSHOT` Version beispielsweise zwei Builds hat, wobei der erste Build ist, lautet der Befehl`20210728.194552-1`, auf den dieser Build gesetzt werden `Unlisted` soll:

```
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
```

## Schnappschüsse und externe Verbindungen
<a name="maven-snapshot-external-connections"></a>

Maven-Snapshots können nicht über eine externe Verbindung aus einem öffentlichen Maven-Repository abgerufen werden. AWS CodeArtifact unterstützt nur den Import von Maven-Release-Versionen.

## Snapshots und Upstream-Repositorys
<a name="maven-snapshot-upstream-repositories"></a>

Im Allgemeinen funktionieren Maven-Snapshots genauso wie Release-Versionen von Maven, wenn sie mit Upstream-Repositorys verwendet werden. Es gibt jedoch eine Einschränkung, wenn Sie planen, Snapshots derselben Paketversion in zwei Repositorys zu veröffentlichen, die eine Upstream-Beziehung haben. Nehmen wir zum Beispiel an, es gibt zwei Repositorys in einer AWS CodeArtifact Domain `R` und `U` wo ist ein Upstream von. `U` `R` Wenn Sie einen neuen Build in `R` veröffentlichen und ein Maven-Client den neuesten Build dieser Snapshot-Version anfordert, wird die neueste Version von CodeArtifact zurückgegeben. `U` Dies kann unerwartet sein, da die neueste Version jetzt verfügbar ist`R`, nicht`U`. Es gibt zwei Möglichkeiten, dies zu vermeiden:

1. Veröffentlichen Sie keine Builds einer Snapshot-Version wie `1.0-SNAPSHOT` in`R`, falls `1.0-SNAPSHOT` vorhanden in`U`.

1. Verwenden Sie die Einstellungen zur CodeArtifact Paketherkunft, um Upstreams für dieses Paket in `R` zu deaktivieren. Letzteres ermöglicht es Ihnen, Builds von `1.0-SNAPSHOT` in zu veröffentlichen`R`, `R` verhindert aber auch, dass andere Versionen dieses Pakets abgerufen werden, `U` die nicht bereits gespeichert sind.