Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo CodeArtifact con Swift
Questi argomenti descrivono come utilizzare Swift Package Manager CodeArtifact per installare e pubblicare pacchetti Swift.
**Nota**
CodeArtifact supporta Swift 5.8 e versioni successive e Xcode 14.3 e versioni successive.
CodeArtifact consiglia Swift 5.9 e versioni successive e Xcode 15 e versioni successive.
**Topics**
+ [Configura Swift con CodeArtifact](configure-swift.md)
+ [Consumo e pubblicazione di pacchetti Swift](swift-publish-consume.md)
+ [Normalizzazione del nome e dello spazio dei nomi del pacchetto Swift](swift-name-normalization.md)
+ [Risoluzione dei problemi Swift](swift-troubleshooting.md)
# Configura Swift Package Manager con CodeArtifact
Per utilizzare Swift Package Manager per pubblicare o utilizzare pacchetti da cui utilizzare AWS CodeArtifact, devi prima configurare le credenziali per accedere al tuo CodeArtifact repository. Il metodo consigliato per configurare la CLI di Swift Package Manager con CodeArtifact le credenziali e l'endpoint del repository consiste nell'utilizzare il comando. `aws codeartifact login` Puoi anche configurare Swift Package Manager manualmente.
## Configura Swift con il comando login
Usa il `aws codeartifact login` comando per configurare Swift Package Manager con CodeArtifact.
**Nota**
Per utilizzare il comando login, è necessario Swift 5.8 o successivo e Swift 5.9 o successivo è consigliato.
Il `aws codeartifact login` comando eseguirà le seguenti operazioni:
1. Recupera un token di autenticazione CodeArtifact e memorizzalo nel tuo ambiente. La modalità di archiviazione delle credenziali dipende dal sistema operativo dell'ambiente:
1. **macOS:** viene creata una voce nell'applicazione macOS Keychain.
1. **Linux e Windows:** viene creata una voce nel file. `~/.netrc`
In tutti i sistemi operativi, se esiste un'immissione di credenziali, questo comando sostituisce tale voce con un nuovo token.
1. Recupera l'URL CodeArtifact dell'endpoint del repository e aggiungilo al file di configurazione Swift. Il comando aggiunge l'URL dell'endpoint del repository al file di configurazione a livello di progetto che si trova in. `/path/to/project/.swiftpm/configuration/registries.json`
**Nota**
Il `aws codeartifact login` comando richiama `swift package-registry` i comandi che devono essere eseguiti dalla directory che contiene il `Package.swift` file. Per questo motivo, `aws codeartifact login` il comando deve essere eseguito dall'interno del progetto Swift.
**Per configurare Swift con il comando login**
1. Vai alla directory del progetto Swift che contiene il file del `Package.swift` tuo progetto.
1. Eseguire il seguente comando `aws codeartifact login`.
Se accedi a un repository in un dominio di tua proprietà, non è necessario includerlo. `--domain-owner` Per ulteriori informazioni, consulta [Domini con più account](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`opzione configura l'applicazione in modo che utilizzi solo i pacchetti del tuo CodeArtifact repository se si trovano nello spazio dei nomi designato. [CodeArtifact i namespace](codeartifact-concepts.md#welcome-concepts-package-namespace) sono sinonimo di ambiti e vengono utilizzati per organizzare il codice in gruppi logici e per prevenire le collisioni di nomi che possono verificarsi quando la base di codice include più librerie.
Il periodo di autorizzazione predefinito dopo la chiamata `login` è di 12 ore e `login` deve essere chiamato per aggiornare periodicamente il token. Per ulteriori informazioni sul token di autorizzazione creato con il `login` comando, vedere[Token creati con il comando `login`](tokens-authentication.md#auth-token-login).
## Configura Swift senza il comando di login
Sebbene sia consigliabile [configurare Swift con il `aws codeartifact login` comando](#configure-swift-login-command), è possibile configurare Swift Package Manager anche senza il comando login aggiornando manualmente la configurazione di Swift Package Manager.
Nella procedura seguente, utilizzerai il AWS CLI per effettuare le seguenti operazioni:
1. Recupera un token di autenticazione CodeArtifact e memorizzalo nel tuo ambiente. La modalità di archiviazione delle credenziali dipende dal sistema operativo dell'ambiente:
1. **macOS:** viene creata una voce nell'applicazione macOS Keychain.
1. **Linux e Windows:** viene creata una voce nel file. `~/.netrc`
1. Recupera l'URL dell'endpoint CodeArtifact del tuo repository.
1. Nel file di `~/.swiftpm/configuration/registries.json` configurazione, aggiungi una voce con l'URL dell'endpoint del repository e il tipo di autenticazione.
**Per configurare Swift senza il comando login**
1. In una riga di comando, usa il seguente comando per recuperare un token di CodeArtifact autorizzazione e memorizzarlo in una variabile di ambiente.
+ *my\$1domain*Sostituiscilo con il tuo nome di CodeArtifact dominio.
+ Sostituiscilo *111122223333* con l'ID dell' AWS account del proprietario del dominio. Se accedi a un repository in un dominio di tua proprietà, non è necessario `--domain-owner` includerlo. Per ulteriori informazioni, consulta [Domini con più account](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 (utilizzando la shell dei comandi predefinita):
```
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. Ottieni l'endpoint del tuo CodeArtifact repository eseguendo il comando seguente. L'endpoint del tuo repository viene utilizzato per indirizzare Swift Package Manager al tuo repository per consumare o pubblicare pacchetti.
+ Sostituiscilo *my\$1domain* con il tuo nome di dominio. CodeArtifact
+ Sostituiscilo *111122223333* con l'ID dell' AWS account del proprietario del dominio. Se accedi a un repository in un dominio di tua proprietà, non è necessario `--domain-owner` includerlo. Per ulteriori informazioni, consulta [Domini con più account](domain-overview.md#domain-overview-cross-account).
+ *my\$1repo*Sostituiscilo con il nome del tuo CodeArtifact repository.
------
#### [ 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 (utilizzando la shell di comando predefinita):
```
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
```
------
L'URL seguente è un esempio di endpoint del repository.
```
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/swift/my_repo/
```
**Nota**
Per utilizzare un endpoint dualstack, usa l'endpoint. `codeartifact.region.on.aws`
**Importante**
È necessario aggiungere alla fine `login` dell'endpoint URL del repository quando viene utilizzato per configurare Swift Package Manager. Questa operazione viene eseguita automaticamente nei comandi di questa procedura.
1. Con questi due valori memorizzati nelle variabili di ambiente, passali a Swift usando il `swift package-registry login` comando seguente:
------
#### [ macOS and Linux ]
```
swift package-registry login ${CODEARTIFACT_REPO}login --token ${CODEARTIFACT_AUTH_TOKEN}
```
------
#### [ Windows ]
+ Windows (utilizzando la shell dei comandi predefinita):
```
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. Successivamente, aggiorna il registro dei pacchetti utilizzato dall'applicazione in modo che qualsiasi dipendenza venga estratta dal CodeArtifact repository. Questo comando deve essere eseguito nella directory del progetto in cui state cercando di risolvere la dipendenza del pacchetto:
------
#### [ macOS and Linux ]
```
$ swift package-registry set ${CODEARTIFACT_REPO} [--scope my_scope]
```
------
#### [ Windows ]
+ Windows (utilizzando la shell dei comandi predefinita):
```
$ swift package-registry set %CODEARTIFACT_REPO% [--scope my_scope]
```
+ Windows PowerShell:
```
$ swift package-registry set $Env:CODEARTIFACT_REPO [--scope my_scope]
```
------
L'`--scope`opzione configura l'applicazione in modo che utilizzi solo i pacchetti del CodeArtifact repository se rientrano nell'ambito designato. Gli ambiti sono sinonimo di [CodeArtifact namespace](codeartifact-concepts.md#welcome-concepts-package-namespace) e vengono utilizzati per organizzare il codice in gruppi logici e per prevenire le collisioni di nomi che possono verificarsi quando la base di codice include più librerie.
1. È possibile verificare che la configurazione sia stata impostata correttamente visualizzando il contenuto del `.swiftpm/configuration/registries.json` file a livello di progetto eseguendo il comando seguente nella directory del progetto:
```
$ 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
}
```
Ora che hai configurato Swift Package Manager con il tuo CodeArtifact repository, puoi usarlo per pubblicare e utilizzare pacchetti Swift da e verso di esso. Per ulteriori informazioni, consulta [Consumo e pubblicazione di pacchetti Swift](swift-publish-consume.md).
# Consumo e pubblicazione di pacchetti Swift
## Consumo di pacchetti Swift da CodeArtifact
Usa la seguente procedura per consumare pacchetti Swift da un AWS CodeArtifact repository.
**Per utilizzare pacchetti Swift da un repository CodeArtifact**
1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.
1. Modifica il `Package.swift` file nella cartella del progetto dell'applicazione per aggiornare le dipendenze dei pacchetti che verranno utilizzate dal progetto.
1. Se il `Package.swift` file non contiene una `dependencies` sezione, aggiungine una.
1. Nella `dependencies` sezione del `Package.swift` file, aggiungi il pacchetto che desideri utilizzare aggiungendo il relativo identificatore del pacchetto. L'identificatore del pacchetto è costituito dall'ambito e dal nome del pacchetto separati da un punto. Per un esempio, vedi il frammento di codice che segue un passaggio successivo.
**Suggerimento**
Per trovare l'identificatore del pacchetto, puoi usare la console. CodeArtifact Trova la versione specifica del pacchetto che desideri utilizzare e consulta le istruzioni **rapide di installazione nella** pagina della versione del pacchetto.
1. Se il `Package.swift` file non contiene una `targets` sezione, aggiungine una.
1. Nella `targets` sezione, aggiungi gli obiettivi che dovranno utilizzare la dipendenza.
Il frammento seguente è un frammento di esempio che mostra le sezioni configurate `dependencies` e `targets` le sezioni in un file: `Package.swift`
```
...
],
dependencies: [
.package(id: "my_scope.package_name", from: "1.0.0")
],
targets: [
.target(
name: "MyApp",
dependencies: ["package_name"]
),...
],
...
```
1. Ora che tutto è configurato, usate il seguente comando per scaricare le dipendenze del pacchetto da. CodeArtifact
```
swift package resolve
```
## Consumo di pacchetti Swift da Xcode CodeArtifact
Usa la seguente procedura per consumare pacchetti Swift da un CodeArtifact repository in Xcode.
**Per utilizzare pacchetti Swift da un repository in Xcode CodeArtifact**
1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.
1. Aggiungi i pacchetti come dipendenza nel tuo progetto in Xcode.
1. Scegli **File > Aggiungi pacchetti**.
1. Cerca il tuo pacchetto utilizzando la barra di ricerca. La tua ricerca deve essere inserita nel modulo`package_scope.package_name`.
1. Una volta trovato, scegli il pacchetto e scegli **Aggiungi pacchetto**.
1. Una volta verificato il pacchetto, scegli i prodotti del pacchetto che desideri aggiungere come dipendenza e scegli **Aggiungi pacchetto**.
Se riscontri problemi nell'utilizzo del tuo CodeArtifact repository con Xcode, consulta i problemi più comuni e [Risoluzione dei problemi Swift](swift-troubleshooting.md) le possibili correzioni.
## Pubblicazione di pacchetti Swift su CodeArtifact
CodeArtifact consiglia Swift 5.9 o versione successiva e utilizza il `swift package-registry publish` comando per pubblicare pacchetti Swift. Se stai usando una versione precedente, devi usare un comando Curl per pubblicare i pacchetti Swift su. CodeArtifact
### Pubblicazione di CodeArtifact pacchetti con il comando `swift package-registry publish`
Usa la seguente procedura con Swift 5.9 o versione successiva per pubblicare pacchetti Swift in un CodeArtifact repository con Swift Package Manager.
1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla sua creazione.
1. Vai alla directory del progetto Swift che contiene il `Package.swift` file del tuo pacchetto.
1. Esegui il `swift package-registry publish` comando seguente per pubblicare il pacchetto. Il comando crea un archivio sorgente del pacchetto e lo pubblica nel tuo CodeArtifact repository.
```
swift package-registry publish packageScope.packageName packageVersion
```
Esempio:
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. È possibile confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
### Pubblicazione di CodeArtifact pacchetti con Curl
Sebbene sia consigliabile utilizzare il `swift package-registry publish` comando fornito con Swift 5.9 o versioni successive, puoi anche usare Curl per pubblicare pacchetti Swift su. CodeArtifact
Usa la seguente procedura per pubblicare pacchetti Swift in un repository con Curl. AWS CodeArtifact
1. In caso contrario, crea e aggiorna le `CODEARTIFACT_AUTH_TOKEN` variabili e di `CODEARTIFACT_REPO` ambiente seguendo i passaggi riportati di seguito. [Configura Swift Package Manager con CodeArtifact](configure-swift.md)
**Nota**
Il token di autorizzazione è valido per 12 ore. Dovrai aggiornare la variabile di `CODEARTIFACT_AUTH_TOKEN` ambiente con nuove credenziali se sono trascorse 12 ore dalla sua creazione.
1. Innanzitutto, se non hai creato un pacchetto Swift, puoi farlo eseguendo i seguenti comandi:
```
mkdir testDir && cd testDir
swift package init
git init .
swift package archive-source
```
1. Usa il seguente comando Curl per pubblicare il tuo pacchetto Swift su: 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. Puoi confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
## Recupero di pacchetti Swift GitHub e ripubblicazione su CodeArtifact
Usa la seguente procedura per recuperare un pacchetto Swift da GitHub e ripubblicarlo in un repository. CodeArtifact
**Per recuperare un pacchetto Swift da e ripubblicarlo in GitHub CodeArtifact**
1. In caso contrario, segui i passaggi indicati [Configura Swift Package Manager con CodeArtifact](configure-swift.md) per configurare Swift Package Manager per utilizzare il tuo CodeArtifact repository con le credenziali corrette.
**Nota**
Il token di autorizzazione generato è valido per 12 ore. Dovrai crearne uno nuovo se sono trascorse 12 ore dalla creazione del token.
1. Clona il repository git del pacchetto Swift che desideri recuperare e ripubblicare usando il seguente comando. `git clone` [Per informazioni sulla clonazione dei repository, consulta Clonazione di un GitHub repository nei Documenti.](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) GitHub
```
git clone repoURL
```
1. Passa al repository che hai appena clonato:
```
cd repoName
```
1. Crea il pacchetto e pubblicalo su. CodeArtifact
1. **Consigliato:** se utilizzi Swift 5.9 o versioni successive, puoi usare il seguente `swift package-registry publish` comando per creare il pacchetto e pubblicarlo nel tuo repository configurato CodeArtifact .
```
swift package-registry publish packageScope.packageName versionNumber
```
Esempio:
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. Se utilizzi una versione di Swift precedente alla 5.9, devi usare il `swift archive-source` comando per creare il pacchetto e poi usare un comando Curl per pubblicarlo.
1. Se non hai configurato le variabili `CODEARTIFACT_AUTH_TOKEN` e di `CODEARTIFACT_REPO` ambiente, o sono passate più di 12 ore da quando l'hai fatto, segui i passaggi indicati. [Configura Swift senza il comando di login](configure-swift.md#configure-swift-without-login-command)
1. Crea il pacchetto Swift usando il `swift package archive-source` comando:
```
swift package archive-source
```
In caso di successo, lo vedrai `Created package_name.zip` nella riga di comando.
1. Usa il seguente comando Curl per pubblicare il pacchetto Swift su: 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. Puoi confermare che il pacchetto è stato pubblicato ed esiste nel repository effettuando il check-in nella console o utilizzando il `aws codeartifact list-packages` comando seguente:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
È possibile elencare la versione singola del pacchetto utilizzando il `aws codeartifact list-package-versions` comando seguente:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
# Normalizzazione del nome e dello spazio dei nomi del pacchetto Swift
CodeArtifact normalizza i nomi e gli spazi dei nomi dei pacchetti prima di memorizzarli, il che significa che i nomi contenuti CodeArtifact possono essere diversi da quelli forniti quando il pacchetto è stato pubblicato.
Normalizzazione **del nome del pacchetto e dello spazio dei nomi: CodeArtifact normalizza** i nomi e gli spazi dei nomi dei pacchetti Swift convertendo tutte le lettere in minuscolo.
**Normalizzazione della versione del pacchetto:** CodeArtifact non normalizza le versioni dei pacchetti Swift. [Nota che supporta CodeArtifact solo i modelli di versione Semantic Versioning 2.0, per ulteriori informazioni sul Semantic Versioning, vedi Semantic Versioning 2.0.0.](https://semver.org/spec/v2.0.0.html)
Il nome e lo spazio dei nomi del pacchetto non normalizzati possono essere utilizzati con le richieste API e CLI perché CodeArtifact eseguono la normalizzazione degli input per tali richieste. Ad esempio, gli input di `--package myPackage` e `--namespace myScope` verrebbero normalizzati e restituirebbero un pacchetto con un nome di pacchetto e uno spazio dei nomi normalizzati di. `mypackage` `myscope`
**È necessario utilizzare nomi normalizzati, ad esempio nelle ARNs politiche IAM.**
Per trovare il nome normalizzato di un pacchetto, usa il `aws codeartifact list-packages` comando. Per ulteriori informazioni, consulta [Elenca i nomi dei pacchetti](list-packages.md).
# Risoluzione dei problemi Swift
Le seguenti informazioni potrebbero aiutarti a risolvere i problemi più comuni relativi a Swift e. CodeArtifact
## Ricevo un errore 401 in Xcode anche dopo aver configurato Swift Package Manager
**Problema:** [quando cerchi di aggiungere un pacchetto dal tuo CodeArtifact repository come dipendenza al tuo progetto Swift in Xcode, ricevi un errore 401 non autorizzato anche dopo aver seguito le istruzioni per connettere Swift a. CodeArtifact](configure-swift.md)
**Possibili correzioni:** ciò può essere causato da un problema con l'applicazione macOS Keychain, in cui sono archiviate CodeArtifact le credenziali. Per risolvere questo problema, ti consigliamo di aprire l'applicazione Keychain ed eliminare tutte le CodeArtifact voci e di configurare nuovamente Swift Package Manager con il tuo CodeArtifact repository seguendo le istruzioni riportate in. [Configura Swift Package Manager con CodeArtifact](configure-swift.md)
## Xcode si blocca sulla macchina CI a causa della richiesta di password del portachiavi
**Problema:** quando si tenta di estrarre pacchetti Swift da CodeArtifact una build Xcode su un server di integrazione continua (CI), ad esempio con GitHub Actions, l'autenticazione con CodeArtifact può bloccarsi e alla fine fallire con un messaggio di errore simile al seguente:
`Failed to save credentials for \'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com\' to keychain: status -60008`
**Possibili correzioni:** ciò è causato dal fatto che le credenziali non vengono salvate nel portachiavi sulle macchine CI e Xcode supporta solo le credenziali salvate in Keychain. Per risolvere questo problema, consigliamo di creare manualmente la voce del portachiavi utilizzando i seguenti passaggi:
1. Prepara il portachiavi.
```
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. Ottieni un token di CodeArtifact autenticazione e l'endpoint del tuo repository.
```
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. Crea manualmente la voce 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}"
```
Per ulteriori informazioni su questo errore e sulla soluzione, vedere [https://github.com/apple/swift-package-manager/issues/7236.](https://github.com/apple/swift-package-manager/issues/7236)