Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation de groupes de packages dans CodeArtifact
*Les groupes de packages* peuvent être utilisés pour appliquer une configuration à plusieurs packages qui correspondent à un modèle défini en utilisant le format du package, l'espace de noms du package et le nom du package. Vous pouvez utiliser des groupes de packages pour configurer plus facilement les contrôles d'origine des packages pour plusieurs packages. Les contrôles d'origine des packages sont utilisés pour bloquer ou autoriser l'ingestion ou la publication de nouvelles versions de packages, ce qui protège les utilisateurs contre les actions malveillantes connues sous le nom d'attaques de substitution de dépendances.
Chaque domaine contient CodeArtifact automatiquement un groupe de packages racine. Ce groupe de packages racine contient tous les packages et permet par défaut aux versions de packages d'entrer dans les référentiels du domaine à partir de tous les types d'origine. `/*` Le groupe de packages racine peut être modifié, mais ne peut pas être supprimé.
La fonctionnalité de configuration des groupes de packages fonctionne finalement de manière cohérente lors de la création d'un nouveau groupe de packages ou de la suppression d'un groupe de packages existant. Cela signifie que lors de la création ou de la suppression d'un groupe de packages, les contrôles d'origine seront appliqués aux packages associés attendus, mais avec un certain retard en raison du comportement cohérent éventuel. Le temps nécessaire pour atteindre une cohérence éventuelle dépend du nombre de groupes de packages dans le domaine ainsi que du nombre de packages dans le domaine. Il peut y avoir une brève période pendant laquelle les contrôles d'origine ne sont pas immédiatement reflétés sur les packages associés après la création ou la suppression d'un groupe de packages.
En outre, les mises à jour des contrôles d'origine des groupes de packages entrent en vigueur presque immédiatement. Contrairement à la création ou à la suppression de groupes de packages, les modifications apportées aux contrôles d'origine d'un groupe de packages existant sont répercutées sur les packages associés sans le même délai.
Ces rubriques contiennent des informations sur les groupes de packages dans AWS CodeArtifact.
**Topics**
+ [Création d'un groupe de packages](create-package-group.md)
+ [Afficher ou modifier un groupe de packages](view-edit-package-group.md)
+ [Supprimer un groupe de packages](delete-package-group.md)
+ [Contrôles d'origine des groupes de packages](package-group-origin-controls.md)
+ [Syntaxe de définition du groupe de packages et comportement de correspondance](package-group-definition-syntax-matching-behavior.md)
+ [Marquer un groupe de packages](package-group-tags.md)
# Création d'un groupe de packages
Vous pouvez créer un groupe de packages à l'aide de la CodeArtifact console, du AWS Command Line Interface (AWS CLI) ou CloudFormation. Pour plus d'informations sur la gestion des groupes de CodeArtifact packages avec CloudFormation, consultez[Création de CodeArtifact ressources avec AWS CloudFormation](cloudformation-codeartifact.md).
## Création d'un groupe de packages (console)
1. Ouvrez la AWS CodeArtifact console sur [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Dans le volet de navigation, choisissez **Domains**, puis le domaine dans lequel vous souhaitez créer un groupe de packages.
1. Choisissez **Groupes de packages**, puis choisissez **Créer un groupe de packages**.
1. Dans **Définition du groupe de packages**, entrez la définition du groupe de packages pour votre groupe de packages. La définition du groupe de packages détermine quels packages sont associés au groupe. Vous pouvez saisir la définition du groupe de packages manuellement avec du texte, ou vous pouvez utiliser le mode visuel pour effectuer des sélections et la définition du groupe de packages sera créée automatiquement.
1. Pour utiliser le mode visuel afin de créer la définition du groupe de packages :
1. Choisissez **Visual** pour passer en mode visuel.
1. Dans **Format du package**, choisissez le format des packages à associer à ce groupe.
1. Dans **Namespace (Scope)**, choisissez les critères d'espace de noms auxquels vous souhaitez répondre.
+ **Égal** : correspond exactement à l'espace de noms spécifié. Si cette option est sélectionnée, entrez l'espace de noms correspondant.
+ **Vide** : associe les packages sans espace de noms.
+ **Commence par un mot** : fait correspondre les espaces de noms commençant par un mot spécifique. Si cette option est sélectionnée, entrez le mot de préfixe correspondant. Pour plus d'informations sur les mots et les limites des mots, voir[Mots, limites de mots et correspondance de préfixes](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Tout** : Faites correspondre les packages dans tous les espaces de noms.
1. Si l'**option** **Egale, Blank** ou **Commence par un mot** est sélectionnée, dans **Nom du package**, choisissez les critères de nom du package auxquels vous souhaitez répondre.
+ **Exactement égal** : correspond exactement au nom du package spécifié. Si c'est le cas, entrez le nom du package correspondant.
+ **Commence par le préfixe** : fait correspondre les packages qui commencent par le préfixe spécifié.
+ **Commence par un mot** : fait correspondre les packages qui commencent par un mot spécifique. Si cette option est sélectionnée, entrez le mot de préfixe correspondant. Pour plus d'informations sur les mots et les limites des mots, voir[Mots, limites de mots et correspondance de préfixes](package-group-definition-syntax-matching-behavior.md#package-group-word-boundary-prefix).
+ **Tous** : Faites correspondre tous les packages.
1. Choisissez **Next** pour revoir la définition.
1. Pour saisir la définition du groupe de packages avec du texte :
1. Choisissez **Texte** pour passer en mode texte.
1. Dans **Définition du groupe de packages**, entrez la définition du groupe de packages. Pour plus d'informations sur la syntaxe de définition des groupes de packages, consultez[Syntaxe de définition du groupe de packages et comportement de correspondance](package-group-definition-syntax-matching-behavior.md).
1. Choisissez **Next** pour revoir la définition.
1. Dans **Réviser la définition**, passez en revue les packages qui seront inclus dans le nouveau groupe de packages en fonction de la définition fournie précédemment. Après avoir passé en revue, choisissez **Next**.
1. Dans **Informations sur le groupe de packages**, ajoutez éventuellement une description et une adresse e-mail de contact pour le groupe de packages. Choisissez **Suivant**.
1. Dans **Contrôles d'origine des packages**, configurez les contrôles d'origine à appliquer aux packages du groupe. Pour plus d'informations sur les contrôles d'origine des groupes de packages, consultez[Contrôles d'origine des groupes de packages](package-group-origin-controls.md).
1. Choisissez **Créer un groupe de packages**.
## Création d'un groupe de packages (AWS CLI)
Utilisez la `create-package-group` commande pour créer un groupe de packages dans votre domaine. Pour l'`--package-group`option, entrez la définition du groupe de packages qui détermine les packages associés au groupe. Pour plus d'informations sur la syntaxe de définition des groupes de packages, consultez[Syntaxe de définition du groupe de packages et comportement de correspondance](package-group-definition-syntax-matching-behavior.md).
Si ce n'est pas le cas, configurez le AWS CLI en suivant les étapes décrites dans[Configuration avec 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
```
# Afficher ou modifier un groupe de packages
Vous pouvez consulter la liste de tous les groupes de packages, afficher les détails d'un groupe de packages spécifique ou modifier les détails ou la configuration d'un groupe de packages à l'aide de la CodeArtifact console ou du AWS Command Line Interface (AWS CLI).
## Afficher ou modifier un groupe de packages (console)
1. Ouvrez la AWS CodeArtifact console sur [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Dans le volet de navigation, sélectionnez **Domaines**, puis choisissez le domaine qui contient le groupe de packages que vous souhaitez afficher ou modifier.
1. Choisissez **Groupes de packages**, puis choisissez le groupe de packages que vous souhaitez afficher ou modifier.
1. Dans **Détails, consultez les** informations relatives au groupe de packages, notamment son groupe parent, sa description, son ARN, son adresse e-mail de contact et les contrôles d'origine des packages.
1. Dans **Sous-groupes**, consultez la liste des groupes de packages dont ce groupe est le groupe parent. Les groupes de packages de cette liste peuvent hériter des paramètres de ce groupe de packages. Pour de plus amples informations, veuillez consulter [Hiérarchie des groupes de packages et spécificité du modèle](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. Dans **Packages**, visualisez les packages appartenant à ce groupe de packages en fonction de la définition du groupe de packages. Dans la colonne **Force**, vous pouvez voir la force de l'association de packages. Pour de plus amples informations, veuillez consulter [Hiérarchie des groupes de packages et spécificité du modèle](package-group-definition-syntax-matching-behavior.md#package-group-hierarchy-pattern-specificity).
1. Pour modifier les informations du groupe de packages, choisissez **Modifier le groupe de packages**.
1. Dans **Informations**, mettez à jour la description ou les coordonnées du groupe de packages. Vous ne pouvez pas modifier la définition d'un groupe de packages.
1. Dans **Contrôles d'origine des groupes de packages**, mettez à jour les paramètres de contrôle d'origine du groupe de packages, qui déterminent comment les packages associés peuvent entrer dans les référentiels du domaine. Pour de plus amples informations, veuillez consulter [Contrôles d'origine des groupes de packages](package-group-origin-controls.md).
## Afficher ou modifier un groupe de packages (AWS CLI)
Utilisez les commandes suivantes pour afficher ou modifier des groupes de packages avec le AWS CLI. Si ce n'est pas le cas, configurez le AWS CLI en suivant les étapes décrites dans[Configuration avec AWS CodeArtifact](get-set-up-for-codeartifact.md).
Pour afficher tous les groupes de packages d'un domaine, utilisez la `list-package-groups` commande.
```
aws codeartifact list-package-groups \
--domain my_domain \
--domain-owner 111122223333
```
Pour afficher les détails d'un groupe de packages, utilisez la `describe-package-group` commande. Pour plus d'informations sur les définitions de groupes de packages, consultez[Syntaxe et exemples de définition de groupes de packages](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/*'
```
Pour afficher les groupes de packages enfants d'un groupe de packages, utilisez la `list-sub-package-groups` commande.
```
aws codeartifact list-sub-package-groups \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*' \
```
Pour afficher le groupe de packages associé à un package, utilisez la `get-associated-package-group` commande. Vous devez utiliser le nom de package et l'espace de noms normalisés pour les NuGet formats de package Python et Swift. Pour plus d'informations sur la façon dont les noms de packages et les espaces de noms sont normalisés, consultez la [NuGet](nuget-name-normalization.md)documentation de normalisation des noms [Python](python-name-normalization.md) et [Swift](swift-name-normalization.md).
```
aws codeartifact get-associated-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--format npm \
--package packageName \
--namespace scope
```
Pour modifier un groupe de packages, utilisez la `update-package-group` commande. Cette commande est utilisée pour mettre à jour les coordonnées ou la description d'un groupe de packages. Pour plus d'informations sur les paramètres de contrôle d'origine des groupes de packages, ainsi que sur leur ajout ou leur modification, consultez[Contrôles d'origine des groupes de packages](package-group-origin-controls.md). Pour plus d'informations sur les définitions de groupes de packages, voir [Syntaxe et exemples de définition de groupes de packages](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"
```
# Supprimer un groupe de packages
Vous pouvez supprimer un groupe de packages à l'aide de la CodeArtifact console ou du AWS Command Line Interface (AWS CLI).
Notez le comportement suivant lors de la suppression de groupes de packages :
+ Le groupe de packages racine ne peut pas être supprimé. `/*`
+ Les packages et les versions de packages associés à ce groupe de packages ne sont pas supprimés.
+ Lorsqu'un groupe de packages est supprimé, les groupes de packages enfants directs deviennent les enfants du groupe de packages parent direct du groupe de packages. Par conséquent, si l'un des groupes d'enfants hérite des paramètres du parent, ces paramètres peuvent changer.
## Supprimer un groupe de packages (console)
1. Ouvrez la AWS CodeArtifact console sur [https://console.aws.amazon.com/codesuite/codeartifact/home](https://console.aws.amazon.com/codesuite/codeartifact/home).
1. Dans le volet de navigation, sélectionnez **Domaines**, puis choisissez le domaine qui contient le groupe de packages que vous souhaitez afficher ou modifier.
1. Choisissez **Package groups**.
1. Choisissez le groupe de packages que vous souhaitez supprimer, puis cliquez **sur Supprimer**.
1. Entrez Supprimer dans le champ et choisissez **Supprimer**.
## Supprimer un groupe de packages (AWS CLI)
Pour supprimer un groupe de packages, utilisez la `delete-package-group` commande.
```
aws codeartifact delete-package-group \
--domain my_domain \
--domain-owner 111122223333 \
--package-group '/nuget/*'
```
# Contrôles d'origine des groupes de packages
Les contrôles d'origine des packages sont utilisés pour configurer la manière dont les versions de package peuvent entrer dans un domaine. Vous pouvez configurer des contrôles d'origine sur un groupe de packages afin de configurer la manière dont les versions de chaque package associé au groupe de packages peuvent entrer dans les référentiels spécifiés du domaine.
Les paramètres de contrôle de l'origine des groupes de packages sont les suivants :
+ [Paramètres de restriction](#package-group-origin-control-settings-restrictions): Ces paramètres définissent si les packages peuvent entrer dans un référentiel CodeArtifact depuis la publication, depuis des flux internes ou depuis des référentiels publics externes.
+ [Listes de référentiels autorisés](#package-group-origin-control-settings-repositories): Chaque paramètre de restriction peut être défini pour autoriser des référentiels spécifiques. Si un paramètre de restriction est défini pour autoriser des référentiels spécifiques, cette restriction sera associée à une liste de référentiels autorisés correspondante.
**Note**
Les paramètres de contrôle d'origine pour les groupes de packages sont légèrement différents des paramètres de contrôle d'origine pour les packages individuels. Pour plus d'informations sur les paramètres de contrôle d'origine des packages, consultez[Paramètres de contrôle de l'origine des packages](package-origin-controls.md#package-origin-control-settings).
## Paramètres de restriction
Les paramètres de restriction des paramètres de contrôle d'origine d'un groupe de packages déterminent la manière dont les packages associés à ce groupe peuvent entrer dans les référentiels du domaine.
### PUBLISH
Le `PUBLISH` paramètre définit si les versions de package peuvent être publiées directement dans n'importe quel référentiel du domaine à l'aide de gestionnaires de packages ou d'outils similaires.
+ **AUTORISER** : les versions des packages peuvent être publiées directement dans tous les référentiels.
+ **BLOCK** : Les versions des packages ne peuvent être publiées directement dans aucun référentiel.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES : Les** versions des packages ne peuvent être publiées directement que dans les référentiels spécifiés dans la liste des référentiels autorisés pour la publication.
+ **INHERIT** : le `PUBLISH` paramètre est hérité du premier groupe de packages parent avec un paramètre qui ne l'est pas`INHERIT`.
### EXTERNAL\$1AMONT
Le `EXTERNAL_UPSTREAM` paramètre définit si les versions des packages peuvent être ingérées à partir de référentiels publics externes à la demande d'un gestionnaire de packages. Pour obtenir la liste des référentiels externes pris en charge, consultez[Référentiels de connexions externes pris en charge](external-connection.md#supported-public-repositories).
+ **AUTORISER** : Toute version de package peut être ingérée dans tous les référentiels à partir d'une source publique avec une connexion externe.
+ **BLOCK** : Les versions du package ne peuvent être ingérées dans aucun référentiel à partir d'une source publique dotée d'une connexion externe.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES : Les** versions des packages peuvent uniquement être ingérées à partir d'une source publique dans les référentiels spécifiés dans la liste des référentiels autorisés pour les flux ascendants externes.
+ **INHERIT** : le `EXTERNAL_UPSTREAM` paramètre est hérité du premier groupe de packages parent avec un paramètre qui ne l'est pas`INHERIT`.
### INTERNE\$1AMONT
Le `INTERNAL_UPSTREAM` paramètre définit si les versions des packages peuvent être conservées à partir des référentiels internes en amont du même CodeArtifact domaine à la demande d'un gestionnaire de packages.
+ **AUTORISER** : Toute version de package peut être conservée à partir d'autres CodeArtifact référentiels configurés en tant que référentiels en amont.
+ **BLOCK** : Les versions des packages ne peuvent pas être conservées à partir d'autres CodeArtifact référentiels configurés comme référentiels en amont.
+ **ALLOW\$1SPECIFIC\$1REPOSITORIES : Les** versions des packages ne peuvent être conservées que depuis CodeArtifact d'autres référentiels configurés comme référentiels en amont vers des référentiels spécifiés dans la liste des référentiels autorisés pour les référentiels internes en amont.
+ **INHERIT** : le `INTERNAL_UPSTREAM` paramètre est hérité du premier groupe de packages parent avec un paramètre qui ne l'est pas`INHERIT`.
## Listes de référentiels autorisés
Lorsqu'un paramètre de restriction est configuré comme suit`ALLOW_SPECIFIC_REPOSITORIES`, le groupe de packages contient une liste de référentiels autorisés qui contient la liste des référentiels autorisés pour ce paramètre de restriction. Par conséquent, un groupe de packages contient de 0 à 3 listes de référentiels autorisés, une pour chaque paramètre configuré comme`ALLOW_SPECIFIC_REPOSITORIES`.
Lorsque vous ajoutez un dépôt à la liste des référentiels autorisés d'un groupe de packages, vous devez spécifier à quelle liste de référentiels autorisés l'ajouter.
Les listes de référentiels autorisés possibles sont les suivantes :
+ `EXTERNAL_UPSTREAM`: autorisez ou bloquez l'ingestion de versions de packages provenant de référentiels externes dans le référentiel ajouté.
+ `INTERNAL_UPSTREAM`: autorisez ou bloquez l'extraction de versions de packages depuis un autre CodeArtifact référentiel dans le référentiel ajouté.
+ `PUBLISH`: autorisez ou bloquez la publication directe des versions de packages depuis les gestionnaires de packages vers le référentiel ajouté.
## Modification des paramètres de contrôle d'origine des groupes de packages
Pour ajouter ou modifier des contrôles d'origine pour un groupe de packages, effectuez les étapes de la procédure suivante. Pour plus d'informations sur les paramètres de contrôle d'origine des groupes de packages, reportez-vous [Paramètres de restriction](#package-group-origin-control-settings-restrictions) aux sections et[Listes de référentiels autorisés](#package-group-origin-control-settings-repositories).
**Pour ajouter ou modifier des contrôles d'origine de groupes de packages (CLI)**
1. Si ce n'est pas le cas, configurez le AWS CLI en suivant les étapes décrites dans[Configuration avec AWS CodeArtifact](get-set-up-for-codeartifact.md).
1. Utilisez la `update-package-group-origin-configuration` commande pour ajouter ou modifier les contrôles d'origine des packages.
+ Pour`--domain`, entrez le CodeArtifact domaine qui contient le groupe de packages que vous souhaitez mettre à jour.
+ Pour`--domain-owner`, entrez le numéro de compte du propriétaire du domaine.
+ Pour`--package-group`, entrez le groupe de packages que vous souhaitez mettre à jour.
+ Pour`--restrictions`, entrez des paires clé-valeur qui représentent les restrictions de contrôle d'origine.
+ Pour`--add-allowed-repositories`, entrez un objet JSON contenant le type de restriction et le nom du référentiel à ajouter à la liste des référentiels autorisés correspondante pour la restriction.
+ Pour`--remove-allowed-repositories`, entrez un objet JSON contenant le type de restriction et le nom du référentiel à supprimer de la liste des référentiels autorisés correspondant à la restriction.
```
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
```
L'exemple suivant ajoute plusieurs restrictions et plusieurs référentiels dans une seule commande.
```
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
```
## Exemples de configuration du contrôle d'origine des groupes de packages
Les exemples suivants présentent les configurations de contrôle de l'origine des packages pour les scénarios courants de gestion des packages.
### Autoriser la publication de packages avec des noms privés, mais pas leur ingestion
Ce scénario est probablement courant dans le domaine de la gestion des packages :
+ Autorisez la publication des packages avec des noms privés dans les référentiels de votre domaine à partir des gestionnaires de packages, et empêchez leur ingestion dans les référentiels de votre domaine à partir de référentiels publics externes.
+ Autorisez l'ingestion de tous les autres packages dans les référentiels de votre domaine à partir de référentiels publics externes, et bloquez leur publication dans les référentiels de votre domaine à partir des gestionnaires de packages.
Pour ce faire, vous devez configurer un groupe de packages avec un modèle incluant le ou les noms privés et les paramètres d'origine de **PUBLISH : ALLOW, EXTERNAL\$1UPSTREAM :** **BLOCK et **INTERNAL\$1UPSTREAM** :** ALLOW. Cela permettra de garantir que les packages avec des noms privés peuvent être publiés directement, mais ne peuvent pas être ingérés à partir de référentiels externes.
Les AWS CLI commandes suivantes créent et configurent un groupe de packages avec des paramètres de restriction d'origine correspondant au comportement souhaité :
Pour créer le groupe de packages :
```
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"
```
Pour mettre à jour la configuration d'origine du groupe de packages :
```
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
```
### Autoriser l'ingestion à partir de référentiels externes via un seul référentiel
Dans ce scénario, votre domaine possède plusieurs référentiels. Parmi ces référentiels, `repoA` dispose d'une connexion en amont à`repoB`, qui possède une connexion externe au référentiel public`npmjs.com`, comme indiqué :
`repoA --> repoB --> npmjs.com`
Vous souhaitez autoriser l'ingestion de packages provenant d'un groupe de packages spécifique, `/npm/space/anycompany~` de destination à`repoA`, mais uniquement de destination `npmjs.com` en direction`repoB`. Vous souhaitez également bloquer l'ingestion de packages associés au groupe de packages dans tout autre référentiel de votre domaine et bloquer la publication directe de packages avec les gestionnaires de packages. Pour ce faire, vous devez créer et configurer le groupe de packages comme suit :
**Paramètres de restriction d'origine pour **PUBLISH : BLOCK, EXTERNAL\$1UPSTREAM :** **ALLOW\$1SPECIFIC\$1REPOSITORIES, et INTERNAL\$1UPSTREAM : ALLOW\$1SPECIFIC\$1REPOSITORIES**.**
`repoA`et `repoB` ajoutés à la liste des référentiels autorisés appropriée :
+ `repoA`devrait être ajouté à la `INTERNAL_UPSTREAM` liste, car il obtiendra les packages depuis son amont interne,`repoB`.
+ `repoB`doit être ajouté à la `EXTERNAL_UPSTREAM` liste, car il obtiendra les packages du référentiel externe,`npmjs.com`.
Les AWS CLI commandes suivantes créent et configurent un groupe de packages avec des paramètres de restriction d'origine correspondant au comportement souhaité :
Pour créer le groupe de packages :
```
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"
```
Pour mettre à jour la configuration d'origine du groupe de packages :
```
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
```
## Comment les paramètres de contrôle d'origine des groupes de packages interagissent avec les paramètres de contrôle de l'origine des packages
Étant donné que les packages ont des paramètres de contrôle d'origine et que les groupes de packages associés ont des paramètres de contrôle d'origine, il est important de comprendre comment ces deux paramètres différents interagissent les uns avec les autres. Pour plus d'informations sur l'interaction entre les paramètres, consultez[Comment les contrôles d'origine des packages interagissent avec les contrôles d'origine des groupes de packages](package-origin-controls.md#package-origin-controls-interaction-package-groups).
# Syntaxe de définition du groupe de packages et comportement de correspondance
Cette rubrique contient des informations sur la définition des groupes de packages, le comportement de correspondance des modèles, la force des associations de packages et la hiérarchie des groupes de packages.
**Contents**
+ [Syntaxe et exemples de définition de groupes de packages](#package-group-definition-syntax-examples)
+ [Définition et normalisation des groupes de packages](#package-group-definition-syntax-examples-normalization)
+ [Espaces de noms dans les définitions de groupes de packages](#package-group-definition-syntax-examples-namespaces)
+ [Hiérarchie des groupes de packages et spécificité du modèle](#package-group-hierarchy-pattern-specificity)
+ [Mots, limites de mots et correspondance de préfixes](#package-group-word-boundary-prefix)
+ [Sensibilité à la casse](#package-group-case-sensitivity)
+ [Match fort et faible](#package-group-strong-and-weak-match)
+ [Variations supplémentaires](#package-group-additional-variations)
## Syntaxe et exemples de définition de groupes de packages
La syntaxe du modèle pour définir les groupes de packages suit de près le formatage des chemins de package. Le chemin d'un package est créé à partir des coordonnées d'un package (format, espace de noms et nom) en ajoutant une barre oblique au début et en séparant chacun des composants par une barre oblique. Par exemple, le chemin du package npm nommé *anycompany-ui-components*dans l'espace de noms est*/npm/space/anycompany**-ui-components*.
Un modèle de groupe de packages suit la même structure qu'un chemin de package, sauf que les composants qui ne sont pas spécifiés dans le cadre de la définition du groupe sont omis et que le modèle se termine par un suffixe. Le suffixe inclus détermine le comportement correspondant du modèle, comme suit :
+ Un `$` suffixe correspondra aux coordonnées complètes du colis.
+ Un `~` suffixe correspondra à un préfixe.
+ Un `*` suffixe correspondra à toutes les valeurs du composant défini précédemment.
Voici des exemples de modèles pour chacune des combinaisons autorisées :
1. Tous les formats de package : `/*`
1. Un format de package spécifique : `/npm/*`
1. Format du package et préfixe d'espace de noms : `/maven/com.anycompany~`
1. Format du package et espace de noms : `/npm/space/*`
1. Format du package, espace de noms et préfixe de nom : `/npm/space/anycompany-ui~`
1. Format, espace de noms et nom du package : `/maven/org.apache.logging.log4j/log4j-core$`
Comme le montrent les exemples ci-dessus, le `~` suffixe est ajouté à la fin d'un espace de noms ou d'un nom pour représenter une correspondance de préfixe et `*` vient après une barre oblique lorsqu'il est utilisé pour correspondre à toutes les valeurs du composant suivant dans le chemin (tous les formats, tous les espaces de noms ou tous les noms).
### Définition et normalisation des groupes de packages
CodeArtifact normalise les NuGet noms de packages Python et Swift, et normalise les espaces de noms de packages Swift avant de les stocker. CodeArtifact utilise ces noms normalisés lors de la mise en correspondance de packages avec des définitions de groupes de packages. Par conséquent, les groupes de packages contenant un espace de noms ou un nom dans ces formats doivent utiliser l'espace de noms et le nom normalisés. Pour plus d'informations sur la façon dont les noms de packages et les espaces de noms sont normalisés, consultez la [NuGet](nuget-name-normalization.md)documentation de normalisation des noms [Python](python-name-normalization.md) et [Swift](swift-name-normalization.md).
### Espaces de noms dans les définitions de groupes de packages
Pour les packages ou les formats de packages sans espace de noms (Python et NuGet), les groupes de packages ne doivent pas contenir d'espace de noms. La définition du groupe de packages pour ces groupes de packages contient une section d'espace de noms vide. Par exemple, le chemin du package Python nommé requests est **/python//requests**.
Pour les packages ou les formats de package dotés d'un espace de noms (Maven, generic et Swift), l'espace de noms doit être inclus si le nom du package est inclus. Pour le format de package Swift, l'espace de noms de package normalisé sera utilisé. Pour plus d'informations sur la façon dont les espaces de noms des packages Swift sont normalisés, consultez. [Normalisation rapide du nom du package et de l'espace de noms](swift-name-normalization.md)
## Hiérarchie des groupes de packages et spécificité du modèle
Les packages « inclus » ou « associés à » un groupe de packages sont des packages dont le chemin de package correspond au modèle du groupe mais ne correspond pas au modèle d'un groupe plus spécifique. Par exemple, étant donné les groupes de packages `/npm/*` et`/npm/space/*`, le chemin du package */npm//react* est associé au premier groupe (`/npm/*`) tandis que*/npm/space/aui.components et/npm/space/amplify**-ui-core* sont associés au second groupe (). `/npm/space/*` Même si un package peut correspondre à plusieurs groupes, chaque package n'est associé qu'à un seul groupe, la correspondance la plus spécifique, et seule la configuration de ce groupe s'applique au package.
Lorsqu'un chemin de package correspond à plusieurs modèles, le modèle « plus spécifique » peut être considéré comme le modèle correspondant le plus long. Sinon, le modèle le plus spécifique est celui qui correspond à un sous-ensemble approprié des packages correspondant au modèle le moins spécifique. Dans notre exemple précédent, chaque package correspondant correspond `/npm/space/*` également`/npm/*`, mais l'inverse n'est pas vrai, ce qui rend `/npm/space/*` le modèle plus spécifique car il s'agit d'un sous-ensemble approprié de`/npm/*`. Comme un groupe est un sous-ensemble d'un autre groupe, il crée une hiérarchie dans laquelle `/npm/space/*` se trouve un sous-groupe du groupe parent. `/npm/*`
Bien que seule la configuration du groupe de packages le plus spécifique s'applique à un package, ce groupe peut être configuré pour hériter de la configuration de son groupe parent.
## Mots, limites de mots et correspondance de préfixes
Avant de discuter de la correspondance des préfixes, définissons quelques termes clés :
+ Un *mot* est une lettre ou un chiffre suivi de zéro ou de plusieurs lettres, chiffres ou caractères de marque (tels que des accents, des trémas, etc.).
+ La *limite d'un mot* se trouve à la fin d'un mot, lorsqu'un caractère autre qu'un mot est atteint. Les caractères autres que les mots sont des caractères de ponctuation tels que `.``-`, et. `_`
Plus précisément, le modèle regex pour un mot est`[\p{L}\p{N}][\p{L}\p{N}\p{M}]*`, qui peut être décomposé comme suit :
+ `\p{L}`représente n'importe quelle lettre.
+ `\p{N}`représente un nombre quelconque.
+ `\p{M}`représente n'importe quel caractère de marque, tel que les accents, les trémas, etc.
Par conséquent, `[\p{L}\p{N}]` représente un chiffre ou une lettre, et `[\p{L}\p{N}\p{M}]*` représente zéro ou plusieurs lettres, chiffres ou caractères de marque et une limite de mot se trouve à la fin de chaque correspondance de ce modèle d'expression régulière.
**Note**
La correspondance des limites des mots est basée sur cette définition d'un « mot ». Il n'est pas basé sur des mots définis dans un dictionnaire, ou CameCase. Par exemple, il n'y a pas de limite de mots dans `oneword` ou`OneWord`.
Maintenant que le mot et la limite des mots sont définis, nous pouvons les utiliser pour décrire la correspondance des préfixes dans CodeArtifact. Pour indiquer une correspondance de préfixe sur la limite d'un mot, un caractère correspondant (`~`) est utilisé après un caractère de mot. Par exemple, le modèle `/npm/space/foo~` correspond aux chemins du package `/npm/space/foo` et`/npm/space/foo-bar`, mais pas à `/npm/space/food` ou`/npm/space/foot`.
Un caractère générique (`*`) doit être utilisé plutôt que `~` lorsque vous suivez un caractère autre qu'un mot, comme dans le modèle. `/npm/*`
## Sensibilité à la casse
Les définitions de groupes de packages font la distinction majuscules/majuscules, ce qui signifie que les modèles qui ne diffèrent que par majuscules peuvent exister en tant que groupes de packages distincts. Par exemple, un utilisateur peut créer des groupes de packages distincts avec les modèles `/npm//AsyncStorage$``/npm//asyncStorage$`, et `/npm//asyncstorage$` pour les trois packages distincts qui existent dans le registre public npm : *AsyncStorage*, *AsyncStorage, *asyncstorage** qui ne diffèrent qu'au cas par cas.
Bien que le cas soit important, associez CodeArtifact toujours les packages à un groupe de packages si le package présente une variation du modèle qui diffère au cas par cas. Si un utilisateur crée le groupe de `/npm//AsyncStorage$` packages sans créer les deux autres groupes indiqués ci-dessus, toutes les variantes majuscules du nom *AsyncStorage*, y compris *AsyncStorage* et *asyncstorage*, seront associées au groupe de packages. Mais, comme décrit dans la section suivante[Match fort et faible](#package-group-strong-and-weak-match), ces variations seront traitées différemment de *AsyncStorage*ce qui correspond exactement au modèle.
## Match fort et faible
Les informations de la section précédente indiquent que [Sensibilité à la casse](#package-group-case-sensitivity) les groupes de packages distinguent les majuscules et minuscules, puis expliquent qu'ils ne le font pas. Cela est CodeArtifact dû au fait que les définitions des groupes de packages reposent sur un concept de correspondance forte (ou correspondance exacte) et de correspondance faible (ou correspondance de variation). Une bonne correspondance se produit lorsque l'emballage correspond exactement au modèle, sans aucune variation. Une faible correspondance se produit lorsque le colis correspond à une variante du modèle, par exemple une majuscule différente. Un comportement de correspondance faible empêche les packages qui sont des variantes du modèle d'un groupe de packages de se transformer en un groupe de packages plus général. Lorsqu'un package est une variante (correspondance faible) du modèle du groupe correspondant le plus spécifique, le package est associé au groupe mais le package est bloqué au lieu d'appliquer la configuration de contrôle d'origine du groupe, empêchant ainsi toute nouvelle version du package d'être extraite des flux ascendants ou publiée. Ce comportement réduit le risque d'attaques de la chaîne d'approvisionnement résultant de la confusion des dépendances entre des packages portant des noms presque identiques.
Pour illustrer le comportement de faible correspondance, supposons que le groupe de packages `/npm/*` autorise l'ingestion et bloque la publication. Un groupe de packages plus spécifique est configuré pour bloquer l'ingestion et autoriser la publication. `/npm//anycompany-spicy-client$` Le package nommé *anycompany-spicy-client*correspond parfaitement au groupe de packages, ce qui permet de publier des versions de package et bloque l'ingestion de versions de package. La seule case du nom du package qui peut être publiée est *anycompany-spicy-client*celle qui correspond parfaitement au modèle de définition du package. La publication d'une variante différente, telle que *AnyCompany-spicy-client*, est bloquée en raison d'une faible correspondance. Plus important encore, le groupe de packages bloque l'ingestion de toutes les variantes majuscules, et pas seulement du nom en minuscules utilisé dans le modèle, réduisant ainsi le risque d'attaque par confusion des dépendances.
## Variations supplémentaires
Outre les différences majuscules/minuscules, la faible correspondance ignore également les différences entre les séquences de tirets`-`, de points`.`, de traits de soulignement `_` et de caractères confuses (tels que les caractères d'apparence similaire issus d'alphabets distincts). Lors de la normalisation utilisée pour les correspondances faibles, CodeArtifact effectue le pliage en majuscules (comme lors de la conversion en minuscules), remplace les séquences de tirets, de points et de soulignements par un seul point et normalise les caractères susceptibles de confusion.
La correspondance faible traite les tirets, les points et les traits de soulignement comme équivalents, mais ne les ignore pas complètement. *Cela signifie que *foo-bar, foo.bar**, foo.. bar* *et *foo\$1bar** sont tous des équivalents à faible correspondance, mais pas foobar.* Bien que plusieurs référentiels publics mettent en œuvre des mesures pour empêcher ces types de variations, la protection fournie par les référentiels publics ne rend pas cette fonctionnalité des groupes de packages inutile. Par exemple, les référentiels publics tels que le registre public npm n'empêcheront les nouvelles variantes du package nommé *my-package que si *my-package** y est déjà publié. Si *my-package* est un package interne et qu'un groupe de packages `/npm//my-package$` est créé pour autoriser la publication et bloquer l'ingestion, vous ne voudrez probablement pas publier *mon-package* dans le registre public npm afin d'empêcher une variante telle que *my.package* d'être autorisée.
*Bien que certains formats de package tels que Maven traitent ces caractères différemment (Maven les traite `.` comme un séparateur de hiérarchie d'espaces de noms, mais pas `-` ou`_`), des éléments tels que *com.act-on peuvent toujours être confondus avec com.act.on*.*
**Note**
Notez que chaque fois que plusieurs variantes sont associées à un groupe de packages, un administrateur peut créer un nouveau groupe de packages pour une variante spécifique afin de configurer un comportement différent pour cette variante.
# Marquer un groupe de packages dans CodeArtifact
Les balises sont des paires clé-valeur associées aux ressources AWS. Vous pouvez appliquer des balises à vos groupes de packages dans CodeArtifact. Pour plus d'informations sur le balisage CodeArtifact des ressources, les cas d'utilisation, les contraintes de clé et de valeur de balise et les types de ressources pris en charge, consultez[Balisage des ressources](tag-resources.md).
Vous pouvez utiliser la CLI pour spécifier des balises lorsque vous créez un groupe de packages ou lorsque vous ajoutez, supprimez ou mettez à jour la valeur des balises d'un groupe de packages existant.
## Groupes de packages de balises (CLI)
Vous pouvez utiliser la CLI pour gérer les balises de groupes de packages.
Si ce n'est pas le cas, configurez le AWS CLI en suivant les étapes décrites dans[Configuration avec AWS CodeArtifact](get-set-up-for-codeartifact.md).
**Astuce**
Pour ajouter des balises, vous devez fournir le nom de ressource Amazon (ARN) du groupe de packages. Pour obtenir l'ARN du groupe de packages, exécutez la `describe-package-group` commande suivante :
```
aws codeartifact describe-package-group \
--domain my_domain \
--package-group /npm/scope/anycompany~ \
--query packageGroup.arn
```
**Topics**
+ [Ajouter des balises à un groupe de packages (CLI)](#package-group-tags-add-cli)
+ [Afficher les balises d'un groupe de packages (CLI)](#package-group-tags-list-cli)
+ [Modifier les balises d'un groupe de packages (CLI)](#package-group-tags-edit-cli)
+ [Supprimer les balises d'un groupe de packages (CLI)](#package-group-tags-delete-cli)
### Ajouter des balises à un groupe de packages (CLI)
Vous pouvez ajouter des balises aux groupes de packages lors de leur création ou à un groupe de packages existant. Pour plus d'informations sur l'ajout de balises à un groupe de packages lors de sa création, consultez[Création d'un groupe de packages](create-package-group.md).
Pour ajouter une balise à un groupe de packages existant à l' AWS CLI aide du terminal ou de la ligne de commande, exécutez la **tag-resource** commande en spécifiant le nom de ressource Amazon (ARN) du groupe de packages dans lequel vous souhaitez ajouter des balises, ainsi que la clé et la valeur de la balise que vous souhaitez ajouter. Pour plus d'informations sur le groupe de packages ARNs, consultez[Groupe de packages ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Vous pouvez ajouter plusieurs balises à un groupe de packages. Par exemple, pour étiqueter un groupe de packages */npm/scope/anycompany\$1* avec deux balises, une clé de balise nommée *key1* avec la valeur de *value1* balise et une clé de balise nommée *key2* avec la valeur de balise 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
```
En cas de succès, cette commande n'a aucune sortie.
### Afficher les balises d'un groupe de packages (CLI)
Procédez comme suit pour utiliser le AWS CLI afin d'afficher les AWS balises d'un groupe de packages. Si aucune balise n’a été ajoutée, la liste renvoyée est vide.
Sur le terminal ou sur la ligne de commande, exécutez la **list-tags-for-resource** commande avec l'Amazon Resource Name (ARN) du groupe de packages. Pour plus d'informations sur le groupe de packages ARNs, consultez[Groupe de packages ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Par exemple, pour afficher la liste des clés de balise et des valeurs de balise pour un groupe de packages, */npm/scope/anycompany\$1* nommé avec une valeur 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~
```
Si elle aboutit, cette commande renvoie des informations similaires à ce qui suit :
```
{
"tags": {
"key1": "value1",
"key2": "value2"
}
}
```
### Modifier les balises d'un groupe de packages (CLI)
Procédez comme suit pour utiliser le AWS CLI pour modifier une balise pour un groupe de packages. Vous pouvez modifier la valeur d'une clé existante ou ajouter une autre clé. Vous pouvez également supprimer des balises d'un groupe de packages, comme indiqué dans la section suivante.
Sur le terminal ou sur la ligne de commande, exécutez la **tag-resource** commande en spécifiant l'ARN du groupe de packages dans lequel vous souhaitez mettre à jour une balise, ainsi que la clé et la valeur de la balise. Pour plus d'informations sur le groupe de packages ARNs, consultez[Groupe de packages 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
```
En cas de succès, cette commande n'a aucune sortie.
### Supprimer les balises d'un groupe de packages (CLI)
Procédez comme suit pour utiliser le AWS CLI pour supprimer une balise d'un groupe de packages.
**Note**
Si vous supprimez un groupe de packages, toutes les associations de balises sont supprimées du groupe de packages supprimé. Il n'est pas nécessaire de supprimer les balises avant de supprimer un groupe de packages.
Sur le terminal ou sur la ligne de commande, exécutez la **untag-resource** commande en spécifiant l'ARN du groupe de packages dans lequel vous souhaitez supprimer les balises et la clé de balise de la balise que vous souhaitez supprimer. Pour plus d'informations sur le groupe de packages ARNs, consultez[Groupe de packages ARNs](auth-and-access-control-permissions-reference.md#package-group-arns).
Par exemple, pour supprimer plusieurs balises d'un groupe de packages*/npm/scope/anycompany\$1*, à l'aide des clés de balise *key1* et *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
```
En cas de succès, cette commande n'a aucune sortie. Après avoir supprimé les balises, vous pouvez afficher les balises restantes du groupe de packages à l'aide de la `list-tags-for-resource` commande.