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. # Verwendung CodeArtifact mit Maven Das Maven-Repository-Format wird von vielen verschiedenen Sprachen verwendet, darunter Java, Kotlin, Scala und Clojure. Es wird von vielen verschiedenen Build-Tools unterstützt, darunter Maven, Gradle, Scala SBT, Apache Ivy und Leiningen. Wir haben die Kompatibilität mit den folgenden Versionen getestet und bestätigt: CodeArtifact + Letzte **Maven-Version**: 3.6.3. + Die neueste **Gradle-Version**: 6.4.1. 5.5.1 wurde ebenfalls getestet. + Die neueste **Clojure-Version**: 1.11.1 wurde ebenfalls getestet. **Topics** + [CodeArtifact Mit Gradle verwenden](maven-gradle.md) + [CodeArtifact Mit MVN verwenden](maven-mvn.md) + [CodeArtifact Mit deps.edn verwenden](maven-deps.md) + [Publizieren mit curl](maven-curl.md) + [Verwenden Sie Maven-Prüfsummen](maven-checksums.md) + [Verwenden Sie Maven-Snapshots](maven-snapshots.md) + [Maven-Pakete von Upstreams und externen Verbindungen anfordern](maven-upstream-external-connections-request.md) + [Fehlerbehebung in Maven](maven-troubleshooting.md) # CodeArtifact Mit Gradle verwenden Nachdem Sie das CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen gespeichert haben, wie unter [Ein Authentifizierungstoken mithilfe einer Umgebungsvariablen übergeben](tokens-authentication.md#env-var) beschrieben, folgen Sie diesen Anweisungen, um Maven-Pakete aus einem Repository zu konsumieren und neue Pakete in einem Repository zu veröffentlichen. CodeArtifact **Topics** + [Abhängigkeiten abrufen](#fetching-dependencies) + [Plugins abrufen](#fetching-plugins) + [Veröffentlichen Sie Artefakte](#publishing-artifacts) + [Führen Sie einen Gradle-Build in IntelliJ IDEA aus](#gradle-intellij) ## Abhängigkeiten abrufen Verwenden Sie das folgende Verfahren, um Abhängigkeiten aus CodeArtifact einem Gradle-Build abzurufen. **Um Abhängigkeiten aus CodeArtifact einem Gradle-Build abzurufen** 1. Wenn nicht, erstellen und speichern Sie ein CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen, indem Sie das Verfahren unter befolgen. [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) 1. Fügen Sie dem `maven` Abschnitt in der `build.gradle` Projektdatei einen `repositories` Abschnitt hinzu. ``` maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password System.env.CODEARTIFACT_AUTH_TOKEN } } ``` Das `url` Beispiel oben ist der Endpunkt Ihres CodeArtifact Repositorys. Gradle verwendet den Endpunkt, um eine Verbindung zu Ihrem Repository herzustellen. Im Beispiel `my_domain` ist dies der Name Ihrer Domain, `111122223333` die ID des Eigentümers der Domain und `my_repo` der Name Ihres Repositorys. Sie können den Endpunkt eines Repositorys mit dem `get-repository-endpoint` AWS CLI Befehl abrufen. Bei einem Repository, das *my\$1repo* innerhalb einer Domain mit dem Namen benannt ist*my\$1domain*, lautet der Befehl beispielsweise wie folgt: ``` aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven ``` Der `get-repository-endpoint` Befehl gibt den Repository-Endpunkt zurück: ``` url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' ``` Das `credentials` Objekt im vorherigen Beispiel enthält das CodeArtifact Authentifizierungstoken, das Sie in Schritt 1 erstellt haben und das Gradle zur Authentifizierung verwendet. CodeArtifact **Anmerkung** Um einen Dual-Stack-Endpunkt zu verwenden, verwenden Sie den Endpunkt. `codeartifact.region.on.aws` 1. (Optional) — Um das CodeArtifact Repository als einzige Quelle für Ihre Projektabhängigkeiten zu verwenden, entfernen Sie alle anderen Abschnitte in `repositories` von. `build.gradle` Wenn Sie mehr als ein Repository haben, durchsucht Gradle jedes Repository nach Abhängigkeiten in der Reihenfolge, in der sie aufgelistet sind. 1. Nachdem Sie das Repository konfiguriert haben, können Sie dem `dependencies` Abschnitt Projektabhängigkeiten mit der Standard-Gradle-Syntax hinzufügen. ``` dependencies { implementation 'com.google.guava:guava:27.1-jre' implementation 'commons-cli:commons-cli:1.4' testImplementation 'org.testng:testng:6.14.3' } ``` ## Plugins abrufen Standardmäßig löst Gradle Plugins aus dem öffentlichen [Gradle](https://plugins.gradle.org/) Plugin Portal auf. Gehen Sie wie folgt vor, um Plugins aus einem CodeArtifact Repository abzurufen. **Um Plugins aus einem CodeArtifact Repository abzurufen** 1. Falls nicht, erstellen und speichern Sie ein CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen, indem Sie das Verfahren unter befolgen. [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) 1. Fügen Sie Ihrer `settings.gradle` Datei einen `pluginManagement` Block hinzu. Der `pluginManagement` Block muss vor allen anderen Anweisungen in erscheinen`settings.gradle`, siehe den folgenden Ausschnitt: ``` 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 } } } } ``` Dadurch wird sichergestellt, dass Gradle Plugins aus dem angegebenen Repository auflöst. Das Repository muss über ein Upstream-Repository mit einer externen Verbindung zum Gradle-Plugin-Portal (z. B.`gradle-plugins-store`) verfügen, damit die häufig benötigten Gradle-Plugins für den Build verfügbar sind. [Weitere Informationen finden Sie in der Gradle-Dokumentation.](https://docs.gradle.org/current/userguide/plugins.html#sec:custom_plugin_repositories) ## Veröffentlichen Sie Artefakte In diesem Abschnitt wird beschrieben, wie Sie eine mit Gradle erstellte Java-Bibliothek in einem CodeArtifact Repository veröffentlichen. Fügen Sie zunächst das `maven-publish` Plugin zum `plugins` Abschnitt der `build.gradle` Projektdatei hinzu. ``` plugins { id 'java-library' id 'maven-publish' } ``` Als Nächstes fügen Sie der `build.gradle` Projektdatei einen `publishing` Abschnitt hinzu. ``` 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 } } } } ``` Das `maven-publish` Plugin generiert eine POM-Datei auf der Grundlage von`groupId`, und`artifactId`, die im `publishing` Abschnitt `version` angegeben sind. Wenn diese Änderungen abgeschlossen `build.gradle` sind, führen Sie den folgenden Befehl aus, um das Projekt zu erstellen und in das Repository hochzuladen. ``` ./gradlew publish ``` Verwenden Sie diese Option, `list-package-versions` um zu überprüfen, ob das Paket erfolgreich veröffentlicht wurde. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven\ --namespace com.company.framework --package my-package-name ``` Beispielausgabe: ``` { "format": "maven", "namespace": "com.company.framework", "package": "example", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` Weitere Informationen finden Sie in den folgenden Themen auf der Gradle-Website: + [Java-Bibliotheken erstellen](https://guides.gradle.org/building-java-libraries/) + [Ein Projekt als Modul veröffentlichen](https://docs.gradle.org/current/userguide/publishing_setup.html) ## Führen Sie einen Gradle-Build in IntelliJ IDEA aus Sie können einen Gradle-Build in IntelliJ IDEA ausführen, der Abhängigkeiten abruft. CodeArtifact Um sich zu authentifizieren CodeArtifact, müssen Sie Gradle ein Autorisierungstoken zur Verfügung stellen. CodeArtifact Es gibt drei Methoden, um ein Authentifizierungstoken bereitzustellen. + Methode 1: Speichern des Authentifizierungstokens in. `gradle.properties` Verwenden Sie diese Methode, wenn Sie den Inhalt der Datei überschreiben oder ihn erweitern können. `gradle.properties` + Methode 2: Speichern des Authentifizierungstokens in einer separaten Datei. Verwenden Sie diese Methode, wenn Sie Ihre `gradle.properties` Datei nicht ändern möchten. + Methode 3: Generieren eines neuen Authentifizierungstokens für jeden Lauf, indem es `aws` als Inline-Skript in `build.gradle` ausgeführt wird. Verwenden Sie diese Methode, wenn Sie möchten, dass das Gradle-Skript bei jedem Lauf ein neues Token abruft. Das Token wird nicht im Dateisystem gespeichert. ------ #### [ Token stored in gradle.properties ] **Methode 1: Speichern des Authentifizierungstokens in `gradle.properties`** **Anmerkung** Das Beispiel zeigt die `gradle.properties` Datei in`GRADLE_USER_HOME`. 1. Aktualisieren Sie Ihre `build.gradle` Datei mit dem folgenden Codeausschnitt: ``` repositories { maven { url 'https://my_domain-111122223333.d.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username "aws" password "$codeartifactToken" } } } ``` 1. Um Plugins abzurufen CodeArtifact, füge deiner Datei einen `pluginManagement` Block hinzu. `settings.gradle` Der `pluginManagement` Block muss vor allen anderen Anweisungen in `settings.gradle` erscheinen. ``` pluginManagement { repositories { maven { name 'my_repo' url 'https://my_domain-111122223333.codeartifact.region.amazonaws.com/maven/my_repo/' credentials { username 'aws' password "$codeartifactToken" } } } } ``` 1. Rufen Sie ein CodeArtifact Authentifizierungstoken ab: ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Schreiben Sie das Authentifizierungstoken in die Datei: `gradle.properties` ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > ~/.gradle/gradle.properties ``` ------ #### [ Token stored in separate file ] **Methode 2: Speichern des Authentifizierungstokens in einer separaten Datei** 1. Aktualisieren Sie Ihre `build.gradle` Datei mit dem folgenden Snippet: ``` 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. Um Plugins abzurufen CodeArtifact, füge deiner Datei einen `pluginManagement` Block hinzu. `settings.gradle` Der `pluginManagement` Block muss vor allen anderen Anweisungen in `settings.gradle` erscheinen. ``` 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. Rufen Sie ein CodeArtifact Authentifizierungstoken ab: ``` export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text --profile profile-name` ``` 1. Schreiben Sie das Authentifizierungstoken in die Datei, die in Ihrer Datei angegeben wurde: `build.gradle` ``` echo "codeartifactToken=$CODEARTIFACT_AUTH_TOKEN" > file ``` ------ #### [ Token generated for each run in build.gradle ] **Methode 3: Generieren eines neuen Authentifizierungstokens für jeden Lauf durch Ausführung `aws` als Inline-Skript in `build.gradle`** 1. Aktualisieren Sie Ihre `build.gradle` Datei mit dem folgenden Snippet: ``` 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. Um Plugins abzurufen CodeArtifact, füge deiner Datei einen `pluginManagement` Block hinzu. `settings.gradle` Der `pluginManagement` Block muss vor allen anderen Anweisungen in `settings.gradle` erscheinen. ``` 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 } } } } ``` ------ # CodeArtifact Mit MVN verwenden Sie verwenden den `mvn` Befehl, um Maven-Builds auszuführen. In diesem Abschnitt wird gezeigt, wie Sie die Verwendung eines CodeArtifact Repositorys konfigurieren`mvn`. **Topics** + [Abhängigkeiten abrufen](#fetching-dependencies) + [Artefakte veröffentlichen](#publishing-artifacts) + [Veröffentlichen Sie Artefakte von Drittanbietern](#publishing-third-party-artifacts) + [Beschränken Sie das Herunterladen von Maven-Abhängigkeiten auf ein Repository CodeArtifact](#restrict-maven-downloads) + [Informationen zum Apache Maven-Projekt](#apache-maven-project-info) ## Abhängigkeiten abrufen Um das Abrufen von Abhängigkeiten aus einem CodeArtifact Repository `mvn` zu konfigurieren, müssen Sie die Maven-Konfigurationsdatei und optional das POM Ihres Projekts bearbeiten. `settings.xml` 1. Falls nicht, erstellen und speichern Sie ein CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen, wie unter [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) So richten Sie die Authentifizierung für Ihr Repository ein. CodeArtifact 1. Fügen Sie unter `settings.xml` (normalerweise zu finden unter`~/.m2/settings.xml`) einen `` Abschnitt mit einem Verweis auf die `CODEARTIFACT_AUTH_TOKEN` Umgebungsvariable hinzu, sodass Maven das Token in HTTP-Anfragen weitergibt. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Fügen Sie den URL-Endpunkt für Ihr CodeArtifact Repository in einem `` Element hinzu. Sie können dies in der POM-Datei `settings.xml` oder in der POM-Datei Ihres Projekts tun. Sie können den Endpunkt Ihres Repositorys mit dem `get-repository-endpoint` AWS CLI Befehl abrufen. Bei einem Repository, das *my\$1repo* innerhalb einer Domain mit dem Namen benannt ist*my\$1domain*, lautet der Befehl beispielsweise wie folgt: ``` aws codeartifact get-repository-endpoint --domain my_domain --repository my_repo --format maven ``` Der `get-repository-endpoint` Befehl gibt den Repository-Endpunkt zurück: ``` url 'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/' ``` **Anmerkung** Um einen Dual-Stack-Endpunkt zu verwenden, verwenden Sie den `codeartifact.region.on.aws` Endpunkt. Fügen Sie den Repository-Endpunkt `settings.xml` wie folgt hinzu. ``` ... default codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ default ... ``` Sie können den `` Abschnitt auch zu einer POM-Projekt-Datei hinzufügen, um ihn nur CodeArtifact für dieses Projekt zu verwenden. ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` **Wichtig** Sie können einen beliebigen Wert im `` Element verwenden, dieser muss jedoch in den `` Elementen `` und identisch sein. Dadurch können die angegebenen Anmeldeinformationen in Anfragen an aufgenommen werden CodeArtifact. Nachdem Sie diese Konfigurationsänderungen vorgenommen haben, können Sie das Projekt erstellen. ``` mvn compile ``` Maven protokolliert die vollständige URL aller Abhängigkeiten, die es auf die Konsole herunterlädt. ``` [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) ``` ## Artefakte veröffentlichen Um ein Maven-Artefakt mit in einem CodeArtifact Repository `mvn` zu veröffentlichen, müssen Sie auch das Projekt `~/.m2/settings.xml` POM bearbeiten. 1. Falls nicht, erstellen und speichern Sie ein CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen, wie unter [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) So richten Sie die Authentifizierung für Ihr Repository ein. CodeArtifact 1. Fügen Sie einen `` Abschnitt `settings.xml` mit einem Verweis auf die `CODEARTIFACT_AUTH_TOKEN` Umgebungsvariable hinzu, sodass Maven das Token in HTTP-Anfragen weitergibt. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Fügen Sie Ihrem Projekt einen `` Abschnitt hinzu. `pom.xml` ``` ... codeartifact codeartifact https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ ... ``` Nachdem Sie diese Konfigurationsänderungen vorgenommen haben, können Sie das Projekt erstellen und im angegebenen Repository veröffentlichen. ``` mvn deploy ``` Wird verwendet`list-package-versions`, um zu überprüfen, ob das Paket erfolgreich veröffentlicht wurde. ``` aws codeartifact list-package-versions --domain my_domain --domain-owner 111122223333 --repository my_repo --format maven \ --namespace com.company.framework --package my-package-name ``` Beispielausgabe: ``` { "defaultDisplayVersion": null, "format": "maven", "namespace": "com.company.framework", "package": "my-package-name", "versions": [ { "version": "1.0", "revision": "REVISION-SAMPLE-1-C7F4S5E9B772FC", "status": "Published" } ] } ``` ## Veröffentlichen Sie Artefakte von Drittanbietern Sie können Maven-Artefakte von Drittanbietern in einem CodeArtifact Repository mit `mvn deploy:deploy-file` veröffentlichen. Dies kann für Benutzer hilfreich sein, die Artefakte veröffentlichen möchten und nur über JAR-Dateien verfügen und keinen Zugriff auf Paketquellcode oder POM-Dateien haben. Der `mvn deploy:deploy-file` Befehl generiert eine POM-Datei auf der Grundlage der in der Befehlszeile übergebenen Informationen. **Veröffentlichen Sie Maven-Artefakte von Drittanbietern** 1. Falls nicht, erstellen und speichern Sie ein CodeArtifact Authentifizierungstoken in einer Umgebungsvariablen, wie unter [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) So richten Sie die Authentifizierung für Ihr CodeArtifact Repository ein. 1. Erstellen Sie eine `~/.m2/settings.xml` Datei mit dem folgenden Inhalt: ``` codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ``` 1. Führen Sie den Befehl `mvn deploy:deploy-file` aus: ``` 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/ ``` **Anmerkung** Das obige Beispiel veröffentlicht`commons-cli 1.4`. Ändern Sie die Argumente groupId, artifactID, version und file, um eine andere JAR zu veröffentlichen. Diese Anweisungen basieren auf Beispielen im [Leitfaden zur Bereitstellung eines JARs Drittanbieter-Repositorys](https://maven.apache.org/guides/mini/guide-3rd-party-jars-remote.html) in der *Apache* Maven-Dokumentation. ## Beschränken Sie das Herunterladen von Maven-Abhängigkeiten auf ein Repository CodeArtifact Wenn ein Paket nicht aus einem konfigurierten Repository abgerufen werden kann, ruft der `mvn` Befehl es standardmäßig von Maven Central ab. Fügen Sie das `mirrors` Element hinzu, damit `settings.xml` Sie `mvn` immer Ihr Repository verwenden können. CodeArtifact ``` ... central-mirror CodeArtifact Maven Central mirror https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ central ... ``` Wenn Sie ein `mirrors` Element hinzufügen, müssen Sie auch ein `pluginRepository` Element in Ihrem `settings.xml` oder haben`pom.xml`. Im folgenden Beispiel werden Anwendungsabhängigkeiten und Maven-Plugins aus einem CodeArtifact Repository abgerufen. ``` ... codeartifact CodeArtifact Plugins https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/ true true ... ``` Im folgenden Beispiel werden Anwendungsabhängigkeiten aus einem CodeArtifact Repository und Maven-Plugins aus Maven Central abgerufen. ``` default ... central-plugins Central Plugins https://repo.maven.apache.org/maven2/ true true .... ``` ## Informationen zum Apache Maven-Projekt Weitere Informationen zu Maven finden Sie in den folgenden Themen auf der Apache Maven Project-Website: + [Einrichtung mehrerer Repositorys](https://maven.apache.org/guides/mini/guide-multiple-repositories.html) + [Referenz für Einstellungen](https://maven.apache.org/settings.html) + [Vertriebsmanagement](https://maven.apache.org/pom.html#Distribution_Management) + [Profile](https://maven.apache.org/pom.html#Profiles) # CodeArtifact Mit deps.edn verwenden Sie verwenden `deps.edn` with, `clj` um Abhängigkeiten für Clojure-Projekte zu verwalten. In diesem Abschnitt wird gezeigt, wie Sie die Verwendung eines `deps.edn` CodeArtifact Repositorys konfigurieren. **Topics** + [Abhängigkeiten abrufen](#fetching-dependencies-deps) + [Artefakte veröffentlichen](#publishing-artifacts-deps) ## Abhängigkeiten abrufen Um das Abrufen von Abhängigkeiten aus einem CodeArtifact Repository `Clojure` zu konfigurieren, müssen Sie die Maven-Konfigurationsdatei bearbeiten,. `settings.xml` 1. Fügen Sie `` unter einen Abschnitt mit einem Verweis auf die `CODEARTIFACT_AUTH_TOKEN` Umgebungsvariable hinzu, sodass Clojure das Token in HTTP-Anfragen weitergibt. `settings.xml` **Anmerkung** Clojure erwartet, dass sich die Datei settings.xml unter befindet. `~/.m2/settings.xml` Falls an einem anderen Ort, erstellen Sie die Datei an diesem Ort. ``` ... codeartifact aws ${env.CODEARTIFACT_AUTH_TOKEN} ... ``` 1. Wenn Sie noch keine haben, generieren Sie mit Hilfe von POM-XML für Ihr Projekt`clj -Spom`. 1. Fügen Sie in Ihrer `deps.edn` Konfigurationsdatei ein Repository hinzu, das der Server-ID von Maven `settings.xml` entspricht. ``` :mvn/repos { "clojars" nil "central" nil "codeartifact" {:url "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/maven/my_repo/"} } ``` **Anmerkung** `tools.deps`garantiert, dass die `central` und `clojars` -Repositorien zuerst auf Maven-Bibliotheken überprüft werden. Danach werden die anderen unter aufgeführten Repositorien überprüft. `deps.edn` Um das direkte Herunterladen von Clojars und Maven Central zu verhindern, `clojars` muss dies auf `central` eingestellt sein. `nil` Stellen Sie sicher, dass Sie das CodeArtifact Auth-Token in einer Umgebungsvariablen haben (siehe). [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) Wenn Sie das Paket nach diesen Änderungen erstellen, `deps.edn` werden die Abhängigkeiten von abgerufen. CodeArtifact **Anmerkung** Um einen Dual-Stack-Endpunkt zu verwenden, verwenden Sie den Endpunkt. `codeartifact.region.on.aws` ## Artefakte veröffentlichen 1. Aktualisieren Sie Ihre Maven-Einstellungen und fügen Sie `deps.edn` sie CodeArtifact als Server hinzu, der von Maven erkannt wurde (siehe). [Abhängigkeiten abrufen](#fetching-dependencies-deps) Sie können ein Tool wie [deps-deploy](https://github.com/slipset/deps-deploy) verwenden, um Artefakte hochzuladen. CodeArtifact 1. Fügen Sie in Ihrem eine `deploy` Aufgabe hinzu`build.clj`, um die erforderlichen Artefakte in das zuvor eingerichtete Repository hochzuladen. `codeartifact` ``` (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. Veröffentlichen Sie das Artefakt, indem Sie den folgenden Befehl ausführen: `clj -T:build deploy` Weitere Informationen zum Ändern von Standard-Repositorys finden Sie unter [Ändern der Standard-Repositorys in der](https://clojure.org/reference/deps_and_cli#_modifying_the_default_repositories) *Clojure Deps* and CLI Reference Rationale. # Publizieren mit curl In diesem Abschnitt wird gezeigt, wie Sie den HTTP-Client verwenden`curl`, um Maven-Artefakte in einem CodeArtifact Repository zu veröffentlichen. Das Veröffentlichen von Artefakten mit `curl` kann nützlich sein, wenn Sie den Maven-Client nicht in Ihren Umgebungen haben oder installieren möchten. **Veröffentlichen Sie ein Maven-Artefakt mit `curl`** 1. Rufen Sie ein CodeArtifact Autorisierungstoken ab, indem Sie die Schritte unter befolgen [Übergeben Sie ein Authentifizierungstoken mithilfe einer Umgebungsvariablen](tokens-authentication.md#env-var) und zu diesen Schritten zurückkehren. 1. Verwenden Sie den folgenden `curl` Befehl, um die JAR in einem CodeArtifact Repository zu veröffentlichen: Ersetzen Sie in jedem der `curl` Befehle in diesem Verfahren die folgenden Platzhalter: + Ersetzen Sie es *my\$1domain* durch Ihren CodeArtifact Domainnamen. + *111122223333*Ersetzen Sie es durch die ID des Inhabers Ihrer CodeArtifact Domain. + *us-west-2*Ersetzen Sie durch die Region, in der sich Ihre CodeArtifact Domain befindet. + Ersetze es *my\$1repo* durch deinen CodeArtifact Repository-Namen. ``` 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 ``` **Wichtig** Sie müssen dem Wert des `--data-binary` Parameters ein `@` Zeichen voranstellen. Wenn Sie den Wert in Anführungszeichen setzen, `@` muss er innerhalb der Anführungszeichen stehen. 1. Verwenden Sie den folgenden `curl` Befehl, um das POM in einem CodeArtifact Repository zu veröffentlichen: ``` 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. Zu diesem Zeitpunkt befindet sich das Maven-Artefakt in Ihrem CodeArtifact Repository mit dem Status. `Unfinished` Um das Paket nutzen zu können, muss es sich im `Published` Status befinden. Sie können das Paket von `Unfinished` nach verschieben, `Published` indem Sie entweder eine `maven-metadata.xml` Datei in Ihr Paket hochladen oder die [UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) aufrufen, um den Status zu ändern. 1. Option 1: Verwenden Sie den folgenden `curl` Befehl, um Ihrem Paket eine `maven-metadata.xml` Datei hinzuzufügen: ``` 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 ``` Das Folgende ist ein Beispiel für den Inhalt einer `maven-metadata.xml` Datei: ``` com.mycompany.app my-app 1.0 1.0 1.0 20200731090423 ``` 1. Option 2: Aktualisieren Sie den Paketstatus `Published` mit der `UpdatePackageVersionsStatus` API auf. ``` 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 ``` Wenn Sie nur über die JAR-Datei eines Artefakts verfügen, können Sie eine verbrauchbare Paketversion in einem CodeArtifact Repository veröffentlichen, indem Sie. `mvn` Dies kann nützlich sein, wenn Sie keinen Zugriff auf den Quellcode oder POM des Artefakts haben. Details dazu finden Sie unter [Veröffentlichen Sie Artefakte von Drittanbietern](maven-mvn.md#publishing-third-party-artifacts). # Verwenden Sie Maven-Prüfsummen Wenn ein Maven-Artefakt in einem AWS CodeArtifact Repository veröffentlicht wird, wird die Prüfsumme, die jedem *Asset* oder jeder Datei im Paket zugeordnet ist, zur Validierung des Uploads verwendet. *Beispiele für Assets sind *JAR* -, *POM* - und WAR-Dateien.* Für jedes Asset enthält das Maven-Artefakt mehrere Prüfsummendateien, die den Asset-Namen mit einer zusätzlichen Erweiterung verwenden, z. B. oder. `md5` `sha1` Beispielsweise könnten die Prüfsummendateien für eine Datei mit dem Namen `my-maven-package.jar` und lauten. `my-maven-package.jar.md5` `my-maven-package.jar.sha1` **Anmerkung** Maven verwendet den Begriff. `artifact` In diesem Handbuch entspricht ein Maven-Paket einem Maven-Artefakt. [Weitere Informationen finden Sie unter Paket.AWS CodeArtifact](https://docs.aws.amazon.com/codeartifact/latest/ug/welcome.html#welcome-concepts-package) ## Prüfsummenspeicher CodeArtifact speichert Maven-Prüfsummen nicht als Vermögenswerte. [Das bedeutet, dass Prüfsummen nicht als einzelne Assets in der Ausgabe der API erscheinen. ListPackageVersionAssets ](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_ListPackageVersionAssets.html) Stattdessen CodeArtifact sind Prüfsummen, die von berechnet wurden, für jedes Asset in allen unterstützten Prüfsummentypen verfügbar. Ein Teil der Antwort auf den Aufruf der ListPackageVersionAssets Maven-Paketversion lautet beispielsweise: `commons-lang:commons-lang 2.1` ``` { "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" } } ``` Auch wenn Prüfsummen nicht als Assets gespeichert werden, können Maven-Clients Prüfsummen dennoch an den erwarteten Speicherorten veröffentlichen und herunterladen. Wenn sie beispielsweise in einem Repository aufgerufen `commons-lang:commons-lang 2.1` `maven-repo` wurde, würde der URL-Pfad für die SHA-256-Prüfsumme der JAR-Datei wie folgt lauten: ``` /maven/maven-repo/commons-lang/commons-lang/2.1/commons-lang-2.1.jar.sha256 ``` Wenn Sie bestehende Maven-Pakete (z. B. Pakete, die zuvor in Amazon S3 gespeichert wurden) auf CodeArtifact einen generischen HTTP-Client wie hochladen, ist es nicht erforderlich`curl`, die Prüfsummen hochzuladen. CodeArtifact generiert sie automatisch. Wenn Sie überprüfen möchten, ob die Assets korrekt hochgeladen wurden, können Sie den ListPackageVersionAssets API-Vorgang verwenden, um die Prüfsummen in der Antwort mit den ursprünglichen Prüfsummenwerten für jedes Asset zu vergleichen. ## Bei der Veröffentlichung stimmen die Prüfsummen nicht überein Neben Assets und Prüfsummen enthalten Maven-Artefakte auch eine Datei. `maven-metadata.xml` Die normale Veröffentlichungsreihenfolge für ein Maven-Paket besteht darin, dass alle Assets und Prüfsummen zuerst hochgeladen werden, gefolgt von. `maven-metadata.xml` Die zuvor `commons-lang 2.1` beschriebene Veröffentlichungsreihenfolge für die Maven-Paketversion, vorausgesetzt, der Client wäre für die Veröffentlichung von SHA-256-Prüfsummendateien konfiguriert, wäre beispielsweise: ``` 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 ``` Beim Hochladen der Prüfsummendatei für ein Asset, z. B. eine JAR-Datei, schlägt die Prüfsummen-Upload-Anfrage mit einer Antwort von **400 (Bad Request)** fehl, wenn zwischen dem hochgeladenen Prüfsummenwert und dem von berechneten Prüfsummenwert eine Diskrepanz besteht. CodeArtifact Wenn das entsprechende Asset nicht existiert, schlägt die Anfrage mit einer **404-Antwort** (Not Found) fehl. Um diesen Fehler zu vermeiden, müssen Sie zuerst das Asset und dann die Prüfsumme hochladen. Wenn hochgeladen `maven-metadata.xml` wird, ändert sich CodeArtifact normalerweise der Status der Maven-Paketversion von `Unfinished` zu. `Published` Wenn bei einem Asset eine nicht übereinstimmende Prüfsumme festgestellt wird, CodeArtifact wird als Antwort auf die Veröffentlichungsanfrage eine **400 (Bad Request)** zurückgegeben. `maven-metadata.xml` Dieser Fehler kann dazu führen, dass der Client das Hochladen von Dateien für diese Paketversion beendet. Wenn dies der Fall ist und die `maven-metadata.xml` Datei nicht hochgeladen wird, können keine Inhalte der bereits hochgeladenen Paketversion heruntergeladen werden. Dies liegt daran, dass der Status der Paketversion nicht auf festgelegt ist `Published` und weiterhin gültig ist`Unfinished`. CodeArtifact ermöglicht das Hinzufügen weiterer Assets zu einer Maven-Paketversion, auch nachdem `maven-metadata.xml` sie hochgeladen wurden und der Status der Paketversion auf `Published` gesetzt wurde. In diesem Status schlägt eine Anfrage zum Hochladen einer nicht übereinstimmenden Prüfsummendatei ebenfalls fehl und es wird eine **400-Antwort (Bad Request**) angezeigt. Da der Paketversionsstatus jedoch bereits auf gesetzt wurde`Published`, können Sie jedes Asset aus dem Paket herunterladen, auch solche, für die der Upload der Prüfsummendatei fehlgeschlagen ist. Wenn Sie eine Prüfsumme für ein Asset herunterladen, bei dem der Upload der Prüfsummendatei fehlgeschlagen ist, ist der Prüfsummenwert, den der Client erhält, der Prüfsummenwert, der auf der CodeArtifact Grundlage der hochgeladenen Asset-Daten berechnet wird. CodeArtifact Bei Prüfsummenvergleichen wird zwischen Groß- und Kleinschreibung unterschieden, und die von berechneten Prüfsummen werden in Kleinbuchstaben formatiert. CodeArtifact Wenn die Prüfsumme hochgeladen `909FA780F76DA393E992A3D2D495F468` wird, schlägt sie daher fehl und die Prüfsumme stimmt nicht überein, da sie CodeArtifact nicht als gleich behandelt wird. `909fa780f76da393e992a3d2d495f468` ## Wiederherstellung nach nicht übereinstimmenden Prüfsummen Wenn ein Prüfsummen-Upload aufgrund einer nicht übereinstimmenden Prüfsumme fehlschlägt, versuchen Sie es mit einem der folgenden Verfahren: + Führen Sie den Befehl, der das Maven-Artefakt veröffentlicht, erneut aus. Dies könnte funktionieren, wenn ein Netzwerkproblem die Prüfsummendatei beschädigt hat. Wenn das Netzwerkproblem dadurch behoben wird, stimmt die Prüfsumme überein und der Download ist erfolgreich. + Löschen Sie die Paketversion und veröffentlichen Sie sie erneut. Weitere Informationen finden Sie [DeletePackageVersions](https://docs.aws.amazon.com/dms/latest/APIReference/API_DeletePackageVersions.html)in der * CodeArtifact AWS-API-Referenz*. # Verwenden Sie Maven-Snapshots 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 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 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 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 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 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\$1domain* 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\$1maven\$1repo* 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 `` Element verweisen. Darüber hinaus muss der `` 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: ``` 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 ``` 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 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 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. # Maven-Pakete von Upstreams und externen Verbindungen anfordern ## Import von Standard-Asset-Namen Beim Import einer Maven-Paketversion aus einem öffentlichen Repository wie Maven Central CodeArtifact versucht AWS, alle Assets in dieser Paketversion zu importieren. Wie unter beschrieben[Eine Paketversion mit Upstream-Repositorys anfordern](repo-upstream-behavior.md), erfolgt der Import in den folgenden Fällen: + Ein Client fordert ein Maven-Asset aus einem CodeArtifact Repository an. + Die Paketversion ist noch nicht im Repository oder seinen Upstreams vorhanden. + Es gibt eine erreichbare externe Verbindung zu einem öffentlichen Maven-Repository. Auch wenn der Client möglicherweise nur ein Asset angefordert hat, CodeArtifact versucht er, alle Assets zu importieren, die er für diese Paketversion finden kann. Wie CodeArtifact festgestellt wird, welche Ressourcen für eine Maven-Paketversion verfügbar sind, hängt vom jeweiligen öffentlichen Repository ab. Einige öffentliche Maven-Repositorien unterstützen das Anfordern einer Liste von Assets, andere jedoch nicht. CodeArtifact Generiert für Repositorys, die keine Möglichkeit bieten, Assets aufzulisten, eine Reihe von Asset-Namen, die wahrscheinlich existieren. Wenn beispielsweise ein Asset der Maven-Paketversion `junit 4.13.2` angefordert CodeArtifact wird, wird versucht, die folgenden Assets zu importieren: + `junit-4.13.2.pom` + `junit-4.13.2.jar` + `junit-4.13.2-javadoc.jar` + `junit-4.13.2-sources.jar` ## Importieren von nicht standardmäßigen Asset-Namen Wenn ein Maven-Client ein Asset anfordert, das keinem der oben beschriebenen Muster entspricht, wird CodeArtifact geprüft, ob dieses Asset im öffentlichen Repository vorhanden ist. Wenn das Asset vorhanden ist, wird es importiert und dem vorhandenen Paketversionsdatensatz hinzugefügt, falls einer existiert. Die Maven-Paketversion `com.android.tools.build:aapt2 7.3.1-8691043` enthält beispielsweise die folgenden Ressourcen: + `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` Wenn ein Client die POM-Datei anfordert und die Ressourcen der Paketversion nicht auflisten kann, ist das POM das einzige importierte Asset. CodeArtifact Dies liegt daran, dass keines der anderen Assets den Standardmustern für Asset-Namen entspricht. Wenn der Client jedoch eines der JAR-Assets anfordert, wird dieses Asset importiert und der vorhandenen Paketversion hinzugefügt, in der gespeichert ist CodeArtifact. Die Paketversionen sowohl im am weitesten nachgelagerten Repository (dem Repository, für das der Client die Anfrage gestellt hat) als auch im Repository, an das die externe Verbindung angeschlossen ist, werden aktualisiert, sodass sie das neue Asset enthalten, wie unter beschrieben. [Aufbewahrung von Paketen aus Upstream-Repositorys](repo-upstream-behavior.md#package-retention-upstream-repos) Sobald eine Paketversion in einem CodeArtifact Repository gespeichert ist, ist sie normalerweise nicht von Änderungen in den Upstream-Repositorys betroffen. Weitere Informationen finden Sie unter [Aufbewahrung von Paketen aus Upstream-Repositorys](repo-upstream-behavior.md#package-retention-upstream-repos). Das zuvor beschriebene Verhalten von Maven-Assets mit nicht standardmäßigen Namen stellt jedoch eine Ausnahme von dieser Regel dar. Die Downstream-Paketversion ändert sich zwar nicht, ohne dass ein zusätzlicher Inhalt von einem Client angefordert wird, aber in diesem Fall wird die beibehaltene Paketversion geändert, nachdem sie ursprünglich beibehalten wurde, und ist daher nicht unveränderlich. Dieses Verhalten ist notwendig, da Maven-Assets mit nicht standardmäßigen Namen andernfalls nicht zugänglich wären. CodeArtifact Dieses Verhalten ist auch möglich, wenn sie zu einer Maven-Paketversion in einem öffentlichen Repository hinzugefügt werden, nachdem die Paketversion in einem Repository aufbewahrt wurde. CodeArtifact ## Die Herkunft von Assets wird überprüft Wenn Sie einer zuvor beibehaltenen Maven-Paketversion ein neues Asset hinzufügen, wird CodeArtifact bestätigt, dass der Ursprung der beibehaltenen Paketversion mit dem Ursprung des neuen Assets identisch ist. Dadurch wird verhindert, dass eine „gemischte“ Paketversion erstellt wird, bei der verschiedene Assets aus unterschiedlichen öffentlichen Repositorys stammen. Ohne diese Prüfung könnte es zu einer Vermischung von Assets kommen, wenn eine Maven-Paketversion in mehr als einem öffentlichen Repository veröffentlicht wird und diese Repositorys Teil des Upstream-Graphen eines CodeArtifact Repositorys sind. ## Import neuer Assets und Paketversionsstatus in Upstream-Repositorys Der [Paketversionsstatus](packages-overview.md#package-version-status) von Paketversionen in Upstream-Repositorys kann CodeArtifact verhindern, dass diese Versionen in Downstream-Repositorys beibehalten werden. Nehmen wir zum Beispiel an, eine Domain hat drei Repositorys:`repo-A`,, und `repo-B``repo-C`, wobei `repo-B` sich ein Upstream von `repo-A` und `repo-C` ein Upstream von befinden. `repo-B` ![\[Ein Diagramm, das zeigt, wie neue Assets und Paketversionen in Upstream-Repositorys funktionieren.\]](http://docs.aws.amazon.com/de_de/codeartifact/latest/ug/images/Maven-new-asset-pv-upstream.png) Die Paketversion `7.3.1` des Maven-Pakets `com.android.tools.build:aapt2` ist in vorhanden `repo-B` und hat den Status. `Published` Es ist nicht vorhanden in`repo-A`. Wenn ein Client ein Asset dieser Paketversion anfordert`repo-A`, lautet die Antwort 200 (OK) und die Maven-Paketversion `7.3.1` wird beibehalten. `repo-A` Wenn der Status der Paketversion `7.3.1` in jedoch `Archived` oder `repo-B` lautet`Disposed`, lautet die Antwort 404 (Not Found), da die Ressourcen der Paketversionen in diesen beiden Status nicht heruntergeladen werden können. Beachten Sie, dass das Setzen der [Paketquellkontrolle](package-origin-controls.md) auf `upstream=BLOCK` for `com.android.tools.build:aapt2` in `repo-A``repo-B`, und `repo-C` verhindert, dass neue Inhalte für alle Versionen dieses Pakets abgerufen werden`repo-A`, unabhängig vom Status der Paketversion. # Fehlerbehebung in Maven Die folgenden Informationen können Ihnen bei der Behebung häufiger Probleme mit Maven und helfen. CodeArtifact ## Deaktivieren Sie parallel Eingaben, um Fehler 429 zu beheben: Zu viele Anfragen Ab Version 3.9.0 lädt Maven Paketartefakte parallel hoch (bis zu 5 Dateien gleichzeitig). Dies kann CodeArtifact dazu führen, dass gelegentlich mit dem Fehlerantwortcode 429 (Zu viele Anfragen) geantwortet wird. Wenn dieser Fehler auftritt, können Sie parallel Eingaben deaktivieren, um ihn zu beheben. Um parallel Puts zu deaktivieren, setzen Sie die `aether.connector.basic.parallelPut` Eigenschaft `false` in Ihrem Profil in Ihrer `settings.xml` Datei auf, wie im folgenden Beispiel gezeigt: ``` default false ``` Weitere Informationen finden Sie unter [Artifact Resolver Configuration Options](https://maven.apache.org/resolver/configuration.html) in der Maven-Dokumentation.