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á.
# Trabalhar com grupos de pacotes no CodeArtifact
Os *grupos de pacotes* podem ser usados para aplicar configurações a vários pacotes que correspondam a um padrão definido usando o formato, o namespace e o nome do pacote. Você pode usar grupos de pacotes para configurar de forma mais conveniente os controles de origem de pacotes para vários pacotes. Os controles de origem de pacotes são usados para bloquear ou permitir a ingestão ou publicação de novas versões de pacotes, protegendo os usuários de ações maliciosas conhecidas como ataques de substituição de dependências.
Cada domínio no CodeArtifact contém automaticamente um grupo de pacotes raiz. Esse grupo de pacotes raiz, `/*`, contém todos os pacotes e permite, por padrão, que versões de pacotes entrem em repositórios no domínio independentemente do tipo de origem. O grupo de pacotes raiz pode ser modificado, mas não pode ser excluído.
O recurso de configuração de grupo de pacotes opera de maneira eventualmente consistente ao criar um novo grupo de pacotes ou excluir um grupo de pacotes existente. Isso significa que, ao criar ou excluir um grupo de pacotes, os controles de origem serão aplicados aos pacotes associados esperados, mas com algum atraso devido ao eventual comportamento consistente. O tempo para alcançar a consistência eventual depende do número de grupos de pacotes no domínio, bem como do número de pacotes no domínio. Pode haver um breve período em que os controles de origem não sejam refletidos imediatamente nos pacotes associados após a criação ou exclusão de um grupo de pacotes.
Além disso, as atualizações nos controles de origem do grupo de pacotes entram em vigor quase imediatamente. Diferentemente da criação ou exclusão de grupos de pacotes, as alterações nos controles de origem de um grupo de pacotes existente são refletidas nos pacotes associados sem o mesmo atraso.
Os tópicos a seguir contêm informações sobre grupos de pacotes no AWS CodeArtifact.
**Topics**
+ [Criar um grupo de pacotes](create-package-group.md)
+ [Visualizar ou editar um grupo de pacotes](view-edit-package-group.md)
+ [Excluir um grupo de pacotes](delete-package-group.md)
+ [Controles de origem do grupo de pacotes](package-group-origin-controls.md)
+ [Sintaxe de definição de grupos de pacotes e comportamento de correspondência](package-group-definition-syntax-matching-behavior.md)
+ [Marcar um grupo de pacotes](package-group-tags.md)
# Criar um grupo de pacotes
É possível criar um grupo de pacotes usando o console do CodeArtifact, a AWS Command Line Interface (AWS CLI) ou o CloudFormation. Consulte mais informações sobre o gerenciamento de grupos de pacotes do CodeArtifact com o CloudFormation em [Criação de recursos do CodeArtifact com AWS CloudFormation](cloudformation-codeartifact.md).
## Criar um grupo de pacotes (console)
1. Abra o console do AWS CodeArtifact em [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. No painel de navegação, selecione **Domínios** e escolha o domínio no qual você deseja criar um grupo de pacotes.
1. Selecione **Grupos de pacotes** e clique em **Criar grupo de pacotes**.
1. Em **Definição de grupos de pacotes**, insira a definição do grupo de pacotes para o seu grupo de pacotes. A definição do grupo de pacotes determina quais pacotes estão associados ao grupo. Você pode inserir a definição do grupo de pacotes manualmente com texto ou usar o modo visual para fazer seleções e a definição do grupo de pacotes será criada automaticamente.
1. Para usar o modo visual para criar a definição do grupo de pacotes:
1. Selecione **Visual** para alternar para o modo visual.
1. Em **Formato do pacote**, escolha o formato dos pacotes a serem associados a esse grupo.
1. Em **Namespace (escopo)**, escolha os critérios de namespace a serem correspondidos.
+ **Igual a**: corresponda exatamente o namespace especificado. Se escolhido, insira o namespace a ser correspondido.
+ **Em branco**: corresponda pacotes sem namespace.
+ **Começa com a palavra**: corresponda namespaces que começam com uma palavra especificada. Se escolhido, insira a palavra de prefixo a ser correspondida. Para obter mais informações sobre palavras e limites de palavras, consulte [Palavras, limites de palavras e correspondência de prefixos](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Todos**: corresponda pacotes em todos os namespaces.
1. Se a opção **Igual a**, **Em branco** ou **Começa com a palavra** estiver selecionada, em **Nome do pacote**, escolha os critérios do nome do pacote a serem correspondidos.
+ **Exatamente igual a**: corresponda exatamente o nome do pacote especificado. Se escolhido, insira o nome do pacote a ser correspondido.
+ **Começa com o prefixo**: corresponda pacotes que começam com o prefixo especificado.
+ **Começa com a palavra**: corresponda pacotes que começam com uma palavra especificada. Se escolhido, insira a palavra de prefixo a ser correspondida. Para obter mais informações sobre palavras e limites de palavras, consulte [Palavras, limites de palavras e correspondência de prefixos](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Todos**: corresponda todos os pacotes.
1. Clique em **Próximo** para revisar a definição.
1. Para inserir a definição do grupo de pacotes com texto:
1. Clique em **Texto** para alternar para o modo de texto.
1. Em **Definição do grupo de pacotes**, insira a definição do grupo de pacotes. Para obter mais informações sobre a sintaxe de definição de grupo de pacotes, consulte [Sintaxe de definição de grupos de pacotes e comportamento de correspondência](package-group-definition-syntax-matching-behavior.md).
1. Clique em **Próximo** para revisar a definição.
1. Em **Revisar definição**, revise os pacotes que serão incluídos no novo grupo de pacotes com base na definição fornecida anteriormente. Após a revisão, clique em **Próximo**.
1. Em **Informações do grupo de pacotes**, opcionalmente, adicione uma descrição e e-mail de contato para o grupo de pacotes. Escolha **Próximo**.
1. Em **Controles de origem de pacotes**, configure os controles de origem a serem aplicados aos pacotes no grupo. Para obter mais informações sobre controles de origem do grupo de pacotes, consulte [Controles de origem do grupo de pacotes](package-group-origin-controls.md).
1. Selecione **Criar grupo de pacotes**.
## Criar um grupo de pacotes (AWS CLI)
Use o comando `create-package-group` para criar um grupo de pacotes no seu domínio. Para a opção `--package-group`, insira a definição do grupo de pacotes que determina quais pacotes estão associados ao grupo. Para obter mais informações sobre a sintaxe de definição de grupo de pacotes, consulte [Sintaxe de definição de grupos de pacotes e comportamento de correspondência](package-group-definition-syntax-matching-behavior.md).
Caso não tenha feito isso, configure a AWS CLI seguindo as etapas em[Configurando com AWS CodeArtifact](get-set-up-for-codeartifact.md).
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group '/nuget/*' \
--domain-owner 111122223333 \
--contact-info contact@email.com \
--description "a new package group" \
--tags key=key1,value=value1
```
# Visualizar ou editar um grupo de pacotes
Você pode ver uma lista de todos os grupos de pacotes, ver detalhes de um grupo de pacotes específico ou editar os detalhes ou a configuração de um grupo de pacotes usando o console CodeArtifact ou a AWS Command Line Interface (AWS CLI).
## Visualizar ou editar um grupo de pacotes (console)
1. Abra o console do AWS CodeArtifact em [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. No painel de navegação, selecione **Domínios** e escolha o domínio que contém o grupo de pacotes que você deseja visualizar ou editar.
1. Selecione **Grupos de pacotes** e escolha o grupo de pacotes que você deseja visualizar ou editar.
1. Em **Detalhes**, visualize informações sobre o grupo de pacotes, incluindo seu grupo principal, descrição, ARN, e-mail de contato e controles de origem do pacote.
1. Em **Subgrupos**, veja uma lista de grupos de pacotes que têm esse grupo como grupo principal. Os grupos de pacotes dessa lista podem herdar as configurações desse grupo de pacotes. Para obter mais informações, consulte [Hierarquia de grupos de pacotes e especificidade de padrões](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. Em **Pacotes**, visualize os pacotes que pertencem a esse grupo de pacotes com base na definição do grupo de pacotes. Na coluna **Força**, você pode ver a força da associação do pacote. Para obter mais informações, consulte [Hierarquia de grupos de pacotes e especificidade de padrões](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. Para editar as informações do grupo de pacotes, selecione **Editar grupo de pacotes**.
1. Em **Informações**, atualize as informações de contato ou a descrição do grupo de pacotes. Você não pode editar a definição de um grupo de pacotes.
1. Em **Controles de origem do grupo de pacotes**, atualize as configurações de controle de origem do grupo de pacotes, que determinam como os pacotes associados podem entrar nos repositórios no domínio. Para obter mais informações, consulte [Controles de origem do grupo de pacotes](package-group-origin-controls.md).
## Visualizar ou editar um grupo de pacotes (AWS CLI)
Use os comandos a seguir para visualizar ou editar grupos de pacotes com a AWS CLI. Caso não tenha feito isso, configure a AWS CLI seguindo as etapas em[Configurando com AWS CodeArtifact](get-set-up-for-codeartifact.md).
Para visualizar todos os grupos de pacotes em um domínio, use o comando `list-package-groups`.
```
aws codeartifact list-package-groups \
--domain my_domain \
--domain-owner 111122223333
```
Para visualizar os detalhes sobre um grupo de pacotes, use o comando `describe-package-group`. Para obter mais informações sobre as definições de grupo de pacotes, consulte [Sintaxe de definição de grupos de pacotes e exemplos](package-group-definition-syntax-matching-behavior.md#package-group-definition-syntax-examples).
```
aws codeartifact describe-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*'
```
Para visualizar os grupos de pacotes secundários de um grupo de pacotes, use o comando `list-sub-package-groups`.
```
aws codeartifact list-sub-package-groups \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
```
Para visualizar o grupo de pacotes associado a um pacote, use o comando `get-associated-package-group`. Você deve usar o nome e o namespace normalizados do pacote para os formatos de pacote NuGet, Python e Swift. Para obter mais informações sobre como os nomes e namespaces dos pacotes são normalizados, consulte a documentação de normalização de nomes do [NuGet](nuget-name-normalization.md), [Python](python-name-normalization.md) e [Swift](swift-name-normalization.md).
```
aws codeartifact get-associated-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--format npm \
--package packageName \
--namespace scope
```
Para editar um grupo de pacotes, use o comando `update-package-group`. Esse comando é usado para atualizar as informações de contato ou a descrição de um grupo de pacotes. Para obter informações sobre as configurações de controle de origem do grupo de pacotes e sobre como adicioná-las ou editá-las, consulte [Controles de origem do grupo de pacotes](package-group-origin-controls.md). Para obter mais informações sobre as definições de grupo de pacotes, consulte [Sintaxe de definição de grupos de pacotes e exemplos](package-group-definition-syntax-matching-behavior.md#package-group-definition-syntax-examples)
```
aws codeartifact update-package-group \
--domain my_domain \
--package-group '/nuget/*' \
--domain-owner 111122223333 \
--contact-info contact@email.com \
--description "updated package group description"
```
# Excluir um grupo de pacotes
Você pode excluir um grupo de pacotes usando o console do CodeArtifact ou a AWS Command Line Interface (AWS CLI).
Observe o seguinte comportamento ao excluir grupos de pacote:
+ O grupo de pacotes raiz, `/*`, não pode ser excluído.
+ Os pacotes e as versões de pacotes associados a esse grupo de pacotes não são excluídos.
+ Quando um grupo de pacotes é excluído, os grupos de pacotes secundários diretos se tornam secundários do grupo de pacotes principal direto do grupo de pacotes. Portanto, se algum dos grupos secundários estiver herdando alguma configuração do grupo principal, essas configurações poderão mudar.
## Excluir um grupo de pacotes (console)
1. Abra o console do AWS CodeArtifact em [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. No painel de navegação, selecione **Domínios** e escolha o domínio que contém o grupo de pacotes que você deseja visualizar ou editar.
1. Selecione **Grupos de pacotes**.
1. Escolha o grupo de pacotes que deseja excluir e clique em **Excluir**.
1. Insira excluir no campo e clique em **Excluir**.
## Excluir um grupo de pacotes (AWS CLI)
Para excluir um grupo de pacotes, use o comando `delete-package-group`.
```
aws codeartifact delete-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*'
```
# Controles de origem do grupo de pacotes
Os controles de origem do pacote são usados para configurar como as versões do pacote podem entrar em um domínio. Você pode configurar controles de origem em um grupo de pacotes para configurar como as versões de cada pacote associado ao grupo de pacotes podem entrar em repositórios específicos no domínio.
As configurações de controle de origem do grupo de pacotes consistem no seguinte:
+ [Configurações de restrição](#package-group-origin-control-settings-restrictions): essas configurações definem se os pacotes podem entrar em um repositório no CodeArtifact por meio de publicação, upstreams internos ou repositórios públicos externos.
+ [Listas de repositórios permitidos](#package-group-origin-control-settings-repositories): cada configuração de restrição pode ser definida para permitir repositórios específicos. Se uma configuração de restrição for definida para permitir repositórios específicos, essa restrição terá uma lista correspondente de repositórios permitidos.
**nota**
As configurações de controle de origem para grupos de pacotes são ligeiramente diferentes das configurações de controle de origem para pacotes individuais. Para obter mais informações sobre as configurações de controle de origem para pacotes, consulte [Configurações de controle de origem do pacote](package-origin-controls.md#package-origin-control-settings).
## Configurações de restrição
As configurações de restrição das configurações de controle de origem de um grupo de pacotes determinam como os pacotes associados a esse grupo podem entrar nos repositórios no domínio.
### PUBLISH
A configuração `PUBLISH` define se as versões do pacote podem ser publicadas diretamente em qualquer repositório no domínio usando gerenciadores de pacotes ou ferramentas similares.
+ **ALLOW**: as versões do pacote podem ser publicadas diretamente em todos os repositórios.
+ **BLOCK**: as versões do pacote não podem ser publicadas diretamente em nenhum repositório.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES**: as versões do pacote só podem ser publicadas diretamente nos repositórios especificados na lista de repositórios permitidos para publicação.
+ **INHERIT**: a configuração `PUBLISH` é herdada do primeiro grupo de pacotes principal com uma configuração que não é `INHERIT`.
### EXTERNAL\$1UPSTREAM
A configuração `EXTERNAL_UPSTREAM` define se as versões do pacote podem ser ingeridas de repositórios externos públicos quando solicitadas por um gerenciador de pacotes. Para ver uma lista dos repositórios externos, consulte [Repositórios de conexão externa compatíveis](external-connection.md#supported-public-repositories).
+ **ALLOW**: qualquer versão do pacote pode ser ingerida em todos os repositórios de uma fonte pública com uma conexão externa.
+ **BLOCK**: as versões do pacote não podem ser ingeridas em nenhum repositório de uma fonte pública com uma conexão externa.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES**: as versões do pacote só podem ser ingeridas de uma fonte pública em repositórios especificados na lista de repositórios permitidos para upstreams externos.
+ **INHERIT**: a configuração `EXTERNAL_UPSTREAM` é herdada do primeiro grupo de pacotes principal com uma configuração que não é `INHERIT`.
### INTERNAL\$1UPSTREAM
A configuração `INTERNAL_UPSTREAM` define se as versões do pacote podem ser retidas de repositórios upstream internos no mesmo domínio do CodeArtifact quando solicitadas por um gerenciador de pacotes.
+ **ALLOW**: qualquer versão do pacote pode ser retida de outros repositórios do CodeArtifact configurados como repositórios upstream.
+ **BLOCK**: as versões do pacote não podem ser retidas de outros repositórios do CodeArtifact configurados como repositórios upstream.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES**: as versões do pacote só podem ser retidas de outros repositórios do CodeArtifact configurados como repositórios upstream em repositórios especificados na lista de repositórios permitidos para upstreams internos.
+ **INHERIT**: a configuração `INTERNAL_UPSTREAM` é herdada do primeiro grupo de pacotes principal com uma configuração que não é `INHERIT`.
## Listas de repositórios permitidos
Quando uma configuração de restrição é definida como `ALLOW_SPECIFIC_REPOSITORIES`, o grupo de pacotes passa a incluir uma lista de repositórios permitidos, que contém os repositórios permitidos para essa configuração de restrição. Portanto, um grupo de pacotes contém de 0 a 3 listas de repositórios permitidos, uma para cada configuração definida como `ALLOW_SPECIFIC_REPOSITORIES`.
Ao adicionar um repositório à lista de repositórios permitidos de um grupo de pacotes, é necessário especificar em qual lista adicioná-lo.
As possíveis listas de repositórios permitidos são as seguintes:
+ `EXTERNAL_UPSTREAM`: permite ou bloqueia a ingestão de versões de pacotes de repositórios externos no repositório adicionado.
+ `INTERNAL_UPSTREAM`: permite ou bloqueia a extração de versões de pacotes de outro repositório do CodeArtifact no repositório adicionado.
+ `PUBLISH`: permite ou bloqueia a publicação direta de versões de pacotes dos gerenciadores de pacotes no repositório adicionado.
## Editar configurações de controle de origem do grupo de pacotes
Para adicionar ou editar controles de origem de um grupo de pacotes, execute as etapas no procedimento a seguir. Para obter informações sobre as configurações de controle de origem do grupo de pacotes, consulte [Configurações de restrição](#package-group-origin-control-settings-restrictions) e [Listas de repositórios permitidos](#package-group-origin-control-settings-repositories).
**Como adicionar ou editar controles de origem do grupo de pacotes (CLI)**
1. Caso não tenha feito isso, configure a AWS CLI seguindo as etapas em[Configurando com AWS CodeArtifact](get-set-up-for-codeartifact.md).
1. Use o comando `update-package-group-origin-configuration` para adicionar ou editar controles de origem do pacote.
+ Para `--domain`, insira o domínio do CodeArtifact que contém o grupo de pacotes que deseja atualizar.
+ Para `--domain-owner`, insira o número da conta do proprietário do domínio.
+ Para `--package-group`, insira o grupo de pacotes que deseja atualizar.
+ Para `--restrictions`, insira pares de chave-valor que representam as restrições de controle de origem.
+ Para `--add-allowed-repositories`, insira um objeto JSON contendo o tipo de restrição e o nome do repositório para adicionar à lista correspondente de repositórios permitidos para a restrição.
+ Para `--remove-allowed-repositories`, insira um objeto JSON contendo o tipo de restrição e o nome do repositório a serem removidos da lista correspondente de repositórios permitidos para a restrição.
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
--restrictions INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo \
--remove-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2
```
O exemplo a seguir adiciona várias restrições e vários repositórios em um comando.
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
--restrictions PUBLISH=BLOCK,EXTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES,INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2 \
--remove-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=my_repo2
```
## Exemplos de configuração do controle de origem do grupo de pacotes
Os exemplos a seguir mostram configurações de controle de origem de pacotes para cenários comuns de gerenciamento de pacotes.
### Permitir que pacotes com nomes privados sejam publicados, mas não ingeridos
Este cenário provavelmente é comum no gerenciamento de pacotes:
+ Permita que pacotes com nomes privados sejam publicados em repositórios em seu domínio por meio de gerenciadores de pacotes e impeça que sejam ingeridos em repositórios em seu domínio por meio de repositórios públicos externos.
+ Permita que todos os outros pacotes sejam ingeridos em repositórios em seu domínio por meio de repositórios públicos externos e impeça que sejam publicados em repositórios em seu domínio por meio de gerenciadores de pacotes.
Para fazer isso, você deve configurar um grupo de pacotes com um padrão que inclua os nomes privados e as configurações de origem de **PUBLISH: ALLOW**, **EXTERNAL\$1UPSTREAM: BLOCK** e **INTERNAL\$1UPSTREAM: ALLOW**. Isso garantirá que pacotes com nomes privados possam ser publicados diretamente, mas não possam ser ingeridos de repositórios externos.
Os seguintes comandos da AWS CLI criam e configuram um grupo de pacotes com configurações de restrição de origem que correspondem ao comportamento desejado:
Para criar o grupo de pacotes:
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group /npm/space/anycompany~ \
--domain-owner 111122223333 \
--contact-info contact@email.com | URL \
--description "my package group"
```
Para atualizar a configuração de origem do grupo de pacotes:
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/npm/space/anycompany~' \
--restrictions PUBLISH=ALLOW,EXTERNAL_UPSTREAM=BLOCK,INTERNAL_UPSTREAM=ALLOW
```
### Permitir a ingestão de repositórios externos por meio de um repositório
Neste cenário, seu domínio tem vários repositórios. Desses repositórios, `repoA` tem uma conexão upstream com `repoB`, que tem uma conexão externa com o repositório público, `npmjs.com`, conforme mostrado:
`repoA --> repoB --> npmjs.com`
Você deseja permitir a ingestão de pacotes de um grupo de pacotes específico, `/npm/space/anycompany~` de `npmjs.com` para `repoA`, mas somente por meio de `repoB`. Você também deseja bloquear a ingestão de pacotes associados ao grupo de pacotes em qualquer outro repositório em seu domínio e bloquear a publicação direta de pacotes com gerenciadores de pacotes. Para fazer isso, você cria e configura o grupo de pacotes da seguinte forma:
Configurações de restrição de origem de **PUBLISH: BLOCK**, **EXTERNAL\$1UPSTREAM: ALLOW\$1SPECIFIC\$1REPOSITORIES** e **INTERNAL\$1UPSTREAM: ALLOW\$1SPECIFIC\$1REPOSITORIES**.
`repoA` e `repoB` adicionados à lista apropriada de repositórios permitidos:
+ `repoA` deve ser adicionado à lista `INTERNAL_UPSTREAM`, pois obterá pacotes de seu upstream interno, `repoB`.
+ `repoB` deve ser adicionado à lista `EXTERNAL_UPSTREAM`, pois obterá pacotes do repositório externo, `npmjs.com`.
Os seguintes comandos da AWS CLI criam e configuram um grupo de pacotes com configurações de restrição de origem que correspondem ao comportamento desejado:
Para criar o grupo de pacotes:
```
aws codeartifact create-package-group \
--domain my_domain \
--package-group /npm/space/anycompany~ \
--domain-owner 111122223333 \
--contact-info contact@email.com | URL \
--description "my package group"
```
Para atualizar a configuração de origem do grupo de pacotes:
```
aws codeartifact update-package-group-origin-configuration \
--domain my_domain \
--domain-owner 111122223333 \
--package-group /npm/space/anycompany~ \
--restrictions PUBLISH=BLOCK,EXTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES,INTERNAL_UPSTREAM=ALLOW_SPECIFIC_REPOSITORIES \
--add-allowed-repositories originRestrictionType=INTERNAL_UPSTREAM,repositoryName=repoA originRestrictionType=EXTERNAL_UPSTREAM,repositoryName=repoB
```
## Como as configurações de controle de origem do grupo de pacotes interagem com as configurações de controle de origem do pacote
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. Para obter mais informações sobre a interação entre as configurações, consulte [Como os controles de origem do pacote interagem com os controles de origem do grupo de pacotes](package-origin-controls.md#package-origin-controls-interaction-package-groups).
# Sintaxe de definição de grupos de pacotes e comportamento de correspondência
Este tópico contém informações sobre como definir grupos de pacotes, comportamento de correspondência de padrões, força de associação de pacotes e hierarquia de grupos de pacotes.
**Contents**
+ [Sintaxe de definição de grupos de pacotes e exemplos](#package-group-definition-syntax-examples)
+ [Definição e normalização de grupos de pacotes](#package-group-definition-syntax-examples-normalization)
+ [Namespaces nas definições de grupos de pacotes](#package-group-definition-syntax-examples-namespaces)
+ [Hierarquia de grupos de pacotes e especificidade de padrões](#package-group-hierarchy-pattern-specificity)
+ [Palavras, limites de palavras e correspondência de prefixos](#package-group-word-boundary-prefix)
+ [Diferenciação de letras maiúsculas e minúsculas](#package-group-case-sensitivity)
+ [Correspondência forte e fraca](#package-group-strong-and-weak-match)
+ [Variações adicionais](#package-group-additional-variations)
## Sintaxe de definição de grupos de pacotes e exemplos
A sintaxe padrão para definir grupos de pacotes segue de perto a formatação dos caminhos de pacotes. Um caminho de pacote é criado com base nos componentes de coordenadas de um pacote (formato, namespace e nome), adicionando uma barra no início e separando cada um dos componentes com uma barra. Por exemplo, o caminho do pacote npm chamado *anycompany-ui-components* no namespace *space* é */npm/space/anycompany-ui-components*.
Um padrão de grupo de pacotes segue a mesma estrutura de um caminho de pacote, exceto que os componentes que não são especificados como parte da definição do grupo são omitidos e o padrão é finalizado com um sufixo. O sufixo incluído determina o comportamento correspondente do padrão, da seguinte forma:
+ Um sufixo `$` corresponderá à coordenada completa do pacote.
+ Um sufixo `~` corresponderá a um prefixo.
+ Um sufixo `*` corresponderá a todos os valores do componente definido anteriormente.
Veja abaixo exemplos de padrões para cada uma das combinações permitidas:
1. Todos os formatos de pacote: `/*`
1. Formato de pacote específico: `/npm/*`
1. Formato e prefixo do namespace do pacote: `/maven/com.anycompany~`
1. Formato e namespace do pacote: `/npm/space/*`
1. Formato, namespace e prefixo do nome do pacote: `/npm/space/anycompany-ui~`
1. Formato, namespace e nome do pacote: `/maven/org.apache.logging.log4j/log4j-core$`
Conforme mostrado nos exemplos acima, o sufixo `~` é adicionado ao final de um namespace ou nome para representar uma correspondência de prefixo, e `*` é adicionado após uma barra quando usado para corresponder a todos os valores do próximo componente no caminho (todos os formatos, todos os namespaces ou todos os nomes).
### Definição e normalização de grupos de pacotes
O CodeArtifact normaliza os nomes de pacotes NuGet, Python e Swift, e normaliza os namespaces dos pacotes Swift antes de armazená-los. O CodeArtifact usa esses nomes normalizados ao corresponder pacotes com definições de grupos de pacotes. Portanto, grupos de pacotes que contêm um namespace ou nome nesses formatos devem usar o namespace e o nome normalizados. Para obter mais informações sobre como os nomes e namespaces dos pacotes são normalizados, consulte a documentação de normalização de nomes do [NuGet](nuget-name-normalization.md), [Python](python-name-normalization.md) e [Swift](swift-name-normalization.md).
### Namespaces nas definições de grupos de pacotes
Para pacotes ou formatos de pacotes sem um namespace (Python e NuGet), os grupos de pacotes não devem conter um namespace. A definição do grupo de pacotes para esses grupos de pacotes contém uma seção de namespace em branco. Por exemplo, o caminho para o pacote Python chamado *requests* é */python//requests*.
Para pacotes ou formatos de pacotes com um namespace (Maven, genérico e Swift), o namespace deverá ser incluído se o nome do pacote estiver incluído. Para o formato de pacote Swift, o namespace normalizado do pacote será usado. Para obter mais informações sobre como os namespaces de pacote Swift são normalizados, consulte [Normalização do nome e do namespace do pacote Swift](swift-name-normalization.md).
## Hierarquia de grupos de pacotes e especificidade de padrões
Os pacotes que estão “em” ou “associados a” um grupo de pacotes são pacotes com um caminho de pacote que corresponde ao padrão do grupo, mas não corresponde ao padrão de um grupo mais específico. Por exemplo, dados os grupos de pacotes `/npm/*` e `/npm/space/*`, o caminho do pacote */npm//react* está associado ao primeiro grupo (`/npm/*`), enquanto */npm/space/aui.components* e */npm/space/amplify-ui-core* estão associados ao segundo grupo (`/npm/space/*`). Embora um pacote possa corresponder a vários grupos, cada pacote está associado somente a um único grupo, a correspondência mais específica, e somente a configuração desse grupo se aplica ao pacote.
Quando um caminho de pacote corresponde a vários padrões, o padrão “mais específico” pode ser considerado o padrão de correspondência mais longo. Alternativamente, o padrão mais específico é aquele que corresponde a um subconjunto próprio dos pacotes que correspondem ao padrão menos específico. Em exemplo anterior, todo pacote que corresponde a `/npm/space/*` também corresponde a `/npm/*`, mas o inverso não é verdadeiro, o que torna `/npm/space/*` o padrão mais específico porque é um subconjunto próprio de `/npm/*`. Como um grupo é um subconjunto de outro grupo, cria-se uma hierarquia, na qual `/npm/space/*` é um subgrupo do grupo principal, `/npm/*`.
Embora somente a configuração mais específica do grupo de pacotes se aplique a um pacote, esse grupo pode ser configurado para herdar da configuração do grupo principal.
## Palavras, limites de palavras e correspondência de prefixos
Antes de discutir a correspondência de prefixos, vamos definir alguns termos-chave:
+ Uma *palavra* é uma letra ou número seguido por zero ou mais letras, números ou caracteres diacríticos (como acentos, tremas etc.).
+ O *limite de uma palavra* ocorre no final de uma palavra, quando um caractere que não é uma palavra é atingido. Caracteres que não são palavras são caracteres de pontuação, como `.`, `-` e `_`.
Especificamente, o padrão regex para uma palavra é `[\p{L}\p{N}][\p{L}\p{N}\p{M}]*`, que pode ser detalhado da seguinte forma:
+ `\p{L}` representa qualquer letra.
+ `\p{N}` representa qualquer número.
+ `\p{M}` representa qualquer caractere diacrítico, como acentos, tremas etc.
Portanto, `[\p{L}\p{N}]` representa um número ou letra, e `[\p{L}\p{N}\p{M}]*` representa zero ou mais letras, números ou caracteres diacríticos, e um limite de palavra está no final de cada correspondência desse padrão regex.
**nota**
A correspondência de limites de palavras é baseada nessa definição de “palavra”. Não é baseada em palavras definidas em um dicionário ou em camelCase. Por exemplo, não há limite de palavras em `oneword` ou `OneWord`.
Agora que a palavra e o limite da palavra estão definidos, podemos usá-los para descrever a correspondência de prefixos no CodeArtifact. Para indicar uma correspondência de prefixo no limite de uma palavra, um caractere de correspondência (`~`) é usado após um caractere de palavra. Por exemplo, o padrão `/npm/space/foo~` corresponde aos caminhos do pacote `/npm/space/foo` e `/npm/space/foo-bar`, mas não `/npm/space/food` ou `/npm/space/foot`.
É necessário usar um curinga (`*`) em vez de `~` após um caractere que não seja uma palavra, como no padrão `/npm/*`.
## Diferenciação de letras maiúsculas e minúsculas
As definições de grupos de pacotes diferenciam maiúsculas de minúsculas, o que significa que padrões que diferem somente por maiúsculas e minúsculas podem existir como grupos de pacotes separados. Por exemplo, um usuário pode criar grupos de pacotes separados com os padrões `/npm//AsyncStorage$`, `/npm//asyncStorage$` e `/npm//asyncstorage$` para os três pacotes separados que existem no Registro Público do npm: *AsyncStorage*, *asyncStorage*, *asyncstorage*, que diferem somente por maiúsculas e minúsculas.
Embora a distinção entre maiúsculas e minúsculas seja importante, o CodeArtifact ainda associa pacotes a um grupo de pacotes se o pacote tiver uma variação do padrão que difere por maiúsculas e minúsculas. Se um usuário criar o grupo de pacotes `/npm//AsyncStorage$` sem criar os outros dois grupos mostrados acima, todas as variações de maiúsculas e minúsculas do nome *AsyncStorage*, incluindo *asyncStorage* e *asyncstorage*, serão associadas ao grupo de pacotes. Mas, conforme descrito na próxima seção, [Correspondência forte e fraca](#package-group-strong-and-weak-match), essas variações serão tratadas de forma diferente do *AsyncStorage*, que corresponde exatamente ao padrão.
## Correspondência forte e fraca
As informações na seção anterior, [Diferenciação de letras maiúsculas e minúsculas](#package-group-case-sensitivity), afirmam que os grupos de pacotes diferenciam maiúsculas de minúsculas e, em seguida, explicam que não diferenciam. Isso ocorre porque as definições de grupos de pacotes no CodeArtifact têm um conceito de correspondência forte (ou correspondência exata) e correspondência fraca (ou correspondência de variação). Uma correspondência forte é quando o pacote corresponde exatamente ao padrão, sem qualquer variação. Uma correspondência fraca ocorre quando o pacote corresponde a uma variação do padrão, como letras maiúsculas e minúsculas diferentes. O comportamento de correspondência fraca impede que pacotes que são variações do padrão de um grupo de pacotes sejam acumulados em um grupo de pacotes mais geral. Quando um pacote é uma variação (correspondência fraca) do padrão do grupo de correspondência mais específico, o pacote é associado ao grupo, mas é bloqueado em vez de aplicar a configuração de controle de origem do grupo, impedindo que novas versões do pacote sejam retiradas de upstreams ou publicadas. Esse comportamento reduz o risco de ataques à cadeia de suprimentos resultantes da confusão de dependências de pacotes com nomes quase idênticos.
Para ilustrar um comportamento de correspondência fraca, suponha que o grupo de pacotes `/npm/*` permita a ingestão e bloqueie a publicação. Um grupo de pacotes mais específico, `/npm//anycompany-spicy-client$`, está configurado para bloquear a ingestão e permitir a publicação. O pacote chamado *anycompany-spicy-client* é uma correspondência forte do grupo de pacotes, que permite que versões de pacotes sejam publicadas e bloqueia a ingestão de versões de pacotes. A única forma permitida de publicar o nome do pacote com maiúsculas e minúsculas é *anycompany-spicy-client*, pois é uma correspondência forte com o padrão de definição do pacote. Uma variação diferente, como *AnyCompany-spicy-client*, é bloqueada para publicação porque é uma correspondência fraca. Mais importante ainda, o grupo de pacotes bloqueia a ingestão de todas as variações de maiúsculas e minúsculas, não somente do nome em minúsculas usado no padrão, reduzindo o risco de um ataque de confusão de dependências.
## Variações adicionais
Além das diferenças entre maiúsculas e minúsculas, a correspondência fraca também ignora as diferenças em sequências de traços `-`, pontos `.`, sublinhados `_` e caracteres que podem ser confundidos (como caracteres de aparência semelhante de alfabetos diferentes). Durante a normalização usada para correspondência fraca, o CodeArtifact realiza a conversão de maiúsculas e minúsculas (semelhante à conversão para minúsculas), substitui sequências de caracteres de traço, ponto e sublinhado por um único ponto e normaliza caracteres que podem ser confundidos.
A correspondência fraca trata traços, pontos e sublinhados como equivalentes, mas não os ignora completamente. Isso significa que *foo-bar*, *foo.bar*, *foo..bar* e *foo\$1bar* são todos equivalentes de correspondência fraca, mas *foobar* não é. Embora vários repositórios públicos implementem etapas para evitar esses tipos de variações, a proteção fornecida pelos repositórios públicos não torna esse recurso de grupos de pacotes desnecessário. Por exemplo, repositórios públicos como o Registro Público do npm só evitarão novas variações do pacote chamado *my-package* se *my-package* já estiver publicado nele. Se *my-package* for um pacote interno e o grupo de pacotes `/npm//my-package$` for criado permitindo a publicação e bloqueando a ingestão, você provavelmente não desejará publicar *my-package* no Registro Público do npm para evitar que uma variante como *my.package* seja permitida.
Embora alguns formatos de pacote, como o Maven, tratem esses caracteres de forma diferente (o Maven trata `.` como um separador de hierarquia de namespace, mas não `-` ou `_`), algo como *com.act-on* ainda pode ser confundido com *com.act.on*.
**nota**
Observe que sempre que várias variações são associadas a um grupo de pacotes, um administrador pode criar um novo grupo de pacotes para uma variação específica para configurar um comportamento diferente para essa variação.
# Marcar um grupo de pacotes no CodeArtifact
As tags são pares de chave-valor associados a recursos da AWS. Você pode aplicar tags aos grupos de pacotes no CodeArtifact. Para obter informações sobre a atribuição de tags do recurso do CodeArtifact, casos de uso, restrições de chave e valor de tag, além de tipos de recursos compatíveis, consulte [Marcando atributos](tag-resources.md).
Você pode usar a CLI para especificar tags ao criar um grupo de pacotes ou adicionar, remover ou atualizar o valor das tags de um grupo de pacotes existente.
## Grupos de pacotes de tag (CLI)
É possível usar a CLI para gerenciar tags de grupos de pacotes.
Caso não tenha feito isso, configure a AWS CLI seguindo as etapas em[Configurando com AWS CodeArtifact](get-set-up-for-codeartifact.md).
**dica**
Para adicionar tags, você deve fornecer o nome do recurso da Amazon (ARN) do grupo de pacotes. Para obter o ARN do grupo de pacotes, execute o comando `describe-package-group`:
```
aws codeartifact describe-package-group \
--domain my_domain \
--package-group /npm/scope/anycompany~ \
--query packageGroup.arn
```
**Topics**
+ [Adicionar tags a um grupo de pacotes (CLI)](#package-group-tags-add-cli)
+ [Exibir tags para um grupo de pacotes (CLI)](#package-group-tags-list-cli)
+ [Editar tags para um grupo de pacotes (CLI)](#package-group-tags-edit-cli)
+ [Remover tags de um grupo de pacotes (CLI)](#package-group-tags-delete-cli)
### Adicionar tags a um grupo de pacotes (CLI)
É possível adicionar tags aos grupos de pacotes quando eles são criados ou a um grupo de pacotes existente. Para obter informações sobre como adicionar tags a um grupo de pacotes ao criá-lo, consulte [Criar um grupo de pacotes](create-package-group.md).
Para adicionar uma tag a um grupo de pacotes existente com a AWS CLI, no terminal ou na linha de comando, execute o comando **tag-resource**, especificando o nome do recurso da Amazon (ARN) do grupo de pacotes ao qual você deseja adicionar tags, bem como a chave e o valor da tag que deseja adicionar. Para obter informações sobre ARNs de grupos de pacotes, consulte [Package group ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Você pode adicionar mais de uma tag a um grupo de pacotes. Por exemplo, para marcar um grupo de pacotes, */npm/scope/anycompany\$1*, com duas tags, uma chave de tag chamada *key1* com o valor de tag de *value1* e uma chave de tag chamada *key2* com o valor de tag de *value2*:
```
aws codeartifact tag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tags key=key1,value=value1 key=key2,value=value2
```
Se for bem-sucedido, este comando não terá saída.
### Exibir tags para um grupo de pacotes (CLI)
Siga estas etapas para usar a AWS CLI para visualizar as tags da AWS para um grupo de pacotes. Se não foram adicionadas tags, a lista retornará vazia.
No terminal ou na linha de comando, execute o comando **list-tags-for-resource** com o nome do recurso da Amazon (ARN) do grupo de recursos. Para obter informações sobre ARNs de grupos de pacotes, consulte [Package group ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Por exemplo, para visualizar uma lista de chaves e valores de tag para um grupo de pacotes, */npm/scope/anycompany\$1*, nomeado com um valor de ARN de `arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~`
```
aws codeartifact list-tags-for-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~
```
Se houver êxito, o comando retornará informações semelhantes às seguintes:
```
{
"tags": {
"key1": "value1",
"key2": "value2"
}
}
```
### Editar tags para um grupo de pacotes (CLI)
Siga estas etapas para usar a AWS CLI para editar uma tag para um grupo de pacotes. Você pode alterar o valor para uma chave existente ou adicionar outra chave. Você também pode remover tags de um grupo de pacotes, como mostrado na próxima seção.
No terminal ou na linha de comando, execute o comando **tag-resource**, especificando o ARN do grupo de pacotes em que deseja atualizar uma tag e especifique a chave e o valor da tag. Para obter informações sobre ARNs de grupos de pacotes, consulte [Package group ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
```
aws codeartifact tag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tags key=key1,value=newvalue1
```
Se for bem-sucedido, este comando não terá saída.
### Remover tags de um grupo de pacotes (CLI)
Siga estas etapas para usar a AWS CLI para remover uma tag de um grupo de pacotes.
**nota**
Se você excluir um grupo de pacotes, todas as associações de tag serão removidas do grupo de pacotes excluído. Não é necessário remover as tags antes de excluir um grupo de pacotes.
No terminal ou na linha de comando, execute o comando **untag-resource**, especificando o ARN do grupo de pacotes no qual você deseja remover tags e a chave da tag que deseja remover. Para obter informações sobre ARNs de grupos de pacotes, consulte [Package group ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Por exemplo, para remover várias tags em um grupo de pacotes, */npm/scope/anycompany \$1*, com as chaves de tag *key1* e *key2*:
```
aws codeartifact untag-resource \
--resource-arn arn:aws:codeartifact:us-west-2:123456789012:package-group/my_domain/npm/scope/anycompany~ \
--tag-keys key1 key2
```
Se for bem-sucedido, este comando não terá saída. Após remover as tags, você pode exibir as tags restantes no grupo de pacotes usando o comando `list-tags-for-resource`.