

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.

# Copier des packages entre des référentiels
<a name="copy-package"></a>

Vous pouvez copier les versions des packages d'un référentiel à un autre dans CodeArtifact. Cela peut être utile pour des scénarios tels que les flux de travail de promotion de packages ou le partage de versions de packages entre des équipes ou des projets. Les référentiels source et de destination doivent se trouver dans le même domaine pour copier les versions des packages.

## Autorisations IAM requises pour copier des packages
<a name="copypackageversions-iam-actions"></a>

Pour copier des versions de package CodeArtifact, l'utilisateur appelant doit disposer des autorisations IAM requises et la politique basée sur les ressources attachée aux référentiels source et de destination doit disposer des autorisations requises. Pour plus d'informations sur les politiques d'autorisation et les CodeArtifact référentiels basés sur les ressources, consultez. [Politiques de référentiel](repo-policies.md)

L'utilisateur appelant `copy-package-versions` doit avoir l'`ReadFromRepository`autorisation sur le référentiel source et l'`CopyPackageVersions`autorisation sur le référentiel de destination.

Le référentiel source doit disposer de l'`ReadFromRepository`autorisation et le référentiel de destination doit disposer de l'`CopyPackageVersions`autorisation attribuée au compte IAM ou à l'utilisateur qui copie des packages. Les politiques suivantes sont des exemples de politiques de référentiel à ajouter au référentiel source ou au référentiel de destination à l'aide de la `put-repository-permissions-policy` commande. Remplacez *111122223333* par l'identifiant du compte appelant`copy-package-versions`.

**Note**  
L'appel `put-repository-permissions-policy` remplacera la politique de dépôt actuelle, s'il en existe une. Vous pouvez utiliser la `get-repository-permissions-policy` commande pour voir s'il existe une politique. Pour plus d'informations, consultez[Lire une politique](repo-policies.md#reading-a-policy). Si une politique existe, vous souhaiterez peut-être y ajouter ces autorisations au lieu de la remplacer.

**Exemple de politique d'autorisation du référentiel source**

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Action": [
                "codeartifact:ReadFromRepository"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::111122223333:root"
            },
            "Resource": "*"
        }
    ]
}
```

------

**Exemple de politique d'autorisation du référentiel de destination**

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Action": [
                "codeartifact:CopyPackageVersions"
            ],
            "Effect": "Allow",
            "Principal": {
                 "AWS": "arn:aws:iam::111122223333:root"
            },
            "Resource": "*"
        }
    ]
}
```

------

## Copier les versions du package
<a name="copy-package-versions"></a>

Utilisez la `copy-package-versions` commande in CodeArtifact pour copier une ou plusieurs versions de package d'un référentiel source vers un référentiel de destination dans le même domaine. L'exemple suivant copiera les versions 6.0.2 et 4.0.0 d'un package npm nommé `my-package` du `my_repo` référentiel vers le référentiel. `repo-2`

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository my_repo \
 --destination-repository repo-2 --package my-package --format npm \
 --versions 6.0.2 4.0.0
```

Vous pouvez copier plusieurs versions du même nom de package en une seule opération. Pour copier des versions de différents noms de packages, vous devez appeler chacun `copy-package-versions` d'entre eux.

La commande précédente produira le résultat suivant, en supposant que les deux versions puissent être copiées avec succès.

```
{
   "successfulVersions": {
        "6.0.2": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        },
        "4.0.0": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

## Copier un package depuis des référentiels en amont
<a name="copy-package-upstream"></a>

Normalement, `copy-package-versions` ne recherche dans le référentiel spécifié par l'`--source-repository`option que les versions à copier. Toutefois, vous pouvez copier des versions à la fois du référentiel source et de ses référentiels en amont à l'aide de `--include-from-upstream` cette option. Si vous utilisez le CodeArtifact SDK, appelez l'`CopyPackageVersions`API avec le `includeFromUpstream` paramètre défini sur true. Pour de plus amples informations, veuillez consulter [Utilisation de référentiels en amont dans CodeArtifact](repos-upstream.md).

## Copier un package npm délimité
<a name="copying-a-scoped-npm-package"></a>

 Pour copier une version de package npm dans une portée, utilisez l'`--namespace`option pour spécifier la portée. Par exemple, pour copier le package`@types/react`, utilisez`--namespace types`. Le `@` symbole doit être omis lors de l'utilisation`--namespace`.

```
aws codeartifact copy-package-versions  --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace types \
 --package react --versions 0.12.2
```

## Copier les versions du package Maven
<a name="copying-a-maven-package"></a>

Pour copier des versions de package Maven entre des référentiels, spécifiez le package à copier en transmettant l'ID du groupe Maven avec l'`--namespace`option et l'ArtifactID Maven avec l'option. `--name` Par exemple, pour copier une seule version de `com.google.guava:guava` :

```
 aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333  \
 --source-repository my_repo --destination-repository repo-2 --format maven --namespace com.google.guava \
 --package guava --versions 27.1-jre
```

Si la version du package est copiée avec succès, le résultat sera similaire à ce qui suit.

```
{
    "successfulVersions": {
        "27.1-jre": {
            "revision": "REVISION-1-SAMPLE-6C81EFF7DA55CC",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

## Versions qui n'existent pas dans le référentiel source
<a name="versions-that-do-not-exist-in-the-source-repository"></a>

Si vous spécifiez une version qui n'existe pas dans le référentiel source, la copie échouera. Si certaines versions existent dans le référentiel source et d'autres non, toutes les versions ne seront pas copiées. Dans l'exemple suivant, la version 0.2.0 du package `array-unique` npm est présente dans le référentiel source, mais pas la version 5.6.7 :

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm \
         --package array-unique --versions 0.2.0 5.6.7
```

Le résultat de ce scénario sera similaire au suivant.

```
{
    "successfulVersions": {},
    "failedVersions": {
        "0.2.0": {
            "errorCode": "SKIPPED",
            "errorMessage": "Version 0.2.0 was skipped"
        },
        "5.6.7": {
            "errorCode": "NOT_FOUND",
            "errorMessage": "Could not find version 5.6.7"
        }
    }
}
```

Le code `SKIPPED` d'erreur est utilisé pour indiquer que la version n'a pas été copiée dans le référentiel de destination car aucune autre version n'a pu être copiée. 

## Versions qui existent déjà dans le référentiel de destination
<a name="versions-that-already-exist-in-the-destination-repository"></a>

 Lorsqu'une version de package est copiée dans un référentiel où elle existe déjà, CodeArtifact compare ses actifs de package et les métadonnées au niveau de la version du package dans les deux référentiels.

 Si les actifs et les métadonnées de la version du package sont identiques dans les référentiels source et de destination, aucune copie n'est effectuée mais l'opération est considérée comme réussie. Cela signifie que c'`copy-package-versions`est idempotent. Dans ce cas, la version qui était déjà présente dans les référentiels source et de destination ne sera pas répertoriée dans la sortie de`copy-package-versions`.

Dans l'exemple suivant, deux versions du package npm `array-unique` sont présentes dans le référentiel `repo-1` source. La version 0.2.1 est également présente dans le référentiel de destination `dest-repo` et la version 0.2.0 ne l'est pas.

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm --package array-unique \
         --versions 0.2.1 0.2.0
```

Le résultat de ce scénario sera similaire au suivant.

```
{
    "successfulVersions": {
        "0.2.0": {
            "revision": "Yad+B1QcBq2kdEVrx1E1vSfHJVh8Pr61hBUkoWPGWX0=",
            "status": "Published"
        }
    },
    "failedVersions": {}
}
```

La version 0.2.0 est répertoriée `successfulVersions` car elle a été copiée avec succès du référentiel source vers le référentiel de destination. La version 0.2.1 n'apparaît pas dans la sortie car elle était déjà présente dans le référentiel de destination.

 Si la version du package, les ressources ou les métadonnées diffèrent dans les référentiels source et de destination, l'opération de copie échouera. Vous pouvez utiliser le `--allow-overwrite` paramètre pour forcer un remplacement. 

Si certaines versions existent dans le référentiel de destination et d'autres non, toutes les versions ne seront pas copiées. Dans l'exemple suivant, la version 0.3.2 du package `array-unique` npm est présente à la fois dans les référentiels source et de destination, mais le contenu de la version du package est différent. La version 0.2.1 est présente dans le référentiel source mais pas dans le référentiel de destination.

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 \
         --source-repository my_repo --destination-repository repo-2 --format npm --package array-unique \
         --versions 0.3.2 0.2.1
```

Le résultat de ce scénario sera similaire au suivant.

```
{
    "successfulVersions": {},
    "failedVersions": {
        "0.2.1": {
            "errorCode": "SKIPPED",
            "errorMessage": "Version 0.2.1 was skipped"
        },
        "0.3.2": {
            "errorCode": "ALREADY_EXISTS",
            "errorMessage": "Version 0.3.2 already exists"
        }
    }
}
```

La version 0.2.1 est marquée comme `SKIPPED` car elle n'a pas été copiée dans le référentiel de destination. Il n'a pas été copié car la copie de la version 0.3.2 a échoué car elle était déjà présente dans le référentiel de destination, mais pas identique dans les référentiels source et de destination.

## Spécification d'une révision de version de package
<a name="specify-package-version-revision"></a>

 Une révision de version de package est une chaîne qui spécifie un ensemble spécifique de ressources et de métadonnées pour une version de package. Vous pouvez spécifier une révision de version de package pour copier les versions de package dans un état spécifique. Pour spécifier une révision de version de package, utilisez le `--version-revisions` paramètre pour transmettre une ou plusieurs versions de package séparées par des virgules et les paires de révisions de version de package à la `copy-package-versions` commande. 

**Note**  
Vous devez spécifier le `--versions` ou le `--version-revisions` paramètre avec`copy-package-versions`. Vous ne pouvez pas spécifier les deux. 

L'exemple suivant ne copiera la version 0.3.2 du package que `my-package` si elle est présente dans le référentiel source avec la révision `REVISION-1-SAMPLE-6C81EFF7DA55CC` de la version du package.

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace my-namespace \
 --package my-package --version-revisions 0.3.2=REVISION-1-SAMPLE-6C81EFF7DA55CC
```

L'exemple suivant copie deux versions du package`my-package`, 0.3.2 et 0.3.13. La copie ne réussira que si, dans le référentiel source, la version 0.3.2 de `my-package` contient une révision `REVISION-1-SAMPLE-6C81EFF7DA55CC` et la version 0.3.13 une révision. `REVISION-2-SAMPLE-55C752BEE772FC`

```
aws codeartifact copy-package-versions --domain my_domain --domain-owner 111122223333 --source-repository repo-1 \
 --destination-repository repo-2 --format npm --namespace my-namespace \
 --package my-package --version-revisions 0.3.2=REVISION-1-SAMPLE-6C81EFF7DA55CC,0.3.13=REVISION-2-SAMPLE-55C752BEE772FC
```

 Pour rechercher les révisions d'une version de package, utilisez la `list-package-versions` commande `describe-package-version` ou. 

 Pour plus d'informations, veuillez consulter les sections [Révision de la version du package](codeartifact-concepts.md#welcome-concepts-package-version-revision) et [CopyPackageVersion](https://docs.aws.amazon.com/codeartifact/latest/APIReference/API_CopyPackageVersions.html) (français non garanti) de la *Référence d'API CodeArtifact *. 

## Copier les packages npm
<a name="copying-npm-packages"></a>

 Pour plus d'informations sur `copy-package-versions` le comportement avec les packages npm, consultez les [balises npm et l' CopyPackageVersionsAPI](npm-tags.md#tags-and-cpv). 