Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation CodeArtifact avec Swift
Ces rubriques décrivent comment utiliser le gestionnaire de packages Swift CodeArtifact pour installer et publier des packages Swift.
**Note**
CodeArtifact supporte Swift 5.8 et versions ultérieures et Xcode 14.3 et versions ultérieures.
CodeArtifact recommande Swift 5.9 et versions ultérieures et Xcode 15 et versions ultérieures.
**Topics**
+ [Configurez Swift avec CodeArtifact](configure-swift.md)
+ [Consommation et publication de packages Swift](swift-publish-consume.md)
+ [Normalisation rapide du nom du package et de l'espace de noms](swift-name-normalization.md)
+ [Résolution rapide des problèmes](swift-troubleshooting.md)
# Configurez le gestionnaire de packages Swift avec CodeArtifact
Pour utiliser le Swift Package Manager afin de publier des packages vers ou de consommer des packages à partir de ceux-ci AWS CodeArtifact, vous devez d'abord configurer des informations d'identification pour accéder à votre CodeArtifact référentiel. La méthode recommandée pour configurer la CLI de Swift Package Manager avec vos CodeArtifact informations d'identification et le point de terminaison du référentiel consiste à utiliser la `aws codeartifact login` commande. Vous pouvez également configurer le Swift Package Manager manuellement.
## Configurer Swift avec la commande de connexion
Utilisez la `aws codeartifact login` commande pour configurer le Swift Package Manager avec CodeArtifact.
**Note**
Pour utiliser la commande de connexion, Swift 5.8 ou version ultérieure est requis et Swift 5.9 ou version ultérieure est recommandé.
La `aws codeartifact login` commande effectuera les opérations suivantes :
1. Récupérez un jeton d'authentification CodeArtifact et stockez-le dans votre environnement. La manière dont les informations d'identification sont stockées dépend du système d'exploitation de l'environnement :
1. **macOS :** une entrée est créée dans l'application macOS Keychain.
1. **Linux et Windows :** une entrée est créée dans le `~/.netrc` fichier.
Dans tous les systèmes d'exploitation, s'il existe une entrée d'informations d'identification, cette commande remplace cette entrée par un nouveau jeton.
1. Récupérez l'URL du point de terminaison de votre CodeArtifact dépôt et ajoutez-la à votre fichier de configuration Swift. La commande ajoute l'URL du point de terminaison du référentiel au fichier de configuration au niveau du projet situé à l'adresse`/path/to/project/.swiftpm/configuration/registries.json`.
**Note**
La `aws codeartifact login` commande appelle `swift package-registry` des commandes qui doivent être exécutées à partir du répertoire contenant le `Package.swift` fichier. Pour cette raison, `aws codeartifact login` la commande doit être exécutée depuis le projet Swift.
**Pour configurer Swift à l'aide de la commande de connexion**
1. Accédez au répertoire du projet Swift qui contient le `Package.swift` fichier de votre projet.
1. Exécutez la commande suivante `aws codeartifact login`.
Si vous accédez à un référentiel dans un domaine qui vous appartient, vous n'avez pas besoin de l'inclure`--domain-owner`. Pour de plus amples informations, veuillez consulter [Domaines multi-comptes](domain-overview.md#domain-overview-cross-account).
```
aws codeartifact login --tool swift --domain my_domain \
--domain-owner 111122223333 --repository my_repo \
[--namespace my_namespace]
```
L'`--namespace`option configure l'application pour qu'elle ne consomme les packages de votre CodeArtifact dépôt que s'ils se trouvent dans l'espace de noms désigné. CodeArtifact les [espaces de noms](codeartifact-concepts.md#welcome-concepts-package-namespace) sont synonymes de portées et sont utilisés pour organiser le code en groupes logiques et pour éviter les collisions de noms qui peuvent se produire lorsque votre base de code inclut plusieurs bibliothèques.
La période d'autorisation par défaut après l'appel `login` est de 12 heures et `login` doit être appelée pour actualiser régulièrement le jeton. Pour plus d'informations sur le jeton d'autorisation créé avec la `login` commande, consultez[Jetons créés avec la `login` commande](tokens-authentication.md#auth-token-login).
## Configurer Swift sans la commande de connexion
Bien qu'il soit recommandé de [configurer Swift avec la `aws codeartifact login` commande](#configure-swift-login-command), vous pouvez également configurer le Swift Package Manager sans la commande de connexion en mettant à jour manuellement la configuration du Swift Package Manager.
Dans la procédure suivante, vous allez utiliser le AWS CLI pour effectuer les opérations suivantes :
1. Récupérez un jeton d'authentification CodeArtifact et stockez-le dans votre environnement. La manière dont les informations d'identification sont stockées dépend du système d'exploitation de l'environnement :
1. **macOS :** une entrée est créée dans l'application macOS Keychain.
1. **Linux et Windows :** une entrée est créée dans le `~/.netrc` fichier.
1. Récupérez l'URL du point de terminaison de votre CodeArtifact dépôt.
1. Dans le fichier `~/.swiftpm/configuration/registries.json` de configuration, ajoutez une entrée avec l'URL du point de terminaison de votre référentiel et le type d'authentification.
**Pour configurer le Swift sans la commande de connexion**
1. Dans une ligne de commande, utilisez la commande suivante pour récupérer un jeton CodeArtifact d'autorisation et le stocker dans une variable d'environnement.
+ *my\$1domain*Remplacez-le par votre nom de CodeArtifact domaine.
+ Remplacez *111122223333* par le numéro de AWS compte du propriétaire du domaine. Si vous accédez à un référentiel dans un domaine qui vous appartient, vous n'avez pas besoin de l'inclure`--domain-owner`. Pour de plus amples informations, veuillez consulter [Domaines multi-comptes](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 (en utilisant l'interface de commande par défaut) :
```
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
```
+ Fenêtres PowerShell :
```
$env:CODEARTIFACT_AUTH_TOKEN = aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text
```
------
1. Obtenez le point de terminaison de votre CodeArtifact dépôt en exécutant la commande suivante. Le point de terminaison de votre dépôt est utilisé pour faire pointer le Swift Package Manager vers votre dépôt afin de consommer ou de publier des packages.
+ *my\$1domain*Remplacez-le par votre nom de CodeArtifact domaine.
+ Remplacez *111122223333* par le numéro de AWS compte du propriétaire du domaine. Si vous accédez à un référentiel dans un domaine qui vous appartient, vous n'avez pas besoin de l'inclure`--domain-owner`. Pour de plus amples informations, veuillez consulter [Domaines multi-comptes](domain-overview.md#domain-overview-cross-account).
+ *my\$1repo*Remplacez-le par le nom de votre CodeArtifact dépôt.
------
#### [ 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 (en utilisant l'interface de commande par défaut) :
```
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
```
+ Fenêtres PowerShell :
```
$env:CODEARTIFACT_REPO = aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format swift --query repositoryEndpoint --output text
```
------
L'URL suivante est un exemple de point de terminaison du référentiel.
```
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/swift/my_repo/
```
**Note**
Pour utiliser un point de terminaison à double pile, utilisez le `codeartifact.region.on.aws` point de terminaison.
**Important**
Vous devez l'ajouter à la `login` fin du point de terminaison de l'URL du référentiel lorsque vous l'utilisez pour configurer le Swift Package Manager. Cela est fait pour vous dans les commandes de cette procédure.
1. Ces deux valeurs étant stockées dans des variables d'environnement, transmettez-les à Swift à l'aide de la `swift package-registry login` commande suivante :
------
#### [ macOS and Linux ]
```
swift package-registry login ${CODEARTIFACT_REPO}login --token ${CODEARTIFACT_AUTH_TOKEN}
```
------
#### [ Windows ]
+ Windows (en utilisant l'interface de commande par défaut) :
```
swift package-registry login %CODEARTIFACT_REPO%login --token %CODEARTIFACT_AUTH_TOKEN%
```
+ Fenêtres PowerShell :
```
swift package-registry login $Env:CODEARTIFACT_REPO+"login" --token $Env:CODEARTIFACT_AUTH_TOKEN
```
------
1. Ensuite, mettez à jour le registre des packages utilisé par votre application afin que toute dépendance soit extraite de votre CodeArtifact référentiel. Cette commande doit être exécutée dans le répertoire du projet où vous essayez de résoudre la dépendance du package :
------
#### [ macOS and Linux ]
```
$ swift package-registry set ${CODEARTIFACT_REPO} [--scope my_scope]
```
------
#### [ Windows ]
+ Windows (en utilisant l'interface de commande par défaut) :
```
$ swift package-registry set %CODEARTIFACT_REPO% [--scope my_scope]
```
+ Fenêtres PowerShell :
```
$ swift package-registry set $Env:CODEARTIFACT_REPO [--scope my_scope]
```
------
L'`--scope`option configure l'application pour qu'elle ne consomme les packages de votre CodeArtifact référentiel que s'ils se situent dans la zone d'application désignée. Les étendues sont synonymes d'[CodeArtifact espaces de noms](codeartifact-concepts.md#welcome-concepts-package-namespace) et sont utilisées pour organiser le code en groupes logiques et pour éviter les collisions de noms qui peuvent se produire lorsque votre base de code inclut plusieurs bibliothèques.
1. Vous pouvez vérifier que la configuration a été correctement configurée en consultant le contenu du `.swiftpm/configuration/registries.json` fichier au niveau du projet en exécutant la commande suivante dans le répertoire de votre projet :
```
$ 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
}
```
Maintenant que vous avez configuré le gestionnaire de packages Swift avec votre CodeArtifact dépôt, vous pouvez l'utiliser pour publier et utiliser des packages Swift depuis et vers celui-ci. Pour de plus amples informations, veuillez consulter [Consommation et publication de packages Swift](swift-publish-consume.md).
# Consommation et publication de packages Swift
## Consommer des packages Swift à partir de CodeArtifact
Utilisez la procédure suivante pour utiliser des packages Swift à partir d'un AWS CodeArtifact dépôt.
**Pour utiliser des packages Swift à partir d'un CodeArtifact dépôt**
1. Si ce n'est pas le cas, suivez les étapes ci-dessous [Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md) pour configurer le Swift Package Manager afin d'utiliser votre CodeArtifact référentiel avec les informations d'identification appropriées.
**Note**
Le jeton d'autorisation généré est valide pendant 12 heures. Vous devrez en créer un nouveau si 12 heures se sont écoulées depuis la création du jeton.
1. Modifiez le `Package.swift` fichier dans le dossier du projet de votre application pour mettre à jour les dépendances des packages à utiliser par votre projet.
1. Si le `Package.swift` fichier ne contient pas de `dependencies` section, ajoutez-en une.
1. Dans la `dependencies` section du `Package.swift` fichier, ajoutez le package que vous souhaitez utiliser en ajoutant son identifiant de package. L'identifiant du package se compose de la portée et du nom du package séparés par un point. Consultez l'extrait de code suivant une étape ultérieure pour un exemple.
**Astuce**
Pour trouver l'identifiant du package, vous pouvez utiliser la CodeArtifact console. Recherchez la version du package que vous souhaitez utiliser et consultez les instructions du **raccourci d'installation** sur la page de version du package.
1. Si le `Package.swift` fichier ne contient pas de `targets` section, ajoutez-en une.
1. Dans la `targets` section, ajoutez les cibles qui devront utiliser la dépendance.
L'extrait suivant est un exemple d'extrait illustrant les sections configurées `dependencies` et les `targets` sections d'un fichier : `Package.swift`
```
...
],
dependencies: [
.package(id: "my_scope.package_name", from: "1.0.0")
],
targets: [
.target(
name: "MyApp",
dependencies: ["package_name"]
),...
],
...
```
1. Maintenant que tout est configuré, utilisez la commande suivante pour télécharger les dépendances du package depuis CodeArtifact.
```
swift package resolve
```
## Consommation de packages Swift depuis CodeArtifact Xcode
Utilisez la procédure suivante pour utiliser des packages Swift à partir d'un CodeArtifact dépôt dans Xcode.
**Pour consommer des packages Swift à partir d'un CodeArtifact dépôt dans Xcode**
1. Si ce n'est pas le cas, suivez les étapes ci-dessous [Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md) pour configurer le Swift Package Manager afin d'utiliser votre CodeArtifact référentiel avec les informations d'identification appropriées.
**Note**
Le jeton d'autorisation généré est valide pendant 12 heures. Vous devrez en créer un nouveau si 12 heures se sont écoulées depuis la création du jeton.
1. Ajoutez les packages en tant que dépendance dans votre projet dans Xcode.
1. Choisissez **Fichier > Ajouter des packages**.
1. Recherchez votre package à l'aide de la barre de recherche. Votre recherche doit figurer dans le formulaire`package_scope.package_name`.
1. Une fois trouvé, choisissez le package et choisissez **Ajouter un package**.
1. Une fois le package vérifié, choisissez les produits du package que vous souhaitez ajouter en tant que dépendance, puis choisissez **Ajouter un package**.
Si vous rencontrez des problèmes lors de l'utilisation de votre CodeArtifact dépôt avec Xcode, consultez [Résolution rapide des problèmes](swift-troubleshooting.md) les problèmes courants et les solutions possibles.
## Publication de packages Swift sur CodeArtifact
CodeArtifact recommande Swift 5.9 ou version ultérieure et utilise la `swift package-registry publish` commande pour publier des packages Swift. Si vous utilisez une version antérieure, vous devez utiliser une commande Curl pour publier les packages Swift dans. CodeArtifact
### Publier CodeArtifact des packages à l'aide de la `swift package-registry publish` commande
Utilisez la procédure suivante avec Swift 5.9 ou version ultérieure pour publier des packages Swift dans un CodeArtifact référentiel à l'aide du Swift Package Manager.
1. Si ce n'est pas le cas, suivez les étapes ci-dessous [Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md) pour configurer le Swift Package Manager afin d'utiliser votre CodeArtifact référentiel avec les informations d'identification appropriées.
**Note**
Le jeton d'autorisation généré est valide pendant 12 heures. Vous devrez en créer un nouveau si 12 heures se sont écoulées depuis sa création.
1. Accédez au répertoire du projet Swift qui contient le `Package.swift` fichier de votre package.
1. Exécutez la `swift package-registry publish` commande suivante pour publier le package. La commande crée une archive source de package et la publie dans votre CodeArtifact dépôt.
```
swift package-registry publish packageScope.packageName packageVersion
```
Par exemple :
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. Vous pouvez vérifier que le package a été publié et qu'il existe dans le référentiel en vérifiant dans la console ou en utilisant la `aws codeartifact list-packages` commande suivante :
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Vous pouvez répertorier la version unique du package à l'aide de la `aws codeartifact list-package-versions` commande suivante :
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
### Publication de CodeArtifact packages avec Curl
Bien qu'il soit recommandé d'utiliser la `swift package-registry publish` commande fournie avec Swift 5.9 ou version ultérieure, vous pouvez également utiliser Curl pour publier des packages Swift dans. CodeArtifact
Utilisez la procédure suivante pour publier des packages Swift dans un AWS CodeArtifact dépôt avec Curl.
1. Si ce n'est pas le cas, créez et mettez à jour les variables d'`CODEARTIFACT_REPO`environnement `CODEARTIFACT_AUTH_TOKEN` et en suivant les étapes décrites dans[Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md).
**Note**
Le jeton d'autorisation est valide pendant 12 heures. Vous devrez actualiser votre variable d'`CODEARTIFACT_AUTH_TOKEN`environnement avec de nouvelles informations d'identification si 12 heures se sont écoulées depuis sa création.
1. Tout d'abord, si aucun package Swift n'a été créé, vous pouvez le faire en exécutant les commandes suivantes :
```
mkdir testDir && cd testDir
swift package init
git init .
swift package archive-source
```
1. Utilisez la commande Curl suivante pour publier votre package Swift sur : CodeArtifact
------
#### [ 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. Vous pouvez vérifier que le package a été publié et qu'il existe dans le référentiel en vérifiant dans la console ou en utilisant la `aws codeartifact list-packages` commande suivante :
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Vous pouvez répertorier la version unique du package à l'aide de la `aws codeartifact list-package-versions` commande suivante :
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
## Récupération de packages Swift depuis GitHub et republication vers CodeArtifact
Utilisez la procédure suivante pour récupérer un package Swift GitHub et le republier dans un CodeArtifact dépôt.
**Pour récupérer un package Swift GitHub et le republier dans CodeArtifact**
1. Si ce n'est pas le cas, suivez les étapes ci-dessous [Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md) pour configurer le Swift Package Manager afin d'utiliser votre CodeArtifact référentiel avec les informations d'identification appropriées.
**Note**
Le jeton d'autorisation généré est valide pendant 12 heures. Vous devrez en créer un nouveau si 12 heures se sont écoulées depuis la création du jeton.
1. Clonez le dépôt git du package Swift que vous souhaitez récupérer et republier à l'aide de la commande suivante`git clone`. Pour plus d'informations sur le clonage de GitHub référentiels, consultez la section [Clonage d'un référentiel dans la documentation](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository). GitHub
```
git clone repoURL
```
1. Accédez au référentiel que vous venez de cloner :
```
cd repoName
```
1. Créez le package et publiez-le sur CodeArtifact.
1. **Recommandé :** Si vous utilisez Swift 5.9 ou une version ultérieure, vous pouvez utiliser la `swift package-registry publish` commande suivante pour créer le package et le publier dans votre CodeArtifact référentiel configuré.
```
swift package-registry publish packageScope.packageName versionNumber
```
Par exemple :
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. Si vous utilisez une version de Swift antérieure à la version 5.9, vous devez utiliser la `swift archive-source` commande pour créer le package, puis utiliser une commande Curl pour le publier.
1. Si vous n'avez pas configuré les variables d'`CODEARTIFACT_REPO`environnement `CODEARTIFACT_AUTH_TOKEN` et, ou si cela fait plus de 12 heures que vous ne l'avez pas fait, suivez les étapes décrites dans[Configurer Swift sans la commande de connexion](configure-swift.md#configure-swift-without-login-command).
1. Créez le package Swift à l'aide de la `swift package archive-source` commande :
```
swift package archive-source
```
En cas de succès, vous le verrez `Created package_name.zip` dans la ligne de commande.
1. Utilisez la commande Curl suivante pour publier le package Swift sur : CodeArtifact
------
#### [ 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. Vous pouvez vérifier que le package a été publié et qu'il existe dans le référentiel en vérifiant dans la console ou en utilisant la `aws codeartifact list-packages` commande suivante :
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Vous pouvez répertorier la version unique du package à l'aide de la `aws codeartifact list-package-versions` commande suivante :
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
# Normalisation rapide du nom du package et de l'espace de noms
CodeArtifact normalise les noms de packages et les espaces de noms avant de les stocker, ce qui signifie que les noms CodeArtifact peuvent être différents de ceux fournis lors de la publication du package.
**Normalisation du nom du package et de l'espace de noms :** CodeArtifact normalise les noms de packages et les espaces de noms Swift en convertissant toutes les lettres en minuscules.
**Normalisation des versions des packages :** CodeArtifact ne normalise pas les versions des packages Swift. [Notez que CodeArtifact seuls les modèles de version 2.0 sont pris en charge. Pour plus d'informations sur le versionnement sémantique, consultez Semantic Versioning 2.0.0.](https://semver.org/spec/v2.0.0.html)
Le nom du package et l'espace de noms non normalisés peuvent être utilisés avec les demandes d'API et de CLI car ils CodeArtifact normalisent les entrées de ces demandes. Par exemple, les entrées de `--package myPackage` et `--namespace myScope` seraient normalisées et renverraient un package dont le nom de package `mypackage` et l'espace de noms normalisés sont de. `myscope`
**Vous devez utiliser des noms normalisés dans les ARNs politiques IAM, par exemple.**
Pour trouver le nom normalisé d'un package, utilisez la `aws codeartifact list-packages` commande. Pour de plus amples informations, veuillez consulter [Lister les noms de packages](list-packages.md).
# Résolution rapide des problèmes
Les informations suivantes peuvent vous aider à résoudre les problèmes courants liés à Swift et CodeArtifact.
## Je reçois une erreur 401 dans Xcode même après avoir configuré le Swift Package Manager
**Problème :** Lorsque vous essayez d'ajouter un package depuis votre CodeArtifact dépôt en tant que dépendance à votre projet Swift dans Xcode, vous obtenez une erreur 401 non autorisée même après avoir suivi les instructions de [connexion à CodeArtifact Swift](configure-swift.md).
**Correctifs possibles :** Cela peut être dû à un problème lié à l'application macOS Keychain, dans laquelle vos CodeArtifact informations d'identification sont stockées. Pour résoudre ce problème, nous vous recommandons d'ouvrir l'application Keychain, de supprimer toutes les CodeArtifact entrées et de configurer à nouveau le Swift Package Manager avec votre CodeArtifact référentiel en suivant les instructions fournies dans[Configurez le gestionnaire de packages Swift avec CodeArtifact](configure-swift.md).
## Xcode se bloque sur la machine CI en raison de l'invite de saisie du mot de passe par le trousseau
**Problème :** Lorsque vous essayez d'extraire des packages Swift dans le CodeArtifact cadre d'une version Xcode sur un serveur d'intégration continue (CI), par exemple avec GitHub Actions, l'authentification CodeArtifact peut se bloquer et éventuellement échouer avec un message d'erreur similaire au suivant :
`Failed to save credentials for \'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com\' to keychain: status -60008`
**Correctifs possibles :** Cela est dû au fait que les informations d'identification ne sont pas enregistrées dans le trousseau sur les machines CI et que Xcode ne prend en charge que les informations d'identification enregistrées dans le trousseau. Pour résoudre ce problème, nous vous recommandons de créer l'entrée du trousseau manuellement en suivant les étapes suivantes :
1. Préparez le trousseau.
```
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. Obtenez un jeton CodeArtifact d'authentification et le point de terminaison de votre référentiel.
```
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. Créez manuellement l'entrée Keychain.
```
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}"
```
Pour plus d'informations sur cette erreur et la solution, consultez [https://github.com/apple/swift-package-manager/issues/7236](https://github.com/apple/swift-package-manager/issues/7236).