

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 Swift
<a name="using-swift"></a>

In diesen Themen wird beschrieben, wie Sie den Swift Package Manager verwenden CodeArtifact , um Swift-Pakete zu installieren und zu veröffentlichen.

**Anmerkung**  
CodeArtifact unterstützt Swift 5.8 und höher sowie Xcode 14.3 und höher.  
CodeArtifact empfiehlt Swift 5.9 und höher und Xcode 15 und höher.

**Topics**
+ [Konfigurieren Sie Swift mit CodeArtifact](configure-swift.md)
+ [Swift-Pakete konsumieren und veröffentlichen](swift-publish-consume.md)
+ [Schnelle Normalisierung von Paketnamen und Namespace](swift-name-normalization.md)
+ [Schnelle Problembehebung](swift-troubleshooting.md)

# Konfigurieren Sie den Swift Package Manager mit CodeArtifact
<a name="configure-swift"></a>

Um den Swift Package Manager zum Veröffentlichen von Paketen oder zum Konsumieren von Paketen zu verwenden AWS CodeArtifact, müssen Sie zunächst Anmeldeinformationen für den Zugriff auf Ihr CodeArtifact Repository einrichten. Die empfohlene Methode zur Konfiguration der Swift Package Manager-CLI mit Ihren CodeArtifact Anmeldeinformationen und Ihrem Repository-Endpunkt ist die Verwendung des `aws codeartifact login` Befehls. Sie können den Swift Package Manager auch manuell konfigurieren.

## Konfigurieren Sie Swift mit dem Login-Befehl
<a name="configure-swift-login-command"></a>

Verwenden Sie den `aws codeartifact login` Befehl, um den Swift Package Manager mit zu konfigurieren CodeArtifact.

**Anmerkung**  
Um den Login-Befehl zu verwenden, ist Swift 5.8 oder höher erforderlich und Swift 5.9 oder höher wird empfohlen.

Der `aws codeartifact login` Befehl führt Folgendes aus:

1. Rufen Sie ein Authentifizierungstoken von Ihrer Umgebung ab CodeArtifact und speichern Sie es dort. Wie die Anmeldeinformationen gespeichert werden, hängt vom Betriebssystem der Umgebung ab:

   1. **macOS:** In der macOS Keychain App wird ein Eintrag erstellt.

   1. **Linux und Windows:** In der `~/.netrc` Datei wird ein Eintrag erstellt.

   Wenn in allen Betriebssystemen ein Eintrag für Anmeldeinformationen vorhanden ist, ersetzt dieser Befehl diesen Eintrag durch ein neues Token.

1. Rufen Sie die URL Ihres CodeArtifact Repository-Endpunkts ab und fügen Sie sie Ihrer Swift-Konfigurationsdatei hinzu. Der Befehl fügt die Repository-Endpunkt-URL zur Konfigurationsdatei auf Projektebene hinzu, die sich unter `/path/to/project/.swiftpm/configuration/registries.json` befindet.

**Anmerkung**  
Der `aws codeartifact login` Befehl ruft `swift package-registry` Befehle auf, die von dem Verzeichnis aus ausgeführt werden müssen, das die `Package.swift` Datei enthält. Aus diesem Grund muss der `aws codeartifact login` Befehl innerhalb des Swift-Projekts ausgeführt werden.

**Um Swift mit dem Login-Befehl zu konfigurieren**

1. Navigieren Sie zum Swift-Projektverzeichnis, das die `Package.swift` Datei Ihres Projekts enthält.

1. Führen Sie den Befehl `aws codeartifact login` aus.

   Wenn Sie auf ein Repository in einer Domain zugreifen, die Sie besitzen, müssen Sie dies nicht angeben`--domain-owner`. Weitere Informationen finden Sie unter [Kontenübergreifende Domänen](domain-overview.md#domain-overview-cross-account).

   ```
   aws codeartifact login --tool swift --domain my_domain \
   --domain-owner 111122223333 --repository my_repo \
   [--namespace my_namespace]
   ```

Die `--namespace` Option konfiguriert die Anwendung so, dass sie nur Pakete aus Ihrem CodeArtifact Repository verwendet, wenn sie sich im angegebenen Namespace befinden. [CodeArtifact Namespaces](codeartifact-concepts.md#welcome-concepts-package-namespace) sind ein Synonym für Bereiche und werden verwendet, um Code in logische Gruppen zu organisieren und Namenskollisionen zu verhindern, die auftreten können, wenn Ihre Codebasis mehrere Bibliotheken umfasst.

Der Standardzeitraum für die Autorisierung nach dem Aufrufen `login` beträgt 12 Stunden und `login` muss aufgerufen werden, um das Token regelmäßig zu aktualisieren. Weitere Hinweise zu dem mit dem `login` Befehl erstellten Autorisierungstoken finden Sie unter[Mit dem Befehl erstellte Tokens `login`](tokens-authentication.md#auth-token-login).

## Konfigurieren Sie Swift ohne den Login-Befehl
<a name="configure-swift-without-login-command"></a>

Es wird zwar empfohlen, [Swift mit dem `aws codeartifact login` Befehl zu konfigurieren, Sie können den](#configure-swift-login-command) Swift Package Manager jedoch auch ohne den Login-Befehl konfigurieren, indem Sie die Swift Package Manager-Konfiguration manuell aktualisieren.

Im folgenden Verfahren verwenden Sie den, AWS CLI um Folgendes zu tun:

1. Rufen Sie ein Authentifizierungstoken von Ihrer Umgebung ab CodeArtifact und speichern Sie es dort. Wie die Anmeldeinformationen gespeichert werden, hängt vom Betriebssystem der Umgebung ab:

   1. **macOS:** In der macOS Keychain App wird ein Eintrag erstellt.

   1. **Linux und Windows:** In der `~/.netrc` Datei wird ein Eintrag erstellt.

1. Rufen Sie die URL Ihres CodeArtifact Repository-Endpunkts ab.

1. Fügen Sie in der `~/.swiftpm/configuration/registries.json` Konfigurationsdatei einen Eintrag mit Ihrer Repository-Endpunkt-URL und Ihrem Authentifizierungstyp hinzu.

**Um den Swift ohne den Login-Befehl zu konfigurieren**

1. Verwenden Sie in einer Befehlszeile den folgenden Befehl, um ein CodeArtifact Autorisierungstoken abzurufen und es in einer Umgebungsvariablen zu speichern.
   + Ersetzen Sie es *my\$1domain* durch Ihren CodeArtifact Domainnamen.
   + *111122223333*Ersetzen Sie es durch die AWS Konto-ID des Inhabers der Domain. Wenn Sie auf ein Repository in einer Domain zugreifen, die Sie besitzen, müssen Sie nichts angeben`--domain-owner`. Weitere Informationen finden Sie unter [Kontenübergreifende Domänen](domain-overview.md#domain-overview-cross-account).

------
#### [ macOS and Linux ]

   ```
   export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text`
   ```

------
#### [ Windows ]
   + Windows (unter Verwendung der Standard-Befehlsshell):

     ```
     for /f %i in ('aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text') do set CODEARTIFACT_AUTH_TOKEN=%i
     ```
   + Windows PowerShell:

     ```
     $env:CODEARTIFACT_AUTH_TOKEN = aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text
     ```

------

1. Rufen Sie den Endpunkt Ihres CodeArtifact Repositorys ab, indem Sie den folgenden Befehl ausführen. Ihr Repository-Endpunkt wird verwendet, um den Swift Package Manager auf Ihr Repository zu verweisen, um Pakete zu konsumieren oder zu veröffentlichen.
   + Ersetze es *my\$1domain* durch deinen CodeArtifact Domainnamen.
   + *111122223333*Ersetzen Sie es durch die AWS Konto-ID des Inhabers der Domain. Wenn Sie auf ein Repository in einer Domain zugreifen, die Sie besitzen, müssen Sie nichts angeben`--domain-owner`. Weitere Informationen finden Sie unter [Kontenübergreifende Domänen](domain-overview.md#domain-overview-cross-account).
   + Ersetze es *my\$1repo* durch deinen CodeArtifact Repository-Namen.

------
#### [ macOS and Linux ]

   ```
   export CODEARTIFACT_REPO=`aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format swift --query repositoryEndpoint --output text`
   ```

------
#### [ Windows ]
   + Windows (unter Verwendung der Standard-Befehlsshell):

     ```
     for /f %i in ('aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format swift --query repositoryEndpoint --output text') do set CODEARTIFACT_REPO=%i
     ```
   + Windows PowerShell:

     ```
     $env:CODEARTIFACT_REPO = aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format swift --query repositoryEndpoint --output text
     ```

------

   Die folgende URL ist ein Beispiel für einen Repository-Endpunkt.

   ```
   https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/swift/my_repo/
   ```
**Anmerkung**  
Um einen Dual-Stack-Endpunkt zu verwenden, verwenden Sie den `codeartifact.region.on.aws` Endpunkt.
**Wichtig**  
Sie müssen `login` an das Ende des Repository-URL-Endpunkts anhängen, wenn Sie ihn zur Konfiguration des Swift Package Managers verwenden. Dies wird in den Befehlen dieses Verfahrens für Sie erledigt.

1. Wenn diese beiden Werte in Umgebungsvariablen gespeichert sind, übergeben Sie sie mit dem folgenden `swift package-registry login` Befehl an Swift:

------
#### [ macOS and Linux ]

   ```
   swift package-registry login ${CODEARTIFACT_REPO}login --token ${CODEARTIFACT_AUTH_TOKEN}
   ```

------
#### [ Windows ]
   + Windows (unter Verwendung der Standard-Befehlsshell):

     ```
     swift package-registry login %CODEARTIFACT_REPO%login --token %CODEARTIFACT_AUTH_TOKEN%
     ```
   + Windows PowerShell:

     ```
     swift package-registry login $Env:CODEARTIFACT_REPO+"login" --token $Env:CODEARTIFACT_AUTH_TOKEN
     ```

------

1. Aktualisieren Sie als Nächstes die von Ihrer Anwendung verwendete Paketregistrierung, sodass alle Abhängigkeiten aus Ihrem CodeArtifact Repository abgerufen werden. Dieser Befehl muss in dem Projektverzeichnis ausgeführt werden, in dem Sie versuchen, die Paketabhängigkeit aufzulösen:

------
#### [ macOS and Linux ]

   ```
   $ swift package-registry set ${CODEARTIFACT_REPO} [--scope my_scope]
   ```

------
#### [ Windows ]
   + Windows (unter Verwendung der Standard-Befehlsshell):

     ```
     $ swift package-registry set %CODEARTIFACT_REPO% [--scope my_scope]
     ```
   + Windows PowerShell:

     ```
     $ swift package-registry set $Env:CODEARTIFACT_REPO [--scope my_scope]
     ```

------

   Die `--scope` Option konfiguriert die Anwendung so, dass sie nur Pakete aus Ihrem CodeArtifact Repository verwendet, wenn sie sich im angegebenen Bereich befinden. Bereiche sind gleichbedeutend mit [CodeArtifact Namespaces](codeartifact-concepts.md#welcome-concepts-package-namespace) und werden verwendet, um Code in logische Gruppen zu organisieren und Namenskollisionen zu verhindern, die auftreten können, wenn Ihre Codebasis mehrere Bibliotheken umfasst.

1. Sie können überprüfen, ob die Konfiguration korrekt eingerichtet wurde, indem Sie den Inhalt der `.swiftpm/configuration/registries.json` Datei auf Projektebene anzeigen, indem Sie den folgenden Befehl in Ihrem Projektverzeichnis ausführen:

   ```
   $ cat .swiftpm/configuration/registries.json
   {
     "authentication" : {
   
     },
     "registries" : {
       "[default]" : {
         "url" : "https://my-domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/swift/my-repo/"
       }
     },
     "version" : 1
   }
   ```

Nachdem Sie den Swift Package Manager mit Ihrem CodeArtifact Repository konfiguriert haben, können Sie ihn verwenden, um Swift-Pakete zu veröffentlichen und zu verwenden. Weitere Informationen finden Sie unter [Swift-Pakete konsumieren und veröffentlichen](swift-publish-consume.md).

# Swift-Pakete konsumieren und veröffentlichen
<a name="swift-publish-consume"></a>

## Swift-Pakete werden konsumiert von CodeArtifact
<a name="consume-swift-packages"></a>

Gehen Sie wie folgt vor, um Swift-Pakete aus einem AWS CodeArtifact Repository zu konsumieren.

**Um Swift-Pakete aus einem CodeArtifact Repository zu konsumieren**

1. Falls nicht, folgen Sie den Schritten unter So konfigurieren Sie den Swift Package Manager so, dass er Ihr CodeArtifact Repository mit den richtigen Anmeldeinformationen verwendet. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)
**Anmerkung**  
Das generierte Autorisierungstoken ist 12 Stunden gültig. Sie müssen ein neues erstellen, wenn seit der Erstellung eines Tokens 12 Stunden vergangen sind.

1. Bearbeiten Sie die `Package.swift` Datei in Ihrem Anwendungsprojektordner, um die Paketabhängigkeiten zu aktualisieren, die von Ihrem Projekt verwendet werden sollen.

   1. Wenn die `Package.swift` Datei keinen `dependencies` Abschnitt enthält, fügen Sie einen hinzu.

   1. Fügen Sie im `dependencies` Abschnitt der `Package.swift` Datei das Paket hinzu, das Sie verwenden möchten, indem Sie dessen Paket-ID hinzufügen. Die Paketkennung besteht aus dem Bereich und dem Paketnamen, die durch einen Punkt getrennt sind. Ein Beispiel finden Sie im Codeausschnitt, der einem späteren Schritt folgt.
**Tipp**  
Um die Paket-ID zu finden, können Sie die CodeArtifact Konsole verwenden. Suchen Sie die spezifische Paketversion, die Sie verwenden möchten, und lesen Sie auf der Seite mit der Paketversion nach den Anweisungen für die **Kurzanleitung zur Installation**.

   1. Wenn die `Package.swift` Datei keinen `targets` Abschnitt enthält, fügen Sie einen hinzu.

   1. Fügen Sie im `targets` Abschnitt die Ziele hinzu, die die Abhängigkeit verwenden müssen.

      Der folgende Ausschnitt ist ein Beispielausschnitt, der konfigurierte `targets` Abschnitte `dependencies` und Abschnitte in einer Datei zeigt: `Package.swift`

      ```
      ...
          ],
          dependencies: [
              .package(id: "my_scope.package_name", from: "1.0.0")
          ],
          targets: [
            .target(
               name: "MyApp",
               dependencies: ["package_name"]
            ),...
          ],
      ...
      ```

1. Nachdem alles konfiguriert ist, verwenden Sie den folgenden Befehl, um die Paketabhängigkeiten von herunterzuladen. CodeArtifact

   ```
   swift package resolve
   ```

## Swift-Pakete CodeArtifact in Xcode konsumieren
<a name="consume-swift-packages-xcode"></a>

Gehen Sie wie folgt vor, um Swift-Pakete aus einem CodeArtifact Repository in Xcode zu konsumieren.

**Um Swift-Pakete aus einem CodeArtifact Repository in Xcode zu konsumieren**

1. Falls nicht, folgen Sie den Schritten unter So konfigurieren Sie den Swift Package Manager so, dass er Ihr CodeArtifact Repository mit den richtigen Anmeldeinformationen verwendet. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)
**Anmerkung**  
Das generierte Autorisierungstoken ist 12 Stunden gültig. Sie müssen ein neues erstellen, wenn seit der Erstellung eines Tokens 12 Stunden vergangen sind.

1. Fügen Sie die Pakete als Abhängigkeit zu Ihrem Projekt in Xcode hinzu.

   1. Wählen Sie „**Datei“ > „Pakete hinzufügen**“.

   1. Suchen Sie mithilfe der Suchleiste nach Ihrem Paket. Ihre Suche muss im Formular erfolgen`package_scope.package_name`.

   1. Sobald Sie es gefunden haben, wählen Sie das Package aus und wählen **Sie Paket hinzufügen**.

   1. Sobald das Package verifiziert ist, wählen Sie die Paketprodukte aus, die Sie als Abhängigkeit hinzufügen möchten, und wählen Sie **Paket hinzufügen**.

Wenn Sie Probleme bei der Verwendung Ihres CodeArtifact Repositorys mit Xcode haben, finden Sie Informationen [Schnelle Problembehebung](swift-troubleshooting.md) zu häufig auftretenden Problemen und möglichen Lösungen.

## Swift-Pakete veröffentlichen auf CodeArtifact
<a name="publish-swift-packages"></a>

CodeArtifact empfiehlt Swift 5.9 oder höher und die Verwendung des `swift package-registry publish` Befehls zur Veröffentlichung von Swift-Paketen. Wenn Sie eine frühere Version verwenden, müssen Sie einen Curl-Befehl verwenden, um Swift-Pakete zu veröffentlichen. CodeArtifact

### Veröffentlichen von CodeArtifact Paketen mit dem Befehl `swift package-registry publish`
<a name="publish-swift-packages-publish-command"></a>

Verwenden Sie das folgende Verfahren mit Swift 5.9 oder höher, um Swift-Pakete mit dem Swift Package Manager in einem CodeArtifact Repository zu veröffentlichen.

1. Falls nicht, folgen Sie den Schritten unter So konfigurieren Sie den Swift Package Manager so, dass er Ihr CodeArtifact Repository mit den richtigen Anmeldeinformationen verwendet. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)
**Anmerkung**  
Das generierte Autorisierungstoken ist 12 Stunden gültig. Sie müssen ein neues erstellen, wenn seit der Erstellung 12 Stunden vergangen sind.

1. Navigieren Sie zum Swift-Projektverzeichnis, das die `Package.swift` Datei für Ihr Paket enthält.

1. Führen Sie den folgenden `swift package-registry publish` Befehl aus, um das Paket zu veröffentlichen. Der Befehl erstellt ein Paketquellarchiv und veröffentlicht es in Ihrem CodeArtifact Repository.

   ```
   swift package-registry publish packageScope.packageName packageVersion
   ```

   Beispiel:

   ```
   swift package-registry publish myScope.myPackage 1.0.0
   ```

1. Sie können überprüfen, ob das Paket veröffentlicht wurde und im Repository vorhanden ist, indem Sie in der Konsole nachschauen oder den `aws codeartifact list-packages` Befehl wie folgt verwenden:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   Sie können die einzelne Version des Pakets mit dem folgenden `aws codeartifact list-package-versions` Befehl auflisten:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```

### CodeArtifact Pakete mit Curl veröffentlichen
<a name="publish-swift-packages-curl"></a>

Es wird zwar empfohlen, den `swift package-registry publish` Befehl zu verwenden, der in Swift 5.9 oder höher enthalten ist, aber Sie können Curl auch verwenden, um Swift-Pakete zu veröffentlichen. CodeArtifact

Gehen Sie wie folgt vor, um Swift-Pakete mit Curl in einem AWS CodeArtifact Repository zu veröffentlichen.

1. Falls nicht, erstellen und aktualisieren Sie die `CODEARTIFACT_REPO` Umgebungsvariablen `CODEARTIFACT_AUTH_TOKEN` und, indem Sie die Schritte unter befolgen. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)
**Anmerkung**  
Das Autorisierungs-Token ist 12 Stunden gültig. Sie müssen Ihre `CODEARTIFACT_AUTH_TOKEN` Umgebungsvariable mit neuen Anmeldeinformationen aktualisieren, wenn seit ihrer Erstellung 12 Stunden vergangen sind.

1. Wenn Sie kein Swift-Paket erstellt haben, können Sie dies zunächst tun, indem Sie die folgenden Befehle ausführen:

   ```
   mkdir testDir && cd testDir
   swift package init
   git init .
   swift package archive-source
   ```

1. Verwenden Sie den folgenden Curl-Befehl, um Ihr Swift-Paket zu CodeArtifact veröffentlichen in:

------
#### [ macOS and Linux ]

   ```
   curl -X PUT  --user "aws:$CODEARTIFACT_AUTH_TOKEN" \
   -H "Accept: application/vnd.swift.registry.v1+json" \
   -F source-archive="@test_dir_package_name.zip" \
   "${CODEARTIFACT_REPO}my_scope/package_name/packageVersion"
   ```

------
#### [ Windows ]

   ```
   curl -X PUT  --user "aws:%CODEARTIFACT_AUTH_TOKEN%" \
   -H "Accept: application/vnd.swift.registry.v1+json" \
   -F source-archive="@test_dir_package_name.zip" \
   "%CODEARTIFACT_REPO%my_scope/package_name/packageVersion"
   ```

------

1. Sie können überprüfen, ob das Paket veröffentlicht wurde und im Repository vorhanden ist, indem Sie in der Konsole nachschauen oder den `aws codeartifact list-packages` Befehl wie folgt verwenden:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   Sie können die einzelne Version des Pakets mit dem folgenden `aws codeartifact list-package-versions` Befehl auflisten:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```

## Swift-Pakete abrufen von GitHub und erneutes Veröffentlichen von CodeArtifact
<a name="publish-swift-packages-from-github"></a>

Gehen Sie wie folgt vor, um ein Swift-Paket aus einem Repository abzurufen GitHub und es erneut in einem Repository zu veröffentlichen. CodeArtifact 

**Um ein Swift-Paket abzurufen GitHub und es erneut zu veröffentlichen CodeArtifact**

1. Falls nicht, folgen Sie den Schritten unter So konfigurieren Sie den Swift Package Manager so, dass er Ihr CodeArtifact Repository mit den richtigen Anmeldeinformationen verwendet. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)
**Anmerkung**  
Das generierte Autorisierungstoken ist 12 Stunden gültig. Sie müssen ein neues erstellen, wenn seit der Erstellung eines Tokens 12 Stunden vergangen sind.

1. Klonen Sie das Git-Repository des Swift-Pakets, das Sie abrufen und erneut veröffentlichen möchten, indem Sie den folgenden `git clone` Befehl verwenden. Informationen zum Klonen von GitHub Repositorys finden Sie in der Dokumentation unter [Ein Repository klonen](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository). GitHub 

   ```
   git clone repoURL
   ```

1. Navigieren Sie zu dem Repository, das Sie gerade geklont haben:

   ```
   cd repoName
   ```

1. Erstellen Sie das Paket und veröffentlichen Sie es in CodeArtifact.

   1. **Empfehlung:** Wenn Sie Swift 5.9 oder höher verwenden, können Sie den folgenden `swift package-registry publish` Befehl verwenden, um das Paket zu erstellen und es in Ihrem konfigurierten CodeArtifact Repository zu veröffentlichen.

      ```
      swift package-registry publish packageScope.packageName versionNumber
      ```

      Beispiel:

      ```
      swift package-registry publish myScope.myPackage 1.0.0
      ```

   1. Wenn Sie eine Swift-Version verwenden, die älter als 5.9 ist, müssen Sie den `swift archive-source` Befehl verwenden, um das Paket zu erstellen, und dann einen Curl-Befehl verwenden, um es zu veröffentlichen.

      1. Wenn Sie die Variablen `CODEARTIFACT_AUTH_TOKEN` und die `CODEARTIFACT_REPO` Umgebungsvariablen noch nicht konfiguriert haben oder es mehr als 12 Stunden her ist, dass Sie das getan haben, folgen Sie den Schritten unter. [Konfigurieren Sie Swift ohne den Login-Befehl](configure-swift.md#configure-swift-without-login-command)

      1. Erstellen Sie das Swift-Paket mit dem `swift package archive-source` folgenden Befehl:

         ```
         swift package archive-source
         ```

         Wenn dies erfolgreich ist, werden Sie es `Created package_name.zip` in der Befehlszeile sehen.

      1. Verwenden Sie den folgenden Curl-Befehl, um das Swift-Paket zu CodeArtifact veröffentlichen in:

------
#### [ macOS and Linux ]

         ```
         curl -X PUT  --user "aws:$CODEARTIFACT_AUTH_TOKEN" \
         -H "Accept: application/vnd.swift.registry.v1+json" \
         -F source-archive="@package_name.zip" \
         "${CODEARTIFACT_REPO}my_scope/package_name/packageVersion"
         ```

------
#### [ Windows ]

         ```
         curl -X PUT  --user "aws:%CODEARTIFACT_AUTH_TOKEN%" \
         -H "Accept: application/vnd.swift.registry.v1+json" \
         -F source-archive="@package_name.zip" \
         "%CODEARTIFACT_REPO%my_scope/package_name/packageVersion"
         ```

------

1. Sie können überprüfen, ob das Paket veröffentlicht wurde und im Repository vorhanden ist, indem Sie in der Konsole nachschauen oder den `aws codeartifact list-packages` Befehl wie folgt verwenden:

   ```
   aws codeartifact list-packages --domain my_domain --repository my_repo
   ```

   Sie können die einzelne Version des Pakets mit dem folgenden `aws codeartifact list-package-versions` Befehl auflisten:

   ```
   aws codeartifact list-package-versions --domain my_domain --repository my_repo \
   --format swift --namespace my_scope --package package_name
   ```

# Schnelle Normalisierung von Paketnamen und Namespace
<a name="swift-name-normalization"></a>

CodeArtifact normalisiert Paketnamen und Namespaces, bevor sie gespeichert werden, was bedeutet, dass sich die Namen darin von denen unterscheiden CodeArtifact können, die bei der Veröffentlichung des Pakets angegeben wurden.

**Normalisierung von Paketnamen und Namespaces: CodeArtifact normalisiert** Swift-Paketnamen und Namespaces, indem alle Buchstaben in Kleinbuchstaben umgewandelt werden.

Normalisierung der **Paketversion: CodeArtifact Normalisiert** keine Swift-Paketversionen. [Beachten Sie, dass CodeArtifact nur Semantic Versioning 2.0-Versionsmuster unterstützt werden. Weitere Informationen zur Semantic Versioning finden Sie unter Semantic Versioning 2.0.0.](https://semver.org/spec/v2.0.0.html)

Der nicht normalisierte Paketname und der Namespace können mit API- und CLI-Anfragen verwendet werden, da CodeArtifact die Eingaben für diese Anfragen normalisiert werden. Zum Beispiel `--namespace myScope` würden Eingaben von `--package myPackage` und normalisiert werden und ein Paket zurückgeben, das den normalisierten Paketnamen und den Namespace von hat. `mypackage` `myscope`

**Sie müssen normalisierte Namen in verwenden ARNs, z. B. in IAM-Richtlinien.**

Verwenden Sie den Befehl, um den normalisierten Namen eines Pakets zu ermitteln. `aws codeartifact list-packages` Weitere Informationen finden Sie unter [Listet die Paketnamen auf](list-packages.md).

# Schnelle Problembehebung
<a name="swift-troubleshooting"></a>

Die folgenden Informationen können Ihnen bei der Behebung häufiger Probleme mit Swift und helfen CodeArtifact.

## Ich erhalte einen 401-Fehler in Xcode, auch nachdem ich den Swift Package Manager konfiguriert habe
<a name="swift-troubleshooting-xcode"></a>

**Problem:** Wenn Sie versuchen, ein Paket aus Ihrem CodeArtifact Repository als Abhängigkeit zu Ihrem Swift-Projekt in Xcode hinzuzufügen, erhalten Sie einen unautorisierten 401-Fehler, auch wenn Sie die Anweisungen zum [Herstellen einer Verbindung mit Swift](configure-swift.md) befolgt haben. CodeArtifact

**Mögliche Lösungen:** Dies kann durch ein Problem mit der macOS Keychain-App verursacht werden, in der Ihre CodeArtifact Anmeldeinformationen gespeichert sind. Um dies zu beheben, empfehlen wir, die Keychain-App zu öffnen und alle CodeArtifact Einträge zu löschen und den Swift Package Manager erneut mit Ihrem CodeArtifact Repository zu konfigurieren, indem Sie den Anweisungen unter folgen. [Konfigurieren Sie den Swift Package Manager mit CodeArtifact](configure-swift.md)

## Xcode hängt auf dem CI-Computer, da der Schlüsselbund zur Eingabe des Passworts aufgefordert wird
<a name="swift-troubleshooting-ci-machine"></a>

**Problem:** Wenn Sie versuchen, Swift-Pakete CodeArtifact als Teil eines Xcode-Builds auf einem Continuous Integration (CI) -Server abzurufen, z. B. mit GitHub Aktionen, CodeArtifact kann die Authentifizierung mit hängen bleiben und schließlich mit einer Fehlermeldung ähnlich der folgenden fehlschlagen:

`Failed to save credentials for \'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com\' to keychain: status -60008`

**Mögliche Lösungen:** Dies wird dadurch verursacht, dass Anmeldeinformationen auf CI-Computern nicht im Schlüsselbund gespeichert werden und Xcode nur Anmeldeinformationen unterstützt, die im Schlüsselbund gespeichert sind. Um dieses Problem zu beheben, empfehlen wir, den Schlüsselbundeintrag mithilfe der folgenden Schritte manuell zu erstellen:

1. Bereite den Schlüsselbund vor.

   ```
   KEYCHAIN_PASSWORD=$(openssl rand -base64 20)
   KEYCHAIN_NAME=login.keychain
   SYSTEM_KEYCHAIN=/Library/Keychains/System.keychain
   
   if [ -f $HOME/Library/Keychains/"${KEYCHAIN_NAME}"-db ]; then
       echo "Deleting old ${KEYCHAIN_NAME} keychain"
       security delete-keychain "${KEYCHAIN_NAME}"
   fi
   echo "Create Keychain"
   security create-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_NAME}"
   
   EXISTING_KEYCHAINS=( $( security list-keychains | sed -e 's/ *//' | tr '\n' ' ' | tr -d '"') )
   sudo security list-keychains -s "${KEYCHAIN_NAME}" "${EXISTING_KEYCHAINS[@]}"
   
   echo "New keychain search list :"
   security list-keychain 
   
   echo "Configure keychain : remove lock timeout"
   security unlock-keychain -p "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_NAME}"
   security set-keychain-settings "${KEYCHAIN_NAME}"
   ```

1. Besorgen Sie sich ein CodeArtifact Authentifizierungstoken und Ihren Repository-Endpunkt.

   ```
   export CODEARTIFACT_AUTH_TOKEN=`aws codeartifact get-authorization-token \
                                       --region us-west-2 \
                                       --domain my_domain   \
                                       --domain-owner 111122223333   \
                                       --query authorizationToken  \
                                       --output text`
                                        
   export CODEARTIFACT_REPO=`aws codeartifact get-repository-endpoint  \
                                 --region us-west-2   \
                                 --domain my_domain   \
                                 --domain-owner 111122223333   \
                                 --format swift     \
                                 --repository my_repo    \
                                 --query repositoryEndpoint   \
                                 --output text`
   ```

1. Erstellen Sie den Schlüsselbundeintrag manuell.

   ```
   SERVER=$(echo $CODEARTIFACT_REPO | sed  's/https:\/\///g' | sed 's/.com.*$/.com/g')
   AUTHORIZATION=(-T /usr/bin/security -T /usr/bin/codesign -T /usr/bin/xcodebuild -T /usr/bin/swift \
                  -T /Applications/Xcode-15.2.app/Contents/Developer/usr/bin/xcodebuild)
   
   security delete-internet-password -a token -s $SERVER -r htps "${KEYCHAIN_NAME}"
   
   security add-internet-password -a token \
                                  -s $SERVER \
                                  -w $CODEARTIFACT_AUTH_TOKEN \
                                  -r htps \
                                  -U \
                                  "${AUTHORIZATION[@]}" \
                                  "${KEYCHAIN_NAME}"
   
   security set-internet-password-partition-list \
                -a token \
                -s $SERVER \
                -S "com.apple.swift-package,com.apple.security,com.apple.dt.Xcode,apple-tool:,apple:,codesign" \
                -k "${KEYCHAIN_PASSWORD}" "${KEYCHAIN_NAME}"
   
   security find-internet-password   "${KEYCHAIN_NAME}"
   ```

Weitere Informationen zu diesem Fehler und der Lösung finden Sie unter [https://github.com/apple/swift-package-manager/issues/7236](https://github.com/apple/swift-package-manager/issues/7236).