\n
... more content ... \n",
"versionRevision": "REVISION-SAMPLE-55C752BEE9B772FC"
}
```
# Atualizar o status da versão do pacote
Cada versão do pacote CodeArtifact tem um status que descreve o estado atual e a disponibilidade da versão do pacote. Você pode alterar o status da versão do pacote usando o console AWS CLI e o console.
**nota**
Para obter mais informações sobre o status da versão do pacote, incluindo uma lista dos status disponíveis, consulte [Satus da versão do pacote](packages-overview.md#package-version-status).
## Atualizar o status da versão do pacote
Definir o status de uma versão de pacote permite controlar como uma versão de pacote pode ser usada sem excluí-la completamente do repositório. Por exemplo, quando uma versão de pacote tem o status de `Unlisted`, ela ainda pode ser baixada normalmente, mas não aparecerá nas listas de versões de pacotes retornadas para comandos como `npm view`. A [UpdatePackageVersionsStatus API](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_UpdatePackageVersionsStatus.html) permite definir o status da versão do pacote de várias versões do mesmo pacote em uma única chamada de API. Para obter uma descrição dos diferentes status, consulte [Visão geral dos pacotes](packages-overview.md).
Use o comando `update-package-versions-status` para alterar o status de uma versão do pacote para `Published`, `Unlisted` ou `Archived`. Para conferir as permissões necessárias do IAM para usar o comando, consulte [Permissões obrigatórias do IAM para atualizar o status da versão do pacote](#update-package-version-status-iam). O exemplo a seguir define o status da versão 4.1.0 do pacote npm `chalk` como `Archived`.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --package chalk
--versions 4.1.0 --target-status Archived
```
Exemplo de saída:
```
{
"successfulVersions": {
"4.1.0": {
"revision": "+Oz8skWbwY3k8M6SrNIqNj6bVH/ax+CxvkJx+No5j8I=",
"status": "Archived"
}
},
"failedVersions": {}
}
```
Este exemplo usa um pacote npm, mas o comando funciona de forma idêntica para outros formatos. Várias versões podem ser movidas para o mesmo status de destino usando um único comando, confira o exemplo a seguir.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --package chalk
--versions 4.1.0 4.1.1 --target-status Archived
```
Exemplo de saída:
```
{
"successfulVersions": {
"4.1.0": {
"revision": "25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=",
"status": "Archived"
},
"4.1.1": {
"revision": "+Oz8skWbwY3k8M6SrNIqNj6bVH/ax+CxvkJx+No5j8I=",
"status": "Archived"
}
},
"failedVersions": {}
}
```
Observe que, uma vez publicada, uma versão do pacote não pode ser movida de volta ao estado `Unfinished`, portanto, esse status não é permitido como um valor para o parâmetro `--target-status`. Para mover a versão do pacote para o estado `Disposed`, use o comando `dispose-package-versions` no lugar, conforme descrito abaixo.
## Permissões obrigatórias do IAM para atualizar o status da versão do pacote
Para chamar `update-package-versions-status` para um pacote, você deve ter a permissão `codeartifact:UpdatePackageVersionsStatus` no recurso do pacote. Isso significa que você pode conceder permissão para chamar `update-package-versions-status` por pacote. Por exemplo, uma política do IAM que concedesse permissão para chamar `update-package-versions-status` o pacote npm *chalk* incluiria uma declaração como a seguinte.
```
{
"Action": [
"codeartifact:UpdatePackageVersionsStatus"
],
"Effect": "Allow",
"Resource": "arn:aws:codeartifact:us-east-1:111122223333:package/my_domain/my_repo/npm//chalk"
}
```
## Atualizar o status de um pacote npm com escopo definido
Para atualizar o status da versão do pacote de uma versão do pacote npm com um escopo, use o parâmetro `--namespace`. Por exemplo, para remover da lista a versão 8.0.0 do `@nestjs/core`, use o comando a seguir.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --namespace nestjs
--package core --versions 8.0.0 --target-status Unlisted
```
## Atualizar o status de um pacote Maven
Os pacotes Maven sempre têm um ID de grupo, chamado de namespace em. CodeArtifact Use o parâmetro `--namespace` para especificar o ID do grupo Maven ao chamar `update-package-versions-status`. Por exemplo, para arquivar a versão 2.13.1 do pacote Maven `org.apache.logging.log4j:log4j`, use o comando a seguir.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format maven
--namespace org.apache.logging.log4j --package log4j
--versions 2.13.1 --target-status Archived
```
## Especificar uma revisão da versão do pacote
A revisão da versão do pacote é uma string que especifica um determinado conjunto de ativos e metadados da versão de um pacote. Você pode especificar uma revisão da versão do pacote para atualizar o status das versões do pacote que estão em um estado definido. Para especificar uma revisão da versão do pacote, use o parâmetro `--version-revisions` para passar uma ou mais versões do pacote separadas por vírgula e os pares de revisão da versão do pacote. O status de uma versão do pacote só será atualizado se a revisão atual da versão do pacote corresponder ao valor especificado.
**nota**
O parâmetro `—-versions` também deve ser definido ao usar o parâmetro `--version-revisions`.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --package chalk
--version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8bzVMJ4="
--versions 4.1.0 --target-status Archived
```
Para atualizar várias versões com um único comando, passe uma lista separada por vírgulas de pares de versão e de revisão de versão para as opções `--version-revisions`. O comando de exemplo a seguir define dois pares diferentes de versão do pacote e de revisão da versão do pacote.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm
--package chalk
--version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=,4.0.0=E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc="
--versions 4.1.0 4.0.0 --target-status Published
```
Exemplo de saída:
```
{
"successfulVersions": {
"4.0.0": {
"revision": "E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc=",
"status": "Published"
},
"4.1.0": {
"revision": "25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=",
"status": "Published"
}
},
"failedVersions": {}
}
```
Ao atualizar várias versões do pacote, as versões passadas para `--version-revisions` devem ser iguais às versões passadas para `--versions`. Se uma revisão for especificada de forma incorreta, o status dessa versão não será atualizado.
## Usar o parâmetro de status esperado
O comando `update-package-versions-status` apresenta o parâmetro `--expected-status` compatível com a especificação do status atual esperado de uma versão do pacote. Se o status atual não corresponder ao valor passado para `--expected-status`, o status dessa versão do pacote não será atualizado.
Por exemplo, em*my\$1repo*, as versões 4.0.0 e 4.1.0 do pacote npm `chalk` atualmente têm o status de. `Published` Uma chamada para `update-package-versions-status` que especifica um status esperado de `Unlisted` falhará na atualização de ambas as versões do pacote devido à incompatibilidade de status.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo --format npm --package chalk
--versions 4.1.0 4.0.0 --target-status Archived --expected-status Unlisted
```
Exemplo de saída:
```
{
"successfulVersions": {},
"failedVersions": {
"4.0.0": {
"errorCode": "MISMATCHED_STATUS",
"errorMessage": "current status: Published, expected status: Unlisted"
},
"4.1.0": {
"errorCode": "MISMATCHED_STATUS",
"errorMessage": "current status: Published, expected status: Unlisted"
}
}
}
```
## Erros com versões de pacotes individuais
Há vários motivos pelos quais o status de uma versão do pacote não será atualizado durante a chamada de `update-package-versions-status`. Por exemplo, a revisão da versão do pacote pode ter sido especificada de maneira incorreta ou o status esperado não corresponde ao status atual. Nesses casos, a versão será incluída no mapa `failedVersions` na resposta da API. Se uma versão falhar, outras versões especificadas na mesma chamada para `update-package-versions-status` poderão ser ignoradas e não ter seu status atualizado. Essas versões também serão incluídas no mapa `failedVersions` com um `errorCode` de`SKIPPED`.
Na implementação atual do `update-package-versions-status`, se uma ou mais versões não puderem ter seu status alterado, todas as outras versões serão ignoradas. Ou seja, todas as versões são atualizadas com sucesso ou nenhuma versão é atualizada. Esse comportamento não é garantido no contrato da API; no futuro, algumas versões podem ser bem-sucedidas, enquanto outras falham em uma única chamada para `update-package-versions-status`.
O exemplo de comando a seguir inclui uma falha na atualização do status da versão causada por uma incompatibilidade na revisão da versão do pacote. Essa falha na atualização faz com que outra chamada de atualização de status da versão seja ignorada.
```
aws codeartifact update-package-versions-status --domain my_domain
--domain-owner 111122223333 --repository my_repo
--format npm --package chalk
--version-revisions "4.1.0=25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ=,4.0.0=E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc="
--versions 4.1.0 4.0.0 --target-status Archived
```
Exemplo de saída:
```
{
"successfulVersions": {},
"failedVersions": {
"4.0.0": {
"errorCode": "SKIPPED",
"errorMessage": "version 4.0.0 is skipped"
},
"4.1.0": {
"errorCode": "MISMATCHED_REVISION",
"errorMessage": "current revision: 25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ4=, expected revision: 25/UjBleHs1DZewk+zozoeqH/R80Rc9gL1P8vbzVMJ="
}
}
}
```
## Descartar as versões do pacote
O status do `Disposed` pacote tem um comportamento semelhante ao`Archived`, exceto que os ativos do pacote serão excluídos permanentemente CodeArtifact para que a conta do proprietário do domínio não seja mais cobrada pelo armazenamento de ativos. Consulte mais informações sobre o status da versão do pacote em [Satus da versão do pacote](packages-overview.md#package-version-status). Para alterar o status de uma versão do pacote para `Disposed`, use o comando `dispose-package-versions`. Esse recurso é separado de `update-package-versions-status` porque o descarte de uma versão do pacote não é reversível. Como os ativos do pacote serão excluídos, o status da versão não pode ser alterado de volta para `Archived`, `Unlisted` ou `Published`. A única ação que pode ser executada em uma versão de pacote que foi descartada é excluí-la usando o comando `delete-package-versions`.
Para chamar `dispose-package-versions` com sucesso, a entidade principal do IAM que está chamando deve ter a permissão `codeartifact:DisposePackageVersions` no recurso do pacote.
O comportamento do comando `dispose-package-versions` é semelhante a `update-package-versions-status`, incluindo o comportamento das opções `--version-revisions ` e `--expected-status` descritas nas seções de [revisão da versão](#update-status-specify-package-version-revision) e [status esperado](#using-expected-status). Por exemplo, o comando a seguir tenta descartar uma versão do pacote, mas falha devido a um status esperado incompatível.
```
aws codeartifact dispose-package-versions —domain my_domain --domain-owner 111122223333
--repository my_repo --format npm --package chalk --versions 4.0.0
--expected-status Unlisted
```
Exemplo de saída:
```
{
"successfulVersions": {},
"failedVersions": {
"4.0.0": {
"errorCode": "MISMATCHED_STATUS",
"errorMessage": "current status: Published, expected status: Unlisted"
}
}
}
```
Se o mesmo comando for executado outra vez com um `--expected-status` de `Published`, o descarte será bem-sucedido.
```
aws codeartifact dispose-package-versions —domain my_domain --domain-owner 111122223333
--repository my_repo --format npm --package chalk --versions 4.0.0
--expected-status Published
```
Exemplo de saída:
```
{
"successfulVersions": {
"4.0.0": {
"revision": "E3lhBp0RObRTut4pkjV5c1AQGkgSA7Oxtil6hMMzelc=",
"status": "Disposed"
}
},
"failedVersions": {}
}
```
# Editar controles de origem do pacote
Em AWS CodeArtifact, as versões do pacote podem ser adicionadas a um repositório publicando-as diretamente, retirando-as de um repositório upstream ou ingerindo-as de um repositório público externo. Permitir que versões de um pacote sejam adicionadas por publicação direta e ingestão de repositórios públicos torna você vulnerável a um ataque de substituição de dependências. Para obter mais informações, consulte [Ataques de substituição de dependências](dependency-substitution-attacks.md). Para se proteger contra um ataque de substituição de dependência, você pode configurar os controles de origem do pacote em um pacote em um repositório para limitar como as versões desse pacote podem ser adicionadas ao repositório.
A configuração dos controles de origem do pacote deve ser considerada por qualquer equipe que queira permitir que novas versões de pacotes diferentes venham tanto de fontes internas, como publicação direta, quanto de fontes externas, como repositórios públicos. Por padrão, os controles de origem do pacote serão configurados com base em como a primeira versão de um pacote é adicionada ao repositório. Para obter informações sobre as configurações de controle de origem do pacote e seus valores padrão, consulte [Configurações de controle de origem do pacote](#package-origin-control-settings).
Para remover o registro do pacote depois de usar a operação da API `put-package-origin-configuration`, use `delete-package` (consulte [Excluir um pacote ou uma versão do pacote](delete-package.md)).
## Cenários comuns de controle de acesso a pacotes
Esta seção inclui alguns cenários comuns quando uma versão de pacote é adicionada a um CodeArtifact repositório. As configurações de controle de origem do pacote serão definidas para novos pacotes, dependendo de como a primeira versão do pacote for adicionada.
Nos cenários a seguir, um *pacote interno* é um pacote publicado diretamente de um gerenciador de pacotes no seu repositório, como um pacote que você ou sua equipe cria e mantém. Um *pacote externo* é um pacote que existe em um repositório público que pode ser ingerido em seu repositório com uma conexão externa.
**Uma versão de pacote externo é publicada para um pacote interno existente**
Nesse cenário, considere um pacote interno, *packageA*. Sua equipe publica a primeira versão do pacote do *PackageA em um repositório*. CodeArtifact Como essa é a primeira versão desse pacote, as configurações de controle de origem do pacote são automaticamente definidas como **Publicar: Permitir** e **Upstream: Bloquear**. Depois que o pacote existe no seu repositório, um pacote com o mesmo nome é publicado em um repositório público conectado ao seu CodeArtifact repositório. Isso pode ser uma tentativa de ataque de substituição de dependência contra o pacote interno ou pode ser apenas uma coincidência. Independentemente disso, os controles de origem do pacote são configurados para bloquear a ingestão da nova versão externa para se protegerem contra um possível ataque.
Na imagem a seguir, o *RepoA* é seu CodeArtifact repositório com uma conexão externa com um repositório público. Seu repositório contém as versões 1.1 e 2.1 de *packageA*, mas a versão 3.0 é publicada no repositório público. Normalmente, *repoA* poderia ingerir a versão 3.0 depois que o pacote fosse solicitado por um gerenciador de pacotes. Como a ingestão de pacotes está definida como **Bloquear**, a versão 3.0 não é ingerida em seu CodeArtifact repositório e não está disponível para gerenciadores de pacotes conectados a ele.
![\[Gráfico simples mostrando uma nova versão de pacote externo sendo bloqueada de um repositório público.\]](http://docs.aws.amazon.com/pt_br/codeartifact/latest/ug/images/package-origin-controls-one.png)
**Uma versão de pacote interno é publicada para um pacote externo existente**
Nesse cenário, um pacote, *packageB*, existe externamente em um repositório público que você conectou ao seu repositório. Quando um gerenciador de pacotes conectado ao seu repositório solicita *packageB*, a versão do pacote é ingerida no seu repositório a partir do repositório público. Como esta é a primeira versão do pacote de *packageB* adicionada ao seu repositório, as configurações de origem do pacote são definidas como **Publicação: BLOQUEAR** e **Upstream: PERMITIR**. Mais tarde, você tenta publicar uma versão com o mesmo nome de pacote no repositório. Ou você não conhece o pacote público e está tentando publicar um pacote não relacionado com o mesmo nome, ou está tentando publicar uma versão corrigida ou está tentando publicar diretamente a versão exata do pacote que já existe externamente. CodeArtifact rejeitará a versão que você está tentando publicar, mas permitirá que você anule explicitamente a rejeição e publique a versão, se necessário.
Na imagem a seguir, o *RepoA* é seu CodeArtifact repositório com uma conexão externa com um repositório público. Seu repositório contém a versão 3.0 que foi ingerida do repositório público. Você deseja publicar a versão 1.1 no seu repositório. Normalmente, você poderia publicar a versão 1.2 em *repoA*, mas como a publicação está definida como **Bloquear**, a versão 1.2 não pode ser publicada.
![\[Gráfico simples mostrando uma nova versão de pacote externo sendo bloqueada de um repositório público.\]](http://docs.aws.amazon.com/pt_br/codeartifact/latest/ug/images/package-origin-controls-two.png)
**Publicar uma versão corrigida de um pacote externo existente**
Nesse cenário, um pacote, *packageB*, existe externamente em um repositório público que você conectou ao seu repositório. Quando um gerenciador de pacotes conectado ao seu repositório solicita *packageB*, a versão do pacote é ingerida no seu repositório a partir do repositório público. Como esta é a primeira versão do pacote de *packageB* adicionada ao seu repositório, as configurações de origem do pacote são definidas como **Publicação: BLOQUEAR** e **Upstream: PERMITIR**. Sua equipe decide que precisa publicar versões corrigidas desse pacote no repositório. Para poder publicar versões de pacotes diretamente, sua equipe altera as configurações de controle de origem do pacote para **Publicação: PERMITIR** e **Upstream: BLOQUEAR**. Agora, as versões desse pacote podem ser publicadas diretamente no seu repositório e ingeridas de repositórios públicos. Depois que sua equipe publica as versões corrigidas do pacote, ela reverte as configurações de origem do pacote para **Publicação: BLOQUEAR** e **Upstream: PERMITIR**.
## Configurações de controle de origem do pacote
Com os controles de origem do pacote, você pode configurar como as versões do pacote podem ser adicionadas a um repositório. As listas a seguir incluem as configurações e os valores disponíveis do controle de origem do pacote.
**nota**
As configurações e valores disponíveis são diferentes ao configurar os controles de origem em grupos de pacotes. Para obter mais informações, consulte [Controles de origem do grupo de pacotes](package-group-origin-controls.md).
**Publicar**
Essa configuração define se as versões do pacote podem ser publicadas diretamente no repositório usando gerenciadores de pacotes ou ferramentas similares.
+ **PERMITIR**: as versões do pacote podem ser publicadas diretamente.
+ **BLOCK**: as versões do pacote não podem ser publicadas diretamente.
**Upstream**
Essa configuração define se as versões do pacote podem ser ingeridas de repositórios externos públicos ou retidas de repositórios upstream quando solicitadas por um gerenciador de pacotes.
+ **PERMITIR**: Qualquer versão do pacote pode ser retida de outros CodeArtifact repositórios configurados como repositórios upstream ou ingerida de uma fonte pública com uma conexão externa.
+ **BLOCO**: As versões do pacote não podem ser retidas de outros CodeArtifact repositórios configurados como repositórios upstream ou ingeridas de uma fonte pública com uma conexão externa.
## Configurações de controle de origem do pacote padrão
As configurações de controle de origem do pacote padrão são definidas com base nas configurações de controle de origem do grupo de pacotes associado ao pacote. Para obter mais informações sobre grupos de pacotes e controles de origem de grupos de pacotes, consulte [Trabalhar com grupos de pacotes no CodeArtifact](package-groups.md) e [Controles de origem do grupo de pacotes](package-group-origin-controls.md).
Se um pacote estiver associado a um grupo de pacotes com configurações de restrição de `ALLOW` para cada tipo de restrição, os controles de origem de pacote padrão serão baseados em como a primeira versão desse pacote é adicionada ao repositório.
+ Se a primeira versão do pacote for publicada diretamente por um gerenciador de pacotes, as configurações serão **Publicação: PERMITIR** e **Upstream: BLOQUEAR**.
+ Se a primeira versão do pacote for ingerida de uma fonte pública, as configurações serão **Publicação: BLOQUEAR** e **Upstream: PERMITIR**.
**nota**
Pacotes que existiam em CodeArtifact repositórios antes de maio de 2022 terão os controles de origem de pacote padrão de **Publish: ALLOW e Upstream****:** ALLOW. Os controles de origem do pacote devem ser definidos manualmente para esses pacotes. Os valores padrão atuais foram definidos em novos pacotes desde aquela época e começaram a ser aplicados quando o atributo foi lançado em 14 de julho de 2022. Para obter mais informações sobre a configuração de controles de origem de pacotes, consulte [Editar controles de origem do pacote](#edit-package-origin-controls).
Caso contrário, se um pacote estiver associado a um grupo de pacotes que tenha pelo menos uma configuração de restrição de `BLOCK` ou `ALLOW_SPECIFIC_REPOSITORIES`, as configurações de controle de origem padrão desse pacote serão definidas como **Publish: ALLOW** e **Upstream: ALLOW**.
## Como os controles de origem do pacote interagem com os controles de origem do grupo de pacotes
Como tanto os pacotes quanto os grupos de pacotes associados têm configurações de controle de origem, é importante entender como essas duas configurações diferentes interagem entre si.
A interação entre as duas configurações é que uma configuração de `BLOCK` sempre prevalece sobre uma configuração de `ALLOW`. A tabela a seguir lista alguns exemplos de configurações e suas configurações de controle de origem eficazes.
| Configuração de controle de origem do pacote | Configuração de controle de origem do grupo de pacotes | Configuração de controle de origem eficaz |
| --- | --- | --- |
| PUBLISH: ALLOWUPSTREAM: ALLOW | PUBLISH: ALLOWUPSTREAM: ALLOW | PUBLISH: ALLOWUPSTREAM: ALLOW |
| PUBLISH: BLOCKUPSTREAM: ALLOW | PUBLISH: ALLOWUPSTREAM: ALLOW | PUBLISH: BLOCKUPSTREAM: ALLOW |
| PUBLISH: ALLOWUPSTREAM: ALLOW | PUBLISH: ALLOWUPSTREAM: BLOCK | PUBLISH: ALLOWUPSTREAM: BLOCK |
Isso significa que um pacote com configurações de origem de **Publish: ALLOW** e **Upstream: ALLOW** está efetivamente adotando as configurações de controle de origem do grupo de pacotes associado.
## Editar controles de origem do pacote
Os controles de origem do pacote são configurados automaticamente com base em como a primeira versão de um pacote é adicionada ao repositório. Para obter mais informações, consulte [Configurações de controle de origem do pacote padrão](#default-package-origin-control-settings). Para adicionar ou editar controles de origem de pacote para um pacote em um CodeArtifact repositório, execute as etapas no procedimento a seguir.
**Para adicionar ou editar controles de origem do pacote (console)**
1. Abra o AWS CodeArtifact console em [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. No painel de navegação, escolha **Repositórios** e escolha o repositório que contém o pacote que você deseja editar.
1. Na tabela **Pacotes**, pesquise e selecione o pacote que você deseja editar.
1. Na página de resumo do pacote, em **Controles de origem**, escolha **Editar**.
1. Em **Editar controles de origem**, escolha os controles de origem do pacote que deseja definir para esse pacote. As duas configurações de controle de origem do pacote, Publicação e Upstream, devem ser definidas ao mesmo tempo.
+ Para permitir a publicação direta de versões do pacote, em **Publicação**, escolha **Permitir**. Para bloquear a publicação de versões do pacote, escolha **Bloquear**.
+ Para permitir a ingestão de pacotes de repositórios externos e a extração de pacotes de repositórios upstream, em **Fontes upstream**, escolha **Permitir**. Para bloquear toda a ingestão e extração de versões de pacotes de repositórios externos e upstream, escolha **Bloquear**.
**Para adicionar ou editar controles de origem do pacote (AWS CLI)**
1. Caso contrário, configure o AWS CLI seguindo as etapas em[Configurando com AWS CodeArtifact](get-set-up-for-codeartifact.md).
1. Use o comando `put-package-origin-configuration` para adicionar ou editar controles de origem do pacote. Substitua os campos a seguir:
+ *my\$1domain*Substitua pelo CodeArtifact domínio que contém o pacote que você deseja atualizar.
+ *my\$1repo*Substitua pelo CodeArtifact repositório que contém o pacote que você deseja atualizar.
+ *npm*Substitua pelo formato do pacote que você deseja atualizar.
+ *my\$1package*Substitua pelo nome do pacote que você deseja atualizar.
+ Substitua *ALLOW* e *BLOCK* com as configurações de controle de origem do pacote desejadas.
```
aws codeartifact put-package-origin-configuration --domain my_domain \
--repository my_repo --format npm --package my_package \
--restrictions publish=ALLOW,upstream=BLOCK
```
## Repositórios de publicação e upstream
CodeArtifact não permite a publicação de versões de pacotes que estejam presentes em repositórios upstream acessíveis ou em repositórios públicos. Por exemplo, suponha que você queira publicar um pacote Maven `com.mycompany.mypackage:1.0` em um repositório `myrepo` e `myrepo` tenha um repositório upstream com uma conexão externa com Maven Central. Considere os seguintes cenários:
1. As configurações de controle de origem do pacote em `com.mycompany.mypackage` são **Publicação: PERMITIR** e **Upstream: PERMITIR**. Se `com.mycompany.mypackage:1.0` estiver presente no repositório upstream ou no Maven Central, CodeArtifact rejeita qualquer tentativa de publicar nele `myrepo` com um erro de conflito 409. Você ainda pode publicar uma versão diferente, como `com.mycompany.mypackage:1.1`.
1. As configurações de controle de origem do pacote em `com.mycompany.mypackage` são **Publicação: PERMITIR** e **Upstream: BLOQUEAR**. Você pode publicar qualquer versão do `com.mycompany.mypackage` no seu repositório que ainda não exista porque as versões do pacote não estão acessíveis.
1. As configurações de controle de origem do pacote em `com.mycompany.mypackage` são **Publicação: BLOQUEAR** e **Upstream: PERMITIR**. Você não pode publicar nenhuma versão do pacote diretamente no seu repositório.