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 CodeArtifact avec NuGet
Ces rubriques décrivent comment consommer et publier des `NuGet` packages à l'aide de CodeArtifact.
**Note**
AWS CodeArtifact ne prend en charge que les [versions NuGet .exe 4.8](https://docs.microsoft.com/en-us/nuget/release-notes/nuget-4.8-rtm) et supérieures.
**Topics**
+ [Utilisation CodeArtifact avec Visual Studio](nuget-visual-studio.md)
+ [Utiliser CodeArtifact avec Nuget ou Dotnet](nuget-cli.md)
+ [NuGet normalisation du nom du package, de la version et du nom de l'actif](nuget-name-normalization.md)
+ [NuGet compatibilité](nuget-compatibility.md)
# Utilisation CodeArtifact avec Visual Studio
Vous pouvez utiliser des packages CodeArtifact directement depuis Visual Studio avec le fournisseur CodeArtifact d'informations d'identification. Le fournisseur d'informations d'identification simplifie la configuration et l'authentification de vos CodeArtifact référentiels dans Visual Studio et est disponible dans le. [AWS Toolkit for Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
**Note**
AWS Toolkit for Visual Studio Il n'est pas disponible pour Visual Studio pour Mac.
Pour configurer et utiliser NuGet avec les outils de la CLI, consultez[À utiliser CodeArtifact avec la CLI nuget ou dotnet](nuget-cli.md).
**Topics**
+ [Configurer Visual Studio avec le fournisseur d' CodeArtifact informations d'identification](#nuget-vs-cred-provider)
+ [Utiliser la console Visual Studio Package Manager](#built-in-nuget-terminal-vs)
## Configurer Visual Studio avec le fournisseur d' CodeArtifact informations d'identification
Le fournisseur CodeArtifact d'informations d'identification simplifie la configuration et l'authentification continue entre Visual Studio CodeArtifact et Visual Studio. CodeArtifact les jetons d'authentification sont valides pendant 12 heures au maximum. Pour éviter d'avoir à actualiser manuellement le jeton lorsque vous travaillez dans Visual Studio, le fournisseur d'informations d'identification récupère régulièrement un nouveau jeton avant que le jeton actuel n'expire.
**Important**
Pour utiliser le fournisseur d'informations d'identification, assurez-vous que toutes les AWS CodeArtifact informations d'identification existantes sont effacées de votre `nuget.config` fichier et qu'elles ont peut-être été ajoutées manuellement ou en exécutant `aws codeartifact login` la configuration NuGet précédente.
**Utilisation CodeArtifact dans Visual Studio avec AWS Toolkit for Visual Studio**
1. Installez le AWS Toolkit for Visual Studio en suivant les étapes ci-dessous. Le kit d'outils est compatible avec Visual Studio 2017 et 2019 en suivant ces étapes. AWS CodeArtifact ne prend pas en charge Visual Studio 2015 et les versions antérieures.
1. Le Toolkit pour Visual Studio pour Visual Studio 2017 et Visual Studio 2019 est distribué sur le [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=AmazonWebServices.AWSToolkitforVisualStudio2017). Vous pouvez également installer et mettre à jour le kit d'outils dans Visual Studio en utilisant **Outils** ≫ **Extensions et mises à jour** (Visual Studio 2017) ou **Extensions** ≫ **Gérer les extensions** (Visual Studio 2019).
1. Une fois le kit d'outils installé, ouvrez-le en choisissant **AWS Explorer** dans le menu **Afficher**.
1. Configurez le Toolkit for Visual Studio avec vos AWS informations d'identification en suivant les étapes décrites dans la section [Fournir des AWS informations d'identification](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/credentials.html) dans le *guide de AWS Toolkit for Visual Studio l'utilisateur*.
1. (Facultatif) Définissez le AWS profil que vous souhaitez utiliser CodeArtifact. S'il n'est pas défini, CodeArtifact il utilisera le profil par défaut. Pour définir le profil, accédez à **Outils > Gestionnaire de NuGet packages > Sélectionner un CodeArtifact AWS profil**.
1. Ajoutez votre CodeArtifact référentiel en tant que source de package dans Visual Studio.
1. Accédez à votre dépôt dans la fenêtre de l'**AWS explorateur**, cliquez avec le bouton droit de la souris et sélectionnez`Copy NuGet Source Endpoint`.
1. Utilisez la commande **Outils > Options** et faites défiler l'écran jusqu'au **Gestionnaire de NuGet packages**.
1. Sélectionnez le nœud **Package Sources**.
1. Sélectionnez **\$1**, modifiez le nom, collez le point de terminaison URL du référentiel copié à l'étape 3a dans la zone **Source**, puis sélectionnez **Mettre à jour**.
1. Cochez la case correspondant à la source du package que vous venez d'ajouter pour l'activer.
**Note**
Nous vous recommandons d'ajouter une connexion externe à **NuGet.org** à votre CodeArtifact dépôt et de désactiver la source du package **nuget.org** dans Visual Studio. Lorsque vous utilisez une connexion externe, tous les packages extraits de **NuGet.org** seront stockés dans votre CodeArtifact dépôt. Si **NuGet.org** devient indisponible, les dépendances de votre application seront toujours disponibles pour les builds CI et le développement local. Pour plus d'informations sur les connexions externes, consultez[Connect un CodeArtifact dépôt à un dépôt public](external-connection.md).
1. Redémarrez Visual Studio pour que les modifications prennent effet.
Après la configuration, Visual Studio peut consommer des packages depuis votre CodeArtifact dépôt, n'importe lequel de ses référentiels en amont ou depuis [NuGet.org](https://www.nuget.org/) si vous avez ajouté une connexion externe. Pour plus d'informations sur la navigation et l'installation de NuGet packages dans Visual Studio, voir [Installer et gérer des packages dans Visual Studio à l'aide NuGet du gestionnaire](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-visual-studio) de packages dans la *NuGet documentation*.
## Utiliser la console Visual Studio Package Manager
La console Visual Studio Package Manager n'utilisera pas la version Visual Studio du fournisseur d' CodeArtifact informations d'identification. Pour l'utiliser, vous devez configurer le fournisseur d'informations d'identification en ligne de commande. Pour plus d'informations, consultez [À utiliser CodeArtifact avec la CLI nuget ou dotnet](nuget-cli.md).
# À utiliser CodeArtifact avec la CLI nuget ou dotnet
Vous pouvez utiliser des outils CLI tels que `nuget` et `dotnet` pour publier et consommer des packages à partir de CodeArtifact. Ce document fournit des informations sur la configuration des outils CLI et leur utilisation pour publier ou consommer des packages.
**Topics**
+ [Configuration de la CLI nuget ou dotnet](#nuget-configure-cli)
+ [Consommez NuGet des colis provenant de CodeArtifact](#nuget-consume-cli)
+ [Publiez NuGet des packages sur CodeArtifact](#nuget-publish-cli)
+ [CodeArtifact NuGet Référence du fournisseur d'informations d'identification](#nuget-cred-provider-reference)
+ [CodeArtifact NuGet Versions du fournisseur d'informations d'identification](#nuget-cred-provider-history)
## Configuration de la CLI nuget ou dotnet
Vous pouvez configurer la CLI nuget ou dotnet avec le fournisseur CodeArtifact NuGet d'informations d'identification, avec ou manuellement AWS CLI. La configuration NuGet avec le fournisseur d'informations d'identification est vivement recommandée pour une configuration simplifiée et une authentification continue.
### Méthode 1 : Configuration avec le fournisseur CodeArtifact NuGet d'informations d'identification
Le fournisseur CodeArtifact NuGet d'informations d'identification simplifie l'authentification et la configuration à l' CodeArtifact aide des outils NuGet CLI. CodeArtifact les jetons d'authentification sont valides pendant 12 heures au maximum. Pour éviter d'avoir à actualiser manuellement le jeton lors de l'utilisation de la CLI nuget ou dotnet, le fournisseur d'informations d'identification récupère régulièrement un nouveau jeton avant l'expiration du jeton actuel.
**Important**
Pour utiliser le fournisseur d'informations d'identification, assurez-vous que toutes les AWS CodeArtifact informations d'identification existantes sont effacées de votre `nuget.config` fichier et qu'elles ont peut-être été ajoutées manuellement ou en exécutant `aws codeartifact login` la configuration NuGet précédente.
**Installation et configuration du fournisseur d' CodeArtifact NuGet informations d'identification**
------
#### [ dotnet ]
1. Téléchargez la dernière version d'[AWS. CodeArtifact. NuGet. CredentialProvider outil de NuGet .org](https://www.nuget.org/packages/AWS.CodeArtifact.NuGet.CredentialProvider) avec la `dotnet` commande suivante.
```
dotnet tool install -g AWS.CodeArtifact.NuGet.CredentialProvider
```
1. Utilisez la `codeartifact-creds install` commande pour copier le fournisseur d'informations d'identification dans le dossier NuGet des plugins.
```
dotnet codeartifact-creds install
```
1. (Facultatif) : Définissez le AWS profil que vous souhaitez utiliser avec le fournisseur d'informations d'identification. S'il n'est pas défini, le fournisseur d'informations d'identification utilisera le profil par défaut. Pour plus d'informations sur les AWS CLI profils, consultez la section [Profils nommés](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html).
```
dotnet codeartifact-creds configure set profile profile_name
```
------
#### [ nuget ]
Procédez comme suit pour utiliser la NuGet CLI afin d'installer le fournisseur CodeArtifact NuGet d'informations d'identification à partir d'un compartiment Amazon S3 et de le configurer. Le fournisseur d'informations d'identification utilisera le AWS CLI profil par défaut. Pour plus d'informations sur les profils, voir [Profils nommés](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html).
1. Téléchargez la dernière version du [fournisseur CodeArtifact NuGet d'informations d'identification (codeartifact-nuget-credentialprovider.zip)](https://a.co/dbGqKq7) depuis un compartiment Amazon S3.
Pour consulter et télécharger les versions antérieures, voir[CodeArtifact NuGet Versions du fournisseur d'informations d'identification](#nuget-cred-provider-history).
1. Décompressez le fichier.
1. Copiez l'**AWS. CodeArtifact. NuGetCredentialProvider**dossier du dossier **netfx** vers `%user_profile%/.nuget/plugins/netfx/` Windows, `~/.nuget/plugins/netfx` Linux ou macOS.
1. Copiez l'**AWS. CodeArtifact. NuGetCredentialProvider**dossier du dossier **netcore** vers `%user_profile%/.nuget/plugins/netcore/` Windows, `~/.nuget/plugins/netcore` Linux ou macOS.
------
Après avoir créé un référentiel et configuré le fournisseur d'informations d'identification, vous pouvez utiliser les outils `nuget` ou `dotnet` CLI pour installer et publier des packages. Pour plus d’informations, consultez [Consommez NuGet des colis provenant de CodeArtifact](#nuget-consume-cli) et [Publiez NuGet des packages sur CodeArtifact](#nuget-publish-cli).
### Méthode 2 : configurer nuget ou dotnet avec la commande de connexion
La `codeartifact login` commande du AWS CLI ajoute un point de terminaison du référentiel et un jeton d'autorisation à votre fichier NuGet de configuration, permettant à Nuget ou Dotnet de se connecter à votre CodeArtifact référentiel. Cela modifiera la NuGet configuration au niveau utilisateur qui se trouve dans `%appdata%\NuGet\NuGet.Config` pour Windows `~/.config/NuGet/NuGet.Config` et/ou `~/.nuget/NuGet/NuGet.Config` pour Mac/Linux. Pour plus d'informations sur les NuGet configurations, consultez la section [ NuGet Configurations courantes](https://docs.microsoft.com/en-us/nuget/consume-packages/configuring-nuget-behavior).
**Configurez nuget ou dotnet avec la commande `login`**
1. Configurez vos AWS informations d'identification à utiliser avec le AWS CLI, comme décrit dans[Commencer avec CodeArtifact](getting-started.md).
1. Assurez-vous que l'outil NuGet CLI (`nuget`ou`dotnet`) a été correctement installé et configuré. Pour obtenir des instructions, consultez la documentation de [Nuget](https://docs.microsoft.com/en-us/nuget/reference/nuget-exe-cli-reference) ou [Dotnet](https://docs.microsoft.com/en-us/dotnet/core/install/).
1. Utilisez la CodeArtifact `login` commande pour récupérer les informations d'identification à utiliser avec NuGet.
**Note**
Si vous accédez à un référentiel dans un domaine qui vous appartient, vous n'avez pas besoin de l'inclure`--domain-owner`. Pour de plus amples informations, veuillez consulter [Domaines multi-comptes](domain-overview.md#domain-overview-cross-account).
------
#### [ dotnet ]
**Important**
**Utilisateurs de Linux et de macOS :** le chiffrement n'étant pas pris en charge sur les plateformes autres que Windows, les informations d'identification que vous avez récupérées seront stockées sous forme de texte brut dans votre fichier de configuration.
```
aws codeartifact login --tool dotnet --domain my_domain --domain-owner 111122223333 --repository my_repo
```
------
#### [ nuget ]
```
aws codeartifact login --tool nuget --domain my_domain --domain-owner 111122223333 --repository my_repo
```
------
La commande de connexion permettra de :
+ Récupérez un jeton d'autorisation à CodeArtifact l'aide de vos AWS informations d'identification.
+ Mettez à jour votre NuGet configuration au niveau utilisateur avec une nouvelle entrée pour la source de votre NuGet package. La source qui pointe vers le point de terminaison de votre CodeArtifact dépôt sera appelée`domain_name/repo_name`.
La période d'autorisation par défaut après l'appel `login` est de 12 heures et `login` doit être appelée pour actualiser régulièrement le jeton. Pour plus d'informations sur le jeton d'autorisation créé avec la `login` commande, consultez[Jetons créés avec la `login` commande](tokens-authentication.md#auth-token-login).
Après avoir créé un référentiel et configuré l'authentification, vous pouvez utiliser les clients `nuget``dotnet`, ou `msbuild` CLI pour installer et publier des packages. Pour plus d’informations, consultez [Consommez NuGet des colis provenant de CodeArtifact](#nuget-consume-cli) et [Publiez NuGet des packages sur CodeArtifact](#nuget-publish-cli).
### Méthode 3 : configurer nuget ou dotnet sans la commande de connexion
Pour la configuration manuelle, vous devez ajouter un point de terminaison de référentiel et un jeton d'autorisation à votre fichier de NuGet configuration pour permettre à nuget ou dotnet de se connecter à votre CodeArtifact référentiel.
**Configurez manuellement nuget ou dotnet pour vous connecter à votre CodeArtifact dépôt.**
1. Déterminez le point de terminaison de votre CodeArtifact dépôt à l'aide de la `get-repository-endpoint` AWS CLI commande.
```
aws codeartifact get-repository-endpoint --domain my_domain --domain-owner 111122223333 --repository my_repo --format nuget
```
Exemple de sortie :
```
{
"repositoryEndpoint": "https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/nuget/my_repo/"
}
```
1. Obtenez un jeton d'autorisation pour vous connecter à votre dépôt depuis votre gestionnaire de packages à l'aide de la `get-authorization-token` AWS CLI commande.
```
aws codeartifact get-authorization-token --domain my_domain
```
Exemple de sortie :
```
{
"authorizationToken": "eyJ2I...viOw",
"expiration": 1601616533.0
}
```
1. Créez l'URL complète du point de terminaison du référentiel en l'ajoutant `/v3/index.json` à l'URL renvoyée `get-repository-endpoint` à l'étape 3.
1. Configurez nuget ou dotnet pour utiliser le point de terminaison du référentiel de l'étape 1 et le jeton d'autorisation de l'étape 2.
**Note**
L'URL source doit se terminer par `/v3/index.json` pour que nuget ou dotnet se connecte correctement à un CodeArtifact dépôt.
------
#### [ dotnet ]
**Utilisateurs de Linux et de macOS :** le chiffrement n'étant pas pris en charge sur les plateformes autres que Windows, vous devez ajouter l'`--store-password-in-clear-text`indicateur à la commande suivante. Notez que cela enregistrera votre mot de passe sous forme de texte brut dans votre fichier de configuration.
```
dotnet nuget add source https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/nuget/my_repo/v3/index.json --name packageSourceName --password eyJ2I...viOw --username aws
```
**Note**
Pour mettre à jour une source existante, utilisez la `dotnet nuget update source` commande.
------
#### [ nuget ]
```
nuget sources add -name domain_name/repo_name -Source https://my_domain-111122223333.d.codeartifact.us-west-2.amazonaws.com/nuget/my_repo/v3/index.json -password eyJ2I...viOw -username aws
```
------
Exemple de sortie :
```
Package source with Name: domain_name/repo_name added successfully.
```
**Note**
Pour utiliser un point de terminaison à double pile, utilisez le `codeartifact.region.on.aws` point de terminaison.
## Consommez NuGet des colis provenant de CodeArtifact
Une fois que vous avez [configuré NuGet avec CodeArtifact](https://docs.aws.amazon.com//codeartifact/latest/ug/nuget-cli.html), vous pouvez utiliser les NuGet packages stockés dans votre CodeArtifact référentiel ou dans l'un de ses référentiels en amont.
Pour utiliser une version de package à partir d'un CodeArtifact référentiel ou de l'un de ses référentiels en amont avec `nuget` ou`dotnet`, exécutez la commande suivante en remplaçant par *packageName* le nom du package que vous souhaitez consommer et *packageSourceName* par le nom de la source de votre CodeArtifact référentiel dans votre fichier de NuGet configuration. Si vous avez utilisé la `login` commande pour configurer votre NuGet configuration, le nom de la source est*domain\$1name/repo\$1name*.
**Note**
Lorsqu'un package est demandé, le NuGet client met en cache les versions de ce package qui existent. En raison de ce comportement, l'installation d'un package précédemment demandé avant que la version souhaitée ne soit disponible peut échouer. Pour éviter cet échec et installer correctement un package existant, vous pouvez soit vider le NuGet cache avant une installation avec `nuget locals all --clear` ou`dotnet nuget locals all --clear`, soit éviter d'utiliser le cache pendant `restore` les commandes `install` et en fournissant l'`-NoCache`option pour `nuget` ou l'`--no-cache`option pour`dotnet`.
------
#### [ dotnet ]
```
dotnet add package packageName --source packageSourceName
```
------
#### [ nuget ]
```
nuget install packageName -Source packageSourceName
```
------
**Pour installer une version spécifique d'un package**
------
#### [ dotnet ]
```
dotnet add package packageName --version 1.0.0 --source packageSourceName
```
------
#### [ nuget ]
```
nuget install packageName -Version 1.0.0 -Source packageSourceName
```
------
Consultez [Gérer les packages à l'aide de la CLI nuget.exe](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-nuget-cli) ou [Installer et gérer les packages à l'aide de la CLI dotnet](https://docs.microsoft.com/en-us/nuget/consume-packages/install-use-packages-dotnet-cli) dans la *documentation Microsoft* pour plus d'informations.
### Consommez NuGet des packages provenant de NuGet .org
Vous pouvez utiliser des NuGet packages provenant de [NuGet.org](https://www.nuget.org/) via un CodeArtifact référentiel en configurant le référentiel avec une connexion externe à **NuGet.org**. Les paquets consommés à partir de **NuGet.org** sont ingérés et stockés dans votre CodeArtifact dépôt. Pour plus d'informations sur l'ajout de connexions externes, consultez[Connect un CodeArtifact dépôt à un dépôt public](external-connection.md).
## Publiez NuGet des packages sur CodeArtifact
Une fois que vous avez [configuré NuGet avec CodeArtifact](https://docs.aws.amazon.com//codeartifact/latest/ug/nuget-cli.html), vous pouvez utiliser `nuget` ou `dotnet` publier des versions de package dans CodeArtifact des référentiels.
Pour transférer une version de package vers un CodeArtifact référentiel, exécutez la commande suivante en indiquant le chemin complet de votre `.nupkg` fichier et le nom de la source de votre CodeArtifact référentiel dans votre fichier NuGet de configuration. Si vous avez utilisé la `login` commande pour configurer votre NuGet configuration, le nom de la source est`domain_name/repo_name`.
**Note**
Vous pouvez créer un NuGet package si vous n'en avez pas à publier. Pour plus d'informations, consultez la section [Flux de travail de création de packages](https://docs.microsoft.com/en-us/nuget/create-packages/overview-and-workflow) dans la *documentation Microsoft*.
------
#### [ dotnet ]
```
dotnet nuget push path/to/nupkg/SamplePackage.1.0.0.nupkg --source packageSourceName
```
------
#### [ nuget ]
```
nuget push path/to/nupkg/SamplePackage.1.0.0.nupkg -Source packageSourceName
```
------
## CodeArtifact NuGet Référence du fournisseur d'informations d'identification
Le fournisseur CodeArtifact NuGet d'informations d'identification facilite la configuration et l'authentification NuGet auprès de vos CodeArtifact référentiels.
### CodeArtifact NuGet Commandes du fournisseur d'informations d'identification
Cette section inclut la liste des commandes pour le fournisseur CodeArtifact NuGet d'informations d'identification. Ces commandes doivent être préfixées par un préfixe, `dotnet codeartifact-creds` comme dans l'exemple suivant.
```
dotnet codeartifact-creds command
```
+ `configure set profile profile`: Configure le fournisseur d'informations d'identification pour qu'il utilise le profil fourni AWS .
+ `configure unset profile`: Supprime le profil configuré s'il est défini.
+ `install`: copie le fournisseur d'informations d'identification `plugins` dans le dossier.
+ `install --profile profile`: copie le fournisseur d'informations d'identification `plugins` dans le dossier et le configure pour utiliser le profil fourni AWS .
+ `uninstall`: désinstalle le fournisseur d'informations d'identification. Cela ne supprime pas les modifications apportées au fichier de configuration.
+ `uninstall --delete-configuration`: désinstalle le fournisseur d'informations d'identification et supprime toutes les modifications apportées au fichier de configuration.
### CodeArtifact NuGet Journaux du fournisseur d'informations d'identification
Pour activer la journalisation pour le fournisseur CodeArtifact NuGet d'informations d'identification, vous devez définir le fichier journal dans votre environnement. Les journaux du fournisseur d'informations d'identification contiennent des informations de débogage utiles, telles que :
+ Le AWS profil utilisé pour établir des connexions
+ Toute erreur d'authentification
+ Si le point de terminaison fourni n'est pas une CodeArtifact URL
**Définissez le fichier journal du fournisseur d'informations d' CodeArtifact NuGet identification**
```
export AWS_CODEARTIFACT_NUGET_LOGFILE=/path/to/file
```
Une fois le fichier journal défini, toute `codeartifact-creds` commande ajoutera sa sortie de journal au contenu de ce fichier.
## CodeArtifact NuGet Versions du fournisseur d'informations d'identification
Le tableau suivant contient des informations sur l'historique des versions et des liens de téléchargement pour le fournisseur CodeArtifact NuGet d'informations d'identification.
| Version | Modifications | Date de publication | Lien de téléchargement (S3) |
| --- | --- | --- | --- |
| 1.0.2 (dernière version) | Dépendances améliorées | 26/06/2024 | [Télécharger v1.0.2](https://d12ov9682v6hj.cloudfront.net/codeartifact-nuget-credentialprovider-v1.0.2.zip) |
| 1.0.1 | Ajout du support pour les profils net5, net6 et SSO | 05/03/2022 | [Télécharger v1.0.1](https://a.co/cAIkhV1) |
| 1.0.0 | Version initiale du fournisseur CodeArtifact NuGet d'informations d'identification | 20/11/2020 | [Télécharger v1.0.0](https://a.co/8b2cENb) |
# NuGet normalisation du nom du package, de la version et du nom de l'actif
CodeArtifact normalise les noms des packages et des actifs ainsi que les versions des packages avant de les stocker, ce qui signifie que les noms ou les versions CodeArtifact peuvent être différents de ceux fournis lors de la publication du package ou de l'actif.
**Normalisation des noms de packages :** CodeArtifact normalise les noms de NuGet packages en convertissant toutes les lettres en minuscules.
**Normalisation des versions des packages :** CodeArtifact normalise les versions des NuGet packages en utilisant le même modèle que NuGet. Les informations suivantes proviennent des [numéros de version normalisés](https://docs.microsoft.com/en-us/nuget/concepts/package-versioning#normalized-version-numbers) de la NuGet documentation.
+ Les zéros en tête sont supprimés des numéros de version :
+ `1.00`est traité comme `1.0`
+ `1.01.1`est traité comme `1.1.1`
+ `1.00.0.1`est traité comme `1.0.0.1`
+ Un zéro dans la quatrième partie du numéro de version sera omis :
+ `1.0.0.0`est traité comme `1.0.0`
+ `1.0.01.0`est traité comme `1.0.1`
+ SemVer Les métadonnées de build 2.0.0 sont supprimées :
+ `1.0.7+r3456`est traité comme `1.0.7`
**Normalisation du nom de l'actif du package :** CodeArtifact construit le nom de l'actif NuGet du package à partir du nom du package normalisé et de la version du package.
Le nom du package et le nom de version non normalisés peuvent être utilisés avec les demandes d'API et de CLI car ils CodeArtifact normalisent le nom du package et les entrées de version pour ces demandes. Par exemple, les entrées de `--package Newtonsoft.JSON` et `--version 12.0.03.0` seraient normalisées et renverraient un package dont le nom de package `newtonsoft.json` et la version de sont normalisés. `12.0.3`
Vous devez utiliser le nom d'actif du package normalisé dans les demandes d'API et de CLI, car CodeArtifact il n'effectue pas de normalisation sur l'`--asset`entrée.
Vous devez utiliser des noms et des versions normalisés dans ARNs.
Pour trouver le nom normalisé d'un package, utilisez la `aws codeartifact list-packages` commande. Pour de plus amples informations, veuillez consulter [Lister les noms de packages](list-packages.md).
Pour trouver le nom non normalisé d'un package, utilisez la `aws codeartifact describe-package-version` commande. Le nom non normalisé du package est renvoyé dans le `displayName` champ. Pour de plus amples informations, veuillez consulter [Afficher et mettre à jour les détails et les dépendances des versions du package](describe-package-version.md).
# NuGet compatibilité
Ce guide contient des informations sur CodeArtifact la compatibilité avec différents NuGet outils et versions.
**Topics**
+ [NuGet Compatibilité générale](#nuget-version-support)
+ [NuGet support en ligne de commande](#nuget-command-line-support)
## NuGet Compatibilité générale
AWS CodeArtifact prend en charge les versions NuGet 4.8 et supérieures.
AWS CodeArtifact supporte uniquement la version 3 du protocole NuGet HTTP. Cela signifie que certaines commandes CLI qui reposent sur la version 2 du protocole ne sont pas prises en charge. Consultez la section [prise en charge des commandes nuget.exe](#nuget-command-support) pour plus d’informations.
AWS CodeArtifact ne prend pas en charge la version PowerShellGet 2.x.
## NuGet support en ligne de commande
AWS CodeArtifact prend en charge les outils CLI NuGet (`nuget.exe``dotnet`) et .NET Core ().
### prise en charge des commandes nuget.exe
Comme elle CodeArtifact ne prend en charge que le protocole HTTP NuGet de la version 3 de, les commandes suivantes ne fonctionneront pas lorsqu'elles sont utilisées avec des CodeArtifact ressources :
+ `list`: La `nuget list` commande affiche une liste de packages provenant d'une source donnée. Pour obtenir la liste des packages d'un CodeArtifact dépôt, vous pouvez utiliser la [Lister les noms de packages](list-packages.md) commande de la AWS CLI.