As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando CodeArtifact com Swift
Esses tópicos descrevem como usar o Swift Package Manager CodeArtifact para instalar e publicar pacotes Swift.
**nota**
CodeArtifact suporta Swift 5.8 e posterior e Xcode 14.3 e posterior.
CodeArtifact recomenda o Swift 5.9 e posterior e o Xcode 15 e posterior.
**Topics**
+ [Configure o Swift com CodeArtifact](configure-swift.md)
+ [Consumir e publicar pacotes Swift](swift-publish-consume.md)
+ [Normalização do nome e do namespace do pacote Swift](swift-name-normalization.md)
+ [Solução de problemas do Swift](swift-troubleshooting.md)
# Configure o Swift Package Manager com CodeArtifact
Para usar o Swift Package Manager para publicar pacotes ou consumir pacotes AWS CodeArtifact, primeiro você precisará configurar as credenciais para acessar seu CodeArtifact repositório. O método recomendado para configurar a CLI do Swift Package Manager com CodeArtifact suas credenciais e o endpoint do repositório é usando o comando. `aws codeartifact login` Você também pode configurar o Swift Package Manager manualmente.
## Configurar o Swift o com o comando login
Use o `aws codeartifact login` comando para configurar o Swift Package Manager com CodeArtifact.
**nota**
Para usar o comando login, é necessário utilizar o Swift 5.8 ou posterior e o Swift 5.9 ou posterior é recomendado.
O comando `aws codeartifact login` fará o que segue:
1. Obtenha um token de autenticação CodeArtifact e armazene-o em seu ambiente. O modo como as credenciais são armazenadas depende do sistema operacional do ambiente:
1. **macOS:** uma entrada é criada no aplicativo macOS Chavechain.
1. **Linux e Windows:** uma entrada é criada no arquivo `~/.netrc`.
Em todos os sistemas operacionais, se existir uma entrada de credenciais, o comando substituirá a entrada por um token.
1. Busque a URL do endpoint CodeArtifact do repositório e adicione-a ao seu arquivo de configuração do Swift. O comando adiciona o URL do endpoint do repositório ao arquivo de configuração no nível do projeto localizado em `/path/to/project/.swiftpm/configuration/registries.json`.
**nota**
O comando `aws codeartifact login` aciona os comandos `swift package-registry` que devem ser executados a partir do diretório que contém o arquivo `Package.swift`. Por isso, o comando `aws codeartifact login` deve ser executado dentro do projeto Swift.
**Para configurar o Swift o com o comando login**
1. Navegue até o diretório do projeto Swift que contém o arquivo `Package.swift` do projeto.
1. Execute o seguinte comando `aws codeartifact login`.
Se você estiver acessando um repositório em um domínio de sua propriedade, não será necessário incluir `--domain-owner`. Para obter mais informações, consulte [Domínios entre contas](domain-overview.md#domain-overview-cross-account).
```
aws codeartifact login --tool swift --domain my_domain \
--domain-owner 111122223333 --repository my_repo \
[--namespace my_namespace]
```
A `--namespace` opção configura o aplicativo para consumir pacotes do seu CodeArtifact repositório somente se eles estiverem no namespace designado. [CodeArtifact namespaces](codeartifact-concepts.md#welcome-concepts-package-namespace) são sinônimos de escopos e são usados para organizar o código em grupos lógicos e evitar colisões de nomes que podem ocorrer quando sua base de código inclui várias bibliotecas.
O período de autorização padrão após chamar o `login` é de 12 horas e o `login` deve ser chamado para atualizar o token periodicamente. Para obter mais informações sobre o token de autorização criado com o comando `login`, consulte [Tokens criados com o comando `login`](tokens-authentication.md#auth-token-login).
## Configurar o Swift sem o comando login
Embora seja recomendável [configurar o Swift com o comando `aws codeartifact login`](#configure-swift-login-command), você também pode configurar o Swift Package Manager sem o comando login atualizando manualmente a configuração do Swift Package Manager.
No procedimento a seguir, você usará o AWS CLI para fazer o seguinte:
1. Obtenha um token de autenticação CodeArtifact e armazene-o em seu ambiente. O modo como as credenciais são armazenadas depende do sistema operacional do ambiente:
1. **macOS:** uma entrada é criada no aplicativo macOS Chavechain.
1. **Linux e Windows:** uma entrada é criada no arquivo `~/.netrc`.
1. Busque o URL do endpoint CodeArtifact do seu repositório.
1. No arquivo de configuração `~/.swiftpm/configuration/registries.json`, adicione uma entrada com o URL do endpoint do repositório e o tipo de autenticação.
**Para configurar o Swift sem o comando login**
1. Em uma linha de comando, use o comando a seguir para buscar um token de CodeArtifact autorização e armazená-lo em uma variável de ambiente.
+ *my\$1domain*Substitua pelo seu nome de CodeArtifact domínio.
+ *111122223333*Substitua pelo ID da AWS conta do proprietário do domínio. Se você estiver acessando um repositório em um domínio de sua propriedade, não será necessário incluir `--domain-owner`. Para obter mais informações, consulte [Domínios entre contas](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 (usando o shell de comando padrão):
```
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
```
+ Janelas PowerShell:
```
$env:CODEARTIFACT_AUTH_TOKEN = aws codeartifact get-authorization-token --domain my_domain --domain-owner 111122223333 --query authorizationToken --output text
```
------
1. Obtenha o endpoint do seu CodeArtifact repositório executando o comando a seguir. O endpoint do repositório é usado para direcionar o Swift Package Manager ao seu repositório para consumir ou publicar pacotes.
+ *my\$1domain*Substitua pelo seu nome de CodeArtifact domínio.
+ *111122223333*Substitua pelo ID da AWS conta do proprietário do domínio. Se você estiver acessando um repositório em um domínio de sua propriedade, não será necessário incluir `--domain-owner`. Para obter mais informações, consulte [Domínios entre contas](domain-overview.md#domain-overview-cross-account).
+ *my\$1repo*Substitua pelo nome CodeArtifact do seu repositório.
------
#### [ 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 (usando o shell de comando padrão):
```
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
```
+ Janelas PowerShell:
```
$env:CODEARTIFACT_REPO = aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format swift --query repositoryEndpoint --output text
```
------
O URL a seguir é um exemplo de endpoint de repositório.
```
https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/swift/my_repo/
```
**nota**
Para usar um endpoint de pilha dupla, use o endpoint `codeartifact.region.on.aws`.
**Importante**
Você deve incluir `login` ao final do endpoint de URL do repositório quando usado para configurar o Swift Package Manager. Isso é feito para você nos comandos deste procedimento.
1. Com esses dois valores armazenados em variáveis de ambiente, envie-os ao Swift usando o comando `swift package-registry login` da seguinte forma:
------
#### [ macOS and Linux ]
```
swift package-registry login ${CODEARTIFACT_REPO}login --token ${CODEARTIFACT_AUTH_TOKEN}
```
------
#### [ Windows ]
+ Windows (usando o shell de comando padrão):
```
swift package-registry login %CODEARTIFACT_REPO%login --token %CODEARTIFACT_AUTH_TOKEN%
```
+ Janelas PowerShell:
```
swift package-registry login $Env:CODEARTIFACT_REPO+"login" --token $Env:CODEARTIFACT_AUTH_TOKEN
```
------
1. Em seguida, atualize o registro do pacote usado pelo seu aplicativo para que qualquer dependência seja retirada do seu CodeArtifact repositório. Esse comando deve ser executado no diretório do projeto em que você está tentando resolver a dependência do pacote:
------
#### [ macOS and Linux ]
```
$ swift package-registry set ${CODEARTIFACT_REPO} [--scope my_scope]
```
------
#### [ Windows ]
+ Windows (usando o shell de comando padrão):
```
$ swift package-registry set %CODEARTIFACT_REPO% [--scope my_scope]
```
+ Janelas PowerShell:
```
$ swift package-registry set $Env:CODEARTIFACT_REPO [--scope my_scope]
```
------
A `--scope` opção configura o aplicativo para consumir pacotes do seu CodeArtifact repositório somente se eles estiverem no escopo designado. Os escopos são sinônimos de [CodeArtifact namespaces](codeartifact-concepts.md#welcome-concepts-package-namespace) e são usados para organizar o código em grupos lógicos e evitar colisões de nomes que podem ocorrer quando sua base de código inclui várias bibliotecas.
1. Você pode confirmar se a configuração foi realizada corretamente ao acessar o conteúdo do arquivo `.swiftpm/configuration/registries.json` no nível do projeto executando o seguinte comando no diretório do projeto:
```
$ 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
}
```
Agora que você configurou o Swift Package Manager com seu CodeArtifact repositório, você pode usá-lo para publicar e consumir pacotes Swift de e para ele. Para obter mais informações, consulte [Consumir e publicar pacotes Swift](swift-publish-consume.md).
# Consumir e publicar pacotes Swift
## Consumindo pacotes Swift de CodeArtifact
Use o procedimento a seguir para consumir pacotes Swift de um AWS CodeArtifact repositório.
**Para consumir pacotes Swift de um CodeArtifact repositório**
1. Caso contrário, siga as etapas [Configure o Swift Package Manager com CodeArtifact](configure-swift.md) para configurar o Swift Package Manager para usar seu CodeArtifact repositório com as credenciais adequadas.
**nota**
O token de autorização gerado é válido por 12 horas. Você precisará criar um novo se tiverem passado 12 horas desde a criação do token.
1. Edite o arquivo `Package.swift` na pasta do projeto do aplicativo para atualizar as dependências do pacote a serem usadas no projeto.
1. Se o arquivo `Package.swift` não contiver a seção `dependencies`, adicione uma.
1. Na seção `dependencies` do arquivo `Package.swift`, adicione o pacote que você deseja usar adicionando seu identificador de pacote. O identificador do pacote consiste no escopo e no nome do pacote separados por ponto (.). Consulte o trecho de código em uma etapa posterior para ver um exemplo.
**dica**
Para encontrar o identificador do pacote, você pode usar o CodeArtifact console. Localize a versão específica do pacote que você deseja usar e consulte as instruções de **Atalho de instalação** na página de versão do pacote.
1. Se o arquivo `Package.swift` não contiver a seção `targets`, adicione uma.
1. Na seção `targets`, adicione os destinos que precisarão usar a dependência.
A seguir há um trecho de exemplo que mostra a configuração das seções `dependencies` e `targets` em um arquivo `Package.swift`:
```
...
],
dependencies: [
.package(id: "my_scope.package_name", from: "1.0.0")
],
targets: [
.target(
name: "MyApp",
dependencies: ["package_name"]
),...
],
...
```
1. Agora que tudo está configurado, use o comando a seguir para baixar as dependências do CodeArtifact pacote.
```
swift package resolve
```
## Consumindo pacotes Swift CodeArtifact do Xcode
Use o procedimento a seguir para consumir pacotes Swift de um CodeArtifact repositório no Xcode.
**Para consumir pacotes Swift de um CodeArtifact repositório no Xcode**
1. Caso contrário, siga as etapas [Configure o Swift Package Manager com CodeArtifact](configure-swift.md) para configurar o Swift Package Manager para usar seu CodeArtifact repositório com as credenciais adequadas.
**nota**
O token de autorização gerado é válido por 12 horas. Você precisará criar um novo se tiverem passado 12 horas desde a criação do token.
1. Adicione os pacotes como uma dependência do projeto no Xcode.
1. Escolha **Arquivo > Adicionar pacotes**.
1. Localize o pacote usando a barra de pesquisa. Sua pesquisa deve estar no formato `package_scope.package_name`.
1. Quando encontrado, escolha o pacote e clique em **Adicionar pacote**.
1. Depois que o pacote for verificado, escolha os produtos do pacote que você deseja adicionar como dependência e escolha **Adicionar pacote**.
Se você tiver problemas ao usar seu CodeArtifact repositório com o Xcode, consulte [Solução de problemas do Swift](swift-troubleshooting.md) os problemas comuns e as possíveis correções.
## Publicando pacotes Swift em CodeArtifact
CodeArtifact recomenda o Swift 5.9 ou posterior e usa o `swift package-registry publish` comando para publicar pacotes Swift. Se você estiver usando uma versão anterior, deverá usar um comando Curl para publicar pacotes do Swift. CodeArtifact
### Publicando CodeArtifact pacotes com o `swift package-registry publish` comando
Use o procedimento a seguir com o Swift 5.9 ou posterior para publicar pacotes Swift em um CodeArtifact repositório com o Swift Package Manager.
1. Caso contrário, siga as etapas [Configure o Swift Package Manager com CodeArtifact](configure-swift.md) para configurar o Swift Package Manager para usar seu CodeArtifact repositório com as credenciais adequadas.
**nota**
O token de autorização gerado é válido por 12 horas. Você precisará criar um novo se tiverem passado 12 horas desde a criação do token.
1. Navegue até o diretório do projeto Swift que contém o arquivo `Package.swift` para seu pacote.
1. Para publicar o pacote, execute o seguinte comando `swift package-registry publish`. O comando cria um arquivo de origem do pacote e o publica no seu CodeArtifact repositório.
```
swift package-registry publish packageScope.packageName packageVersion
```
Por exemplo:
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. Você pode confirmar se o pacote foi publicado e existe no repositório acessando o console ou usando o comando `aws codeartifact list-packages` da seguinte forma:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Você pode exibir a versão única do pacote usando o comando `aws codeartifact list-package-versions` da seguinte forma:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
### Publicando CodeArtifact pacotes com Curl
Embora seja recomendável usar o `swift package-registry publish` comando que vem com o Swift 5.9 ou posterior, você também pode usar o Curl para publicar pacotes do Swift no. CodeArtifact
Use o procedimento a seguir para publicar pacotes Swift em um AWS CodeArtifact repositório com Curl.
1. Caso ainda não tenha feito isso, crie e atualize as variáveis de ambiente `CODEARTIFACT_AUTH_TOKEN` e `CODEARTIFACT_REPO` seguindo as etapas em [Configure o Swift Package Manager com CodeArtifact](configure-swift.md).
**nota**
O token de autorização é válido por 12 horas. Você precisará atualizar a variável de ambiente `CODEARTIFACT_AUTH_TOKEN` com novas credenciais se tiverem passado 12 horas desde que ela foi criada.
1. Primeiramente, se você não tiver um pacote Swift criado, isso pode ser feito executando os seguintes comandos:
```
mkdir testDir && cd testDir
swift package init
git init .
swift package archive-source
```
1. Use o seguinte comando Curl para publicar seu pacote Swift em 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. Você pode confirmar se o pacote foi publicado e existe no repositório acessando o console ou usando o comando `aws codeartifact list-packages` da seguinte forma:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Você pode exibir a versão única do pacote usando o comando `aws codeartifact list-package-versions` da seguinte forma:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
## Buscando pacotes Swift GitHub e republicando em CodeArtifact
Use o procedimento a seguir para buscar um pacote Swift GitHub e republicá-lo em um CodeArtifact repositório.
**Para obter um pacote Swift GitHub e republicá-lo no CodeArtifact**
1. Caso contrário, siga as etapas [Configure o Swift Package Manager com CodeArtifact](configure-swift.md) para configurar o Swift Package Manager para usar seu CodeArtifact repositório com as credenciais adequadas.
**nota**
O token de autorização gerado é válido por 12 horas. Você precisará criar um novo se tiverem passado 12 horas desde a criação do token.
1. Clone o repositório Git do pacote Swift que você deseja buscar e republicar usando o seguinte comando `git clone`. Para obter informações sobre a clonagem de GitHub repositórios, consulte [Clonar um repositório](https://docs.github.com/en/repositories/creating-and-managing-repositories/cloning-a-repository) na Documentação. GitHub
```
git clone repoURL
```
1. Navegue até o repositório que você acabou de clonar:
```
cd repoName
```
1. Crie o pacote e publique-o no CodeArtifact.
1. **Recomendado:** se você estiver usando o Swift 5.9 ou posterior, poderá usar o `swift package-registry publish` comando a seguir para criar o pacote e publicá-lo no seu CodeArtifact repositório configurado.
```
swift package-registry publish packageScope.packageName versionNumber
```
Por exemplo:
```
swift package-registry publish myScope.myPackage 1.0.0
```
1. Se você estiver usando uma versão do Swift anterior à 5.9, deverá usar o comando `swift archive-source` para criar o pacote e, em seguida, usar um comando Curl para publicá-lo.
1. Se as variáveis de ambiente `CODEARTIFACT_AUTH_TOKEN` e `CODEARTIFACT_REPO` não tiverem sido configuradas ou caso já tenham se passado mais de 12 horas desde que você realizou essa configuração, siga as etapas em [Configurar o Swift sem o comando login](configure-swift.md#configure-swift-without-login-command).
1. Crie o pacote Swift usando o comando `swift package archive-source`:
```
swift package archive-source
```
Se for bem-sucedido, você verá `Created package_name.zip` na linha de comando.
1. Use o seguinte comando Curl para publicar o pacote Swift em 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. Você pode confirmar se o pacote foi publicado e existe no repositório acessando o console ou usando o comando `aws codeartifact list-packages` da seguinte forma:
```
aws codeartifact list-packages --domain my_domain --repository my_repo
```
Você pode exibir a versão única do pacote usando o comando `aws codeartifact list-package-versions` da seguinte forma:
```
aws codeartifact list-package-versions --domain my_domain --repository my_repo \
--format swift --namespace my_scope --package package_name
```
# Normalização do nome e do namespace do pacote Swift
CodeArtifact normaliza os nomes e namespaces dos pacotes antes de armazená-los, o que significa que os nomes CodeArtifact podem ser diferentes dos fornecidos quando o pacote foi publicado.
**Normalização do nome do pacote e do namespace: CodeArtifact normaliza** os nomes e namespaces dos pacotes Swift convertendo todas as letras em minúsculas.
**Normalização da versão do pacote: CodeArtifact não normaliza** as versões do pacote Swift. [Observe que CodeArtifact só oferece suporte aos padrões de versão 2.0 do Semantic Versioning. Para obter mais informações sobre o Versionamento Semântico, consulte Versionamento Semântico 2.0.0.](https://semver.org/spec/v2.0.0.html)
O nome e o namespace do pacote não normalizados podem ser usados com solicitações de API e CLI porque CodeArtifact executam a normalização nas entradas dessas solicitações. Por exemplo, as entradas `--package myPackage` e `--namespace myScope` seriam normalizadas e retornariam um pacote normalizado com o nome `mypackage` e namespace `myscope`.
**Você deve usar nomes normalizados em ARNs, como nas políticas do IAM.**
Para localizar o nome normalizado de um pacote, use o comando `aws codeartifact list-packages`. Para obter mais informações, consulte [Listar nomes de pacotes](list-packages.md).
# Solução de problemas do Swift
As informações a seguir podem ajudá-lo a solucionar problemas comuns com o Swift e. CodeArtifact
## O erro 401 é exibido no Xcode mesmo depois de configurar o Swift Package Manager
**Problema:** [Quando você está tentando adicionar um pacote do seu CodeArtifact repositório como uma dependência ao seu projeto Swift no Xcode, você está recebendo um erro 401 não autorizado mesmo depois de seguir as instruções para conectar o Swift a. CodeArtifact](configure-swift.md)
**Possíveis correções:** isso pode ser causado por um problema com o aplicativo macOS Keychain, onde suas CodeArtifact credenciais são armazenadas. Para corrigir isso, recomendamos abrir o aplicativo Keychain, excluir todas as CodeArtifact entradas e configurar o Swift Package Manager com seu CodeArtifact repositório novamente seguindo as instruções em. [Configure o Swift Package Manager com CodeArtifact](configure-swift.md)
## O Xcode trava na máquina de CI devido à solicitação de senha do Keychain
**Problema:** quando você está tentando extrair pacotes do Swift CodeArtifact como parte de uma compilação do Xcode em um servidor de integração contínua (CI), como com o GitHub Actions, a autenticação com CodeArtifact pode travar e, eventualmente, falhar com uma mensagem de erro semelhante à seguinte:
`Failed to save credentials for \'https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com\' to keychain: status -60008`
**Possíveis correções:** isso ocorre porque as credenciais não são salvas no Keychain em máquinas de CI e o Xcode é compatível somente com as credenciais salvas no Keychain. Para corrigir isso, recomendamos criar a entrada do Keychain manualmente, usando as seguintes etapas:
1. Prepare o Keychain.
```
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. Obtenha um token de CodeArtifact autenticação e o endpoint do seu repositório.
```
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. Crie manualmente a entrada do 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}"
```
Para obter mais informações sobre esse erro e a solução, consulte [https://github.com/apple/swift-package-manager/issues/7236](https://github.com/apple/swift-package-manager/issues/7236).