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.
# Création d’une AMI basée sur Amazon S3
L’AMI que vous spécifiez au lancement de votre instance détermine le type de volume racine.
Pour créer une AMI basée sur Amazon S3, démarrez à partir d’une instance que vous avez lancée depuis une AMI Linux existante basée sur Amazon S3. Après avoir personnalisé l’instance pour répondre à vos besoins, créez un bundle du volume et inscrivez une nouvelle AMI que vous pouvez utiliser pour lancer de nouvelles instances avec ces personnalisations.
Vous ne pouvez pas créer d'AMI Windows basée sur Amazon S3 car Windows AMIs ne prend pas en charge le stockage d'instance pour le volume racine.
**Important**
Seuls les types d’instance suivants prennent en charge un volume de stockage d’instances en tant que volume racine et nécessitent une AMI basée sur Amazon S3 : C1, C3, D2, I2, M1, M2, M3, R3 et X1.
Le processus de création d'AMI est différent pour Amazon EBS AMIs. Pour de plus amples informations, veuillez consulter [Créer une AMI basée sur Amazon EBS](creating-an-ami-ebs.md).
**Topics**
+ [Aperçu de la création d’une AMI](#process-creating-an-ami-instance-store)
+ [Conditions préalables](#bundle-ami-prerequisites)
+ [Créer une AMI à partir d’une instance Amazon Linux](#amazon_linux_instructions)
+ [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md)
+ [Référence des outils Amazon EC2 AMI](ami-tools-commands.md)
+ [Conversion de votre AMI basée sur Amazon S3 en AMI basée sur Amazon EBS](Using_ConvertingS3toEBS.md)
## Aperçu de la création d’une AMI
Le diagramme suivant résume le processus de création d’une AMI à partir d’une instance avec un volume racine de stockage d’instance.
![\[Créez une AMI basée sur Amazon S3.\]](http://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/images/ami_create_instance_store.png)
Tout d’abord, lancez une instance depuis une AMI qui est similaire à l’AMI que vous souhaiteriez créer. Vous pouvez vous connecter à votre instance et la personnaliser. Lorsque l’instance est configurée comme vous le voulez, vous pouvezen créer un bundle. Le processus de création d’un bundle peut prendre plusieurs minutes. Après la fin du processus, vous avez un groupe qui se compose d’un manifeste d’image (`image.manifest.xml`) et de fichiers (`image.part.`*xx*) contenant un modèle pour le volume racine. Ensuite, vous chargez le bundle dans votre compartiment Amazon S3, puis vous inscrivez votre AMI.
**Note**
Afin de charger des objets vers un compartiment S3 pour votre AMI Linux basée sur Amazon S3, les listes de contrôle d’accès (ACL) doivent être activées pour le compartiment. Dans le cas contraire, Amazon EC2 ne sera pas en mesure de définir ACLs les objets à télécharger. Si votre compartiment de destination utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, cela ne fonctionnera pas car ils ACLs sont désactivés. Pour plus d'informations, consultez les [sections Contrôle de la propriété des objets et désactivation ACLs de votre compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html).
Lorsque vous lancez une instance à l’aide de la nouvelle AMI, nous créons le volume racine pour l’instance avec le bundle que vous avez chargé sur Amazon S3. L’espace de stockage utilisé par le bundle dans Amazon S3 entraîne des frais sur votre compte jusqu’à ce que vous le supprimiez. Pour de plus amples informations, veuillez consulter [Annuler l’inscription d’une AMI Amazon EC2](deregister-ami.md).
Si vous ajoutez des volumes de stockage d’instance à votre instance en plus du volume racine, le mappage de périphérique de stockage en mode bloc pour la nouvelle AMI contient des informations pour ces volumes et les mappages de périphérique de stockage en mode bloc pour les instances que vous lancez depuis la nouvelle AMI contient automatiquement des informations pour ces volumes. Pour de plus amples informations, veuillez consulter [Bloquer les mappages d'appareils pour les volumes sur les instances Amazon EC2](block-device-mapping-concepts.md).
## Conditions préalables
Avant de créer un AMI, vous devez terminer les tâches suivantes :
+ Installez les outils AMI. Pour de plus amples informations, veuillez consulter [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md).
+ Installez le AWS CLI. Pour plus d'informations, consultez [Démarrer avec le AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
+ Assurez-vous que vous disposez d'un compartiment S3 pour le bundle et que votre compartiment est ACLs activé. Pour plus d'informations sur la configuration ACLs, consultez [la section Configuration ACLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/managing-acls.html).
+ Pour créer un compartiment S3 à l'aide de AWS Management Console, ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)et choisissez **Create Bucket**.
+ Pour créer un compartiment S3 avec le AWS CLI, vous pouvez utiliser la commande [mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html). Si la version installée des outils AMI est la version 1.5.18 ou toute autre version ultérieure, vous pouvez également utiliser la commande `ec2-upload-bundle` pour créer le compartiment S3. Pour de plus amples informations, veuillez consulter [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle).
+ Assurez-vous que les fichiers de votre offre groupée ne sont pas cryptés dans le compartiment S3. Si vous avez besoin d’un chiffrement pour votre AMI, vous pouvez utiliser une AMI basée sur EBS à la place. Pour de plus amples informations, veuillez consulter [Utilisez le chiffrement avec EBS Backed AMIs](AMIEncryption.md).
+ Assurez-vous d'avoir votre identifiant de AWS compte. Pour plus d'informations, consultez la section [Afficher les Compte AWS identifiants](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html) dans le *Guide de référence AWS sur la gestion des comptes*.
+ Assurez-vous de disposer des informations d’identification nécessaires pour utiliser l’ AWS CLI. Pour plus d’informations, consultez la section [Authentification et contrôle d’accès pour l’ AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) dans le *Guide de l’utilisateur AWS Command Line Interface *.
+ Assurez-vous d’avoir un certificat X.509 et la clé privée correspondante.
+ Si vous avez besoin créer un certificat X.509, consultez la section [Gérer les certificats de signature](set-up-ami-tools.md#ami-tools-managing-certs). Le certificat X.509 et la clé privée sont utilisés pour chiffrer et déchiffrer votre AMI.
+ [Chine (Pékin)] Utilisez le certificat `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-cn-north-1.pem`.
+ [AWS GovCloud (US-West)] Utilisez le `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-gov.pem` certificat.
+ Connectez-vous à votre instance et personnalisez-la. Par exemple, vous pouvez installer des logiciels et des applications, copier des données, supprimer des fichiers temporaires et modifier la configuration Linux.
## Créer une AMI à partir d’une instance Amazon Linux
Les procédures suivantes décrivent comment créer une AMI à partir d’une instance avec un volume racine de stockage d’instance exécutant Amazon Linux 1. Elles peuvent ne pas fonctionner pour les instances exécutant d’autres distributions Linux.
**Pour se préparer à utiliser les outils AMI (instances HVM uniquement)**
1. Les outils AMI ont besoin de GRUB Legacy pour démarrer correctement. Utilisez la commande suivante pour installer GRUB :
```
[ec2-user ~]$ sudo yum install -y grub
```
1. Installez les packages de gestion de partition à l’aide de la commande suivante :
```
[ec2-user ~]$ sudo yum install -y gdisk kpartx parted
```
**Pour créer une AMI à partir d’une instance Amazon Linux avec un volume racine de stockage d’instance**
Cette procédure part du principe que vous avez respecté les prérequis dans [Conditions préalables](#bundle-ami-prerequisites).
Dans les commandes suivantes, remplacez chacune *user input placeholder* par vos propres informations.
1. Chargez vos informations d’identification sur votre instance. Nous utilisons ces informations d’identification pour garantir que seuls vous et Amazon EC2 peuvent accéder à votre AMI.
1. Créez un répertoire temporaire sur votre instance pour vos informations d’identification en suivant ce qui suit :
```
[ec2-user ~]$ mkdir /tmp/cert
```
Ceci vous permet d’exclure vos informations d’identification de l’image créée.
1. Copiez votre certificat X.509 et votre clé privée correspondante depuis votre ordinateur vers le répertoire `/tmp/cert` de votre instance en utilisant un outil de copie sécurisé tel que [scp](linux-file-transfer-scp.md). L’option `-i my-private-key.pem` de la commande **scp** suivante est la clé privée que vous utilisez pour vous connecter à votre instance avec SSH, et non la clé privée X.509. Exemples :
```
you@your_computer:~ $ scp -i my-private-key.pem /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem /path/to/cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem ec2-user@ec2-203-0-113-25.compute-1.amazonaws.com:/tmp/cert/
pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 717 0.7KB/s 00:00
cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 685 0.7KB/s 00:00
```
Sinon, étant donné qu’il s’agit de fichiers de texte brut, vous pouvez ouvrir le certificat et la clé dans un éditeur de texte et copier leur contenu dans de nouveaux fichiers dans le répertoire `/tmp/cert`.
1. Préparez le bundle à charger sur Amazon S3 en exécutant la commande [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) depuis votre instance. Assurez-vous de spécifier l’option `-e` pour exclure le répertoire où vos informations d’identification sont stockées. Par défaut, la création d’un bundle exclut les fichiers qui peuvent contenir des informations sensibles. Ces fichiers incluent `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` et `*/.bash_history`. Pour inclure tous ces fichiers, utilisez l’option `--no-filter`. Pour inclure certains de ces fichiers, utilisez l’option `--include`.
**Important**
Par défaut, le processus de création d’un bundle d’AMI génère un ensemble de fichiers compressés et chiffrés dans le répertoire `/tmp` qui représente le volume racine. Si vous n’avez pas suffisamment d’espace disque libre dans `/tmp` pour stocker le groupe, vous devez spécifier un emplacement différent pour qu’il soit stocké avec l’option `-d /path/to/bundle/storage`. Certaines instances disposent d’un stockage éphémère monté à `/mnt` ou `/media/ephemeral0` que vous pouvez utiliser, ou vous pouvez également créer, joindre et monter un nouveau volume Amazon EBS) afin de stocker l’offre groupé. Pour plus d’informations, consultez la section [Créer un volume Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html) dans le *Guide de l’utilisateur Amazon EBS*.
1. Vous devez exécuter la commande **ec2-bundle-vol** en tant que racine. Pour la plupart des commandes, vous pouvez utiliser **sudo** afin d’obtenir des autorisations d’un niveau élevé, mais dans ce cas, vous devriez exécuter **sudo -E su** pour conserver vos variables d’environnement.
```
[ec2-user ~]$ sudo -E su
```
Notez que l’invite de commande de Bash vous identifie maintenant en tant qu’utilisateur racine, et que le signe dollar a été remplacé par un hashtag, ce qui indique que vous êtes dans un shell racine :
```
[root ec2-user]#
```
1. Pour créer le bundle AMI, exécutez la commande [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) comme suit :
```
[root ec2-user]# ec2-bundle-vol -k /tmp/cert/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c /tmp/cert/cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 123456789012 -r x86_64 -e /tmp/cert --partition gpt
```
**Note**
Pour les régions de Chine (Pékin) et AWS GovCloud (ouest des États-Unis), utilisez le `--ec2cert` paramètre et spécifiez les certificats conformément aux [prérequis](#bundle-ami-prerequisites).
La création de l’image peut prendre quelques minutes. Lorsque cette commande est exécutée, votre répertoire `/tmp` (ou un répertoire autre que celui par défaut) contient le bundle (`image.manifest.xml`, ainsi que plusieurs `image.part.` *xx* fichiers).
1. Quittez le shell racine.
```
[root ec2-user]# exit
```
1. (Facultatif) Pour ajouter davantage de volumes de stockage d’instance, modifiez les mappages de périphérique de stockage en mode bloc dans le fichier `image.manifest.xml` pour votre AMI. Pour plus d’informations, consultez [Bloquer les mappages d'appareils pour les volumes sur les instances Amazon EC2](block-device-mapping-concepts.md).
1. Créez une sauvegarde de votre fichier `image.manifest.xml`.
```
[ec2-user ~]$ sudo cp /tmp/image.manifest.xml /tmp/image.manifest.xml.bak
```
1. Reformatez le fichier `image.manifest.xml` pour qu’il soit plus facile à lire et à modifier.
```
[ec2-user ~]$ sudo xmllint --format /tmp/image.manifest.xml.bak > /tmp/image.manifest.xml
```
1. Modifiez les mappages de périphérique de stockage en mode bloc dans `image.manifest.xml` avec un éditeur de texte. L’exemple ci-dessous montre une nouvelle entrée pour le volume de stockage d’instance `ephemeral1`.
**Note**
Pour obtenir la liste des fichiers exclus, consultez [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol).
```
ami
sda
ephemeral0
sdb
ephemeral1
sdc
root
/dev/sda1
```
1. Enregistrez le fichier `image.manifest.xml` et quittez votre éditeur de texte.
1. Pour charger votre bundle sur Amazon S3, exécutez la commande [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle) comme suit.
```
[ec2-user ~]$ ec2-upload-bundle -b amzn-s3-demo-bucket/bundle_folder/bundle_name -m /tmp/image.manifest.xml -a your_access_key_id -s your_secret_access_key
```
**Important**
Pour inscrire votre AMI dans une région autre que US East (N. Virginia), vous devez spécifier à la fois la région cible avec l’option `--region` et un chemin de compartiment qui existe déjà dans la région cible ou un chemin de compartiment unique qui peut être créé dans la région cible.
1. (Facultatif) Une fois que le groupe est chargé sur Amazon S3, vous pouvez le supprimer du répertoire `/tmp` sur l’instance en utilisant la commande **rm** suivante :
```
[ec2-user ~]$ sudo rm /tmp/image.manifest.xml /tmp/image.part.* /tmp/image
```
**Important**
Si vous avez spécifié un chemin avec l’option `-d /path/to/bundle/storage` dans [Step 2](#step_with_bundle_path_amazon_linux), utilisez ce chemin à la place de `/tmp`.
1. Pour inscrire votre AMI, exécutez la commande [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) comme suit.
```
[ec2-user ~]$ aws ec2 register-image --image-location amzn-s3-demo-bucket/bundle_folder/bundle_name/image.manifest.xml --name AMI_name --virtualization-type hvm
```
**Important**
Si vous avez précédemment spécifié une région pour la commande [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle), spécifiez de nouveau cette région pour cette commande.
# Configurer les outils AMI Amazon EC2
Vous pouvez utiliser les outils AMI pour créer et gérer un système Linux basé sur Amazon S3. AMIs Pour utiliser ces outils, vous devez les installer sur votre instance Linux. Les outils AMI sont disponibles sous forme de fichiers RPM et .zip pour les distributions Linux ne prenant pas en charge RPM.
**Pour installer les outils AMI à l’aide d’un fichier RPM**
1. Installez Ruby en utilisant le gestionnaire de package pour votre distribution de Linux, par exemple yum. Exemples :
```
[ec2-user ~]$ sudo yum install -y ruby
```
1. Téléchargez le fichier RPM à l’aide d’un outil tel que wget ou curl. Exemples :
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.noarch.rpm
```
1. Vérifiez la signature du fichier RPM en utilisant la commande suivante :
```
[ec2-user ~]$ rpm -K ec2-ami-tools.noarch.rpm
```
La commande ci-dessus doit indiquer que le fichier SHA1 et les MD5 hachages sont. `OK.` Si la commande indique que les hachages le sont`NOT OK`, utilisez la commande suivante pour afficher l'en-tête SHA1 et MD5 les hachages du fichier :
```
[ec2-user ~]$ rpm -Kv ec2-ami-tools.noarch.rpm
```
Comparez ensuite l'en-tête SHA1 et les hachages de votre fichier avec MD5 les hachages vérifiés des outils AMI suivants pour confirmer l'authenticité du fichier :
+ En-tête SHA1 : a1f662d6f25f69871104e6a62187fa4df508f880
+ MD5: 9faff05258064e2f7909b66142de6782
Si l'en-tête SHA1 et les MD5 hachages de votre fichier correspondent aux hachages vérifiés des outils AMI, passez à l'étape suivante.
1. Installez le fichier RPM à l’aide de la commande suivante:
```
[ec2-user ~]$ sudo yum install ec2-ami-tools.noarch.rpm
```
1. Vérifiez l’installation de vos outils AMI avec la commande [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**Note**
Si vous recevez une erreur de chargement du type « impossible de charger ce fichier -- ec2/amitools/version (LoadError) », passez à l'étape suivante pour ajouter l'emplacement de l'installation de vos outils AMI à votre chemin. `RUBYLIB`
1. (Facultatif) Si vous avez reçu une erreur à l’étape précédente, ajoutez l’emplacement d’installation de vos outils AMI pour votre chemin d’accès `RUBYLIB`.
1. Exécutez la commande suivante afin de déterminer les chemins à ajouter.
```
[ec2-user ~]$ rpm -qil ec2-ami-tools | grep ec2/amitools/version
/usr/lib/ruby/site_ruby/ec2/amitools/version.rb
/usr/lib64/ruby/site_ruby/ec2/amitools/version.rb
```
Dans l’exemple ci-dessus, le fichier manquant à partir de l’erreur de chargement précédente est situé aux emplacements `/usr/lib/ruby/site_ruby` et `/usr/lib64/ruby/site_ruby`.
1. Ajoutez les emplacements à partir de l’étape précédente pour votre chemin d’accès. `RUBYLIB`
```
[ec2-user ~]$ export RUBYLIB=$RUBYLIB:/usr/lib/ruby/site_ruby:/usr/lib64/ruby/site_ruby
```
1. Vérifiez l’installation de vos outils AMI avec la commande [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**Pour installer les outils AMI à l’aide du fichier .zip**
1. Installez Ruby et décompressez en utilisant le gestionnaire de package pour votre distribution de Linux, comme **apt-get**. Exemples :
```
[ec2-user ~]$ sudo apt-get update -y && sudo apt-get install -y ruby unzip
```
1. Téléchargez le fichier .zip à l’aide d’un outil tel que wget ou curl. Exemples :
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.zip
```
1. Décompressez les fichiers dans un répertoire d’installation approprié, tel que `/usr/local/ec2`.
```
[ec2-user ~]$ sudo mkdir -p /usr/local/ec2
$ sudo unzip ec2-ami-tools.zip -d /usr/local/ec2
```
Notez que le fichier .zip contient un dossier ec2-ami-tools-. *x* *x*. *x*, où*x*. *x*. *x*est le numéro de version des outils (par exemple,`ec2-ami-tools-1.5.7`).
1. Définissez la variable d’environnement `EC2_AMITOOL_HOME` sur le répertoire d’installation des outils. Exemples :
```
[ec2-user ~]$ export EC2_AMITOOL_HOME=/usr/local/ec2/ec2-ami-tools-x.x.x
```
1. Ajoutez les outils à votre variable d’environnement `PATH`. Exemples :
```
[ec2-user ~]$ export PATH=$EC2_AMITOOL_HOME/bin:$PATH
```
1. Vous pouvez vérifier l’installation de vos outils AMI avec la commande [ec2- ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
## Gérer les certificats de signature
Certaines commandes dans les outils AMI nécessitent un certificat de signature (également appelé certificat X.509). Vous devez créer le certificat, puis le télécharger sur AWS. Par exemple, vous pouvez utiliser un outil tiers tel que OpenSSL pour créer le certificat.
**Pour créer un certificat de signature**
1. Installer et configurer OpenSSL.
1. Créez une clé privée à l’aide de la commande `openssl genrsa` et enregistrez la sortie dans un fichier `.pem`. Nous vous recommandons de créer une clé RSA 2048 bits ou 4096 bits.
```
openssl genrsa 2048 > private-key.pem
```
1. Générez un certificat à l’aide de la commande `openssl req`.
```
openssl req -new -x509 -nodes -sha256 -days 365 -key private-key.pem -outform PEM -out certificate.pem
```
Pour télécharger le certificat sur AWS, utilisez la [upload-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/upload-signing-certificate.html)commande.
```
aws iam upload-signing-certificate --user-name user-name --certificate-body file://path/to/certificate.pem
```
Pour répertorier les certificats d'un utilisateur, utilisez la [list-signing-certificates](https://docs.aws.amazon.com/cli/latest/reference/iam/list-signing-certificates.html)commande :
```
aws iam list-signing-certificates --user-name user-name
```
Pour désactiver ou réactiver un certificat de signature pour un utilisateur, utilisez la [update-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/update-signing-certificate.html)commande. La commande suivante désactive le certificat :
```
aws iam update-signing-certificate --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE --status Inactive --user-name user-name
```
Pour supprimer un certificat, utilisez la [delete-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-signing-certificate.html)commande suivante :
```
aws iam delete-signing-certificate --user-name user-name --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE
```
# Référence des outils Amazon EC2 AMI
Vous pouvez utiliser les commandes des outils AMI pour créer et gérer un système Linux basé sur Amazon S3. AMIs Pour installer les outils, consultez [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md).
Pour plus d’informations sur vos clés d’accès, consultez la section [Gestion des clés d’accès pour les utilisateurs IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) dans le *Guide de l’utilisateur IAM*.
**Topics**
+ [ec2- ami-tools-version](#ami-tools-version)
+ [ec2-bundle-image](#ami-bundle-image)
+ [ec2-bundle-vol](#ami-bundle-vol)
+ [ec2-delete-bundle](#ami-delete-bundle)
+ [ec2-download-bundle](#ami-download-bundle)
+ [ec2-migrate-manifest](#ami-migrate-manifest)
+ [ec2-unbundle](#ami-unbundle)
+ [ec2-upload-bundle](#ami-upload-bundle)
+ [Options courantes pour les outils AMI](#common-args-ami)
## ec2- ami-tools-version
### Description
Décrit la version des outils AMI.
### Syntaxe
**ec2-ami-tools-version**
### Output
Informations de version.
### Exemple
Cet exemple de commande affiche les informations de version des outils AMI que vous utilisez.
```
[ec2-user ~]$ ec2-ami-tools-version
1.5.2 20071010
```
## ec2-bundle-image
### Description
Crée une AMI Linux prise en charge par Amazon S3 à partir d’une image du système d’exploitation créée dans un fichier de boucle.
### Syntaxe
****ec2-bundle-image** -c *path* -k *path* -u *account* -i *path* [-d *path*] [--ec2cert *path*] [-r *architecture*] [--productcodes *code1*,*code2*,...] [-B *mapping*] [-p *prefix*]**
### Options
`-c, --cert` *chemin*
Fichier de certificat de clé publique RSA code PEM de l’utilisateur.
Obligatoire : oui
`-k, --privatekey` *chemin*
Chemin d’accès à un fichier de clé RSA codée PEM. Vous devrez également spécifier cette clé pour dissocier ce groupe, conservez-la dans un endroit sûr. Notez qu'il n'est pas nécessaire que la clé soit enregistrée sur votre AWS compte.
Obligatoire : oui
`-u, --user ` *compte*
L'identifiant du AWS compte de l'utilisateur, sans tirets.
Obligatoire : oui
`-i, --image` *chemin*
Chemin d’accès à l’image à grouper.
Obligatoire : oui
`-d, --destination` *chemin*
Répertoire dans lequel vous créez le groupe.
Par défaut: `/tmp`
Obligatoire : non
`--ec2cert` *chemin*
Le chemin d'accès au certificat de clé publique Amazon EC2 X.509 utilisé pour chiffrer le manifeste d'image.
Les régions `us-gov-west-1`et `cn-north-1` utilisent un certificat de clé publique par défaut. Le chemin d’accès à ce certificat doit être spécifié avec cette option. Le chemin d’accès au certificat varie selon la méthode d’installation des outils AMI. Pour Amazon Linux, les certificats se trouvent à l’adresse `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Si vous avez installé les outils AMI à partir du fichier RPM ou ZIP dans [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md), les certificats se trouvent à l’adresse `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obligatoire : uniquement pour les régions `us-gov-west-1` et `cn-north-1`.
`-r, --arch` *architecture*
Architecture d’image. Si vous ne fournissez pas l’architecture dans la ligne de commande, vous serez invité à la saisir au début de la création du bundle.
Valeurs valides : `i386` \$1 `x86_64`
Obligatoire : non
`--productcodes` *code1,code2,...*
Codes de produit à attacher à l’image au moment de l’inscription, séparé par des virgules.
Obligatoire : non
`-B, --block-device-mapping` *mappage*
Définit la façon dont les périphériques de stockage en mode bloc sont exposés à une instance de AMI si son type d’instance prend en charge le périphérique spécifié.
Spécifiez une liste séparée par des virgules de paires clé-valeur, où chaque clé est un nom virtuel et chaque valeur le nom de périphérique correspondant. Les noms virtuels incluent les éléments suivants :
+ `ami`— Périphérique du système de fichiers racine, tel qu’il est vu par l’instance
+ `root`— Périphérique du système de fichiers racine, tel qu’il est vu par le noyau
+ `swap`— Périphérique d’échange, tel qu’il est vu par l’instance
+ `ephemeralN`—Volume de stockage de la nième instance
Obligatoire : non
`-p, --prefix` *prefix*
Préfixe du nom des fichiers AMI groupés.
Par défaut : nom du fichier image. Par exemple, si le chemin d’accès de l’image est `/var/spool/my-image/version-2/debian.img`, le préfixe par défaut est `debian.img`.
Obligatoire : non
`--kernel` *kernel\$1id*
Obsolète. Utilisez [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) pour définir le noyau.
Obligatoire : non
`--ramdisk` *ramdisk\$1id*
Obsolète. Utilisez [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) pour définir le disque RAM le cas échéant.
Obligatoire : non
### Output
Messages d’état décrivant les étapes et le statut du processus de groupement.
### Exemple
Cet exemple crée une AMI groupée à partir d’une image du système d’exploitation qui a été créée dans un fichier de boucle.
```
[ec2-user ~]$ ec2-bundle-image -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 111122223333 -i image.img -d bundled/ -r x86_64
Please specify a value for arch [i386]:
Bundling image file...
Splitting bundled/image.gz.crypt...
Created image.part.00
Created image.part.01
Created image.part.02
Created image.part.03
Created image.part.04
Created image.part.05
Created image.part.06
Created image.part.07
Created image.part.08
Created image.part.09
Created image.part.10
Created image.part.11
Created image.part.12
Created image.part.13
Created image.part.14
Generating digests for each part...
Digests generated.
Creating bundle manifest...
ec2-bundle-image complete.
```
## ec2-bundle-vol
### Description
Crée une AMI Linux prise en charge par Amazon S3 en compressant, effectuant le chiffrement et signant une copie du volume racine de l’instance.
Amazon EC2 tente d'hériter des codes produits, des paramètres du noyau, des paramètres du disque RAM et de bloquer les mappages de périphériques depuis l'instance.
Par défaut, la création d’un bundle exclut les fichiers qui peuvent contenir des informations sensibles. Ces fichiers incluent `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` et `*/.bash_history`. Pour inclure tous ces fichiers, utilisez l’option `--no-filter`. Pour inclure certains de ces fichiers, utilisez l’option `--include`.
Pour plus d’informations, consultez [Création d’une AMI basée sur Amazon S3](creating-an-ami-instance-store.md).
### Syntaxe
****ec2-bundle-vol** -c *path* -k *path* -u *account* [-d *path*] [--ec2cert *path*] [-r *architecture*] [--productcodes *code1*,*code2*,...] [-B *mapping*] [--all] [-e *directory1*,*directory2*,...] [-i *file1*,*file2*,...] [--no-filter] [-p *prefix*] [-s *size*] [--[no-]inherit] [-v *volume*] [-P *type*] [-S *script*] [--fstab *path*] [--generate-fstab] [--grub-config *path*]**
### Options
`-c, --cert` *chemin*
Fichier de certificat de clé publique RSA code PEM de l’utilisateur.
Obligatoire : oui
`-k, --privatekey ` *chemin*
Chemin d’accès au fichier de clé RSA codé PEM de l’utilisateur.
Obligatoire : oui
`-u, --user` *compte*
L'identifiant du AWS compte de l'utilisateur, sans tirets.
Obligatoire : oui
`-d, --destination` *destination*
Répertoire dans lequel vous créez le groupe.
Par défaut: `/tmp`
Obligatoire : non
`--ec2cert` *chemin*
Le chemin d'accès au certificat de clé publique Amazon EC2 X.509 utilisé pour chiffrer le manifeste d'image.
Les régions `us-gov-west-1`et `cn-north-1` utilisent un certificat de clé publique par défaut. Le chemin d’accès à ce certificat doit être spécifié avec cette option. Le chemin d’accès au certificat varie selon la méthode d’installation des outils AMI. Pour Amazon Linux, les certificats se trouvent à l’adresse `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Si vous avez installé les outils AMI à partir du fichier RPM ou ZIP dans [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md), les certificats se trouvent à l’adresse `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obligatoire : uniquement pour les régions `us-gov-west-1` et `cn-north-1`.
`-r, --arch ` *architecture*
Architecture de l’image. Si vous ne fournissez pas cette ligne de commande, vous serez invité à la saisir au début de la création du bundle.
Valeurs valides : `i386` \$1 `x86_64`
Obligatoire : non
`--productcodes` *code1,code2,...*
Codes de produit à attacher à l’image au moment de l’inscription, séparé par des virgules.
Obligatoire : non
`-B, --block-device-mapping` *mappage*
Définit la façon dont les périphériques de stockage en mode bloc sont exposés à une instance de AMI si son type d’instance prend en charge le périphérique spécifié.
Spécifiez une liste séparée par des virgules de paires clé-valeur, où chaque clé est un nom virtuel et chaque valeur le nom de périphérique correspondant. Les noms virtuels incluent les éléments suivants :
+ `ami`— Périphérique du système de fichiers racine, tel qu’il est vu par l’instance
+ `root`— Périphérique du système de fichiers racine, tel qu’il est vu par le noyau
+ `swap`— Périphérique d’échange, tel qu’il est vu par l’instance
+ `ephemeralN`—Volume de stockage de la nième instance
Obligatoire : non
`-a, --all`
Groupez tous les répertoires, y compris ceux contenus dans les systèmes de fichiers montés à distance.
Obligatoire : non
`-e, --exclude ` *directory1,directory2,...*
Liste des chemins absolus de répertoires et fichiers à exclure de l’opération de groupement. Ce paramètre remplace l’option `--all`. Lorsque la commande exclude est spécifié, les répertoires et sous-répertoires répertoriés avec le paramètre ne sont pas groupés avec le volume.
Obligatoire : non
`-i, --include ` *file1,file2,...*
Liste des fichiers à inclure dans l’opération de groupement. Les fichiers spécifiés seraient autrement exclus de l’ AMI car ils peuvent contenir des informations sensibles.
Obligatoire : non
`--no-filter`
Si ce paramètre est spécifié, nous n’excluons pas les fichiers de l’AMI, car ils peuvent contenir des informations sensibles.
Obligatoire : non
`-p, --prefix ` *prefix*
Préfixe du nom des fichiers AMI groupés.
Par défaut: `image`
Obligatoire : non
`-s, --size` *taille*
Taille, en Mo (1024 \$1 1024 octets), du fichier image à créer. La taille maximale est 10 240 Mo.
Par défaut: 10240
Obligatoire : non
`--[no-]inherit`
Indique si l’image doit hériter des métadonnées de l’instance (la valeur par défaut consiste à hériter). Le groupement échoue si vous activez `--inherit`, mais les métadonnées d’instance ne sont pas accessibles.
Obligatoire : non
`-v, --volume ` *volume*
Chemin d’accès absolu au volume monté à partir duquel créer le groupe.
Par défaut : le répertoire racine (/)
Obligatoire : non
`-P, --partition` *type*
Indique si l’image de disque doit utiliser une table de partition. Si vous ne spécifiez pas de type de table de partition, la valeur par défaut est le type utilisé sur le périphérique de stockage en mode bloc parent du volume, le cas échéant. Dans le cas contraire, la valeur par défaut est `gpt`.
Valeurs valides : `mbr` \$1 `gpt` \$1 `none`
Obligatoire : non
`-S, --script` *script*
Script de personnalisation à exécuter juste avant de procéder à la création du bundle. Le script doit attendre un seul argument, le point de montage du volume.
Obligatoire : non
`--fstab` *chemin*
Chemin d’accès au fichier fstab à grouper dans l’image. Si cela n'est pas spécifié, Amazon EC2 regroupe /etc/fstab.
Obligatoire : non
`--generate-fstab`
Regroupe le volume à l'aide d'un fichier fstab EC2 fourni par Amazon.
Obligatoire : non
`--grub-config`
Chemin d’accès à un autre fichier de configuration grub à grouper dans l’image. Par défaut, `ec2-bundle-vol` attend `/boot/grub/menu.lst` ou `/boot/grub/grub.conf` pour exister sur l’image clonée. Cette option vous permet de spécifier un chemin d’accès à un autre fichier de configuration grub, qui sera ensuite copié par-dessus les valeurs par défaut (le cas échéant).
Obligatoire : non
`--kernel` *kernel\$1id*
Obsolète. Utilisez [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) pour définir le noyau.
Obligatoire : non
`--ramdisk`*ramdisk\$1id*
Obsolète. Utilisez [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) pour définir le disque RAM le cas échéant.
Obligatoire : non
### Output
Messages d’état décrivant les étapes et le statut de la création du bundle.
### Exemple
Cet exemple crée un groupe AMI par compression, chiffrement et signature d’un instantané du système de fichiers racine de l’ordinateur local.
```
[ec2-user ~]$ ec2-bundle-vol -d /mnt -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -c cert-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -u 111122223333 -r x86_64
Copying / into the image file /mnt/image...
Excluding:
sys
dev/shm
proc
dev/pts
proc/sys/fs/binfmt_misc
dev
media
mnt
proc
sys
tmp/image
mnt/img-mnt
1+0 records in
1+0 records out
mke2fs 1.38 (30-Jun-2005)
warning: 256 blocks unused.
Splitting /mnt/image.gz.crypt...
Created image.part.00
Created image.part.01
Created image.part.02
Created image.part.03
...
Created image.part.22
Created image.part.23
Generating digests for each part...
Digests generated.
Creating bundle manifest...
Bundle Volume complete.
```
## ec2-delete-bundle
### Description
Supprime le groupe spécifié du stockage Amazon S3. Une fois que vous supprimez un groupe, vous ne pouvez pas lancer d’instances à partir de l’AMI correspondante.
### Syntaxe
****ec2-delete-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* [-t *token*] [--url *url*] [--region *region*] [--sigv *version*] [-m *path*] [-p *prefix*] [--clear] [--retry] [-y]**
### Options
`-b, --bucket `*bucket*
Le nom du compartiment Amazon S3 contenant l’AMI groupée, suivi d’un préfixe de chemin facultatif séparé par des « / »
Obligatoire : oui
`-a, --access-key` *access\$1key\$1id*
L'ID de la clé d' AWS accès.
Obligatoire : oui
`-s, --secret-key` *secret\$1access\$1key*
La clé d'accès AWS secrète.
Obligatoire : oui
`-t, --delegation-token` *jeton*
Le jeton de délégation à transmettre à la AWS demande. Pour plus d’informations, consultez la section [Informations d’identification de sécurité temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) dans le *Guide de l’utilisateur IAM*.
Requis : uniquement lorsque vous utilisez des informations d’identification de sécurité temporaires.
Par défaut : valeur de la variable d’environnement `AWS_DELEGATION_TOKEN` (si elle est définie).
`--region`*region*
Région à utiliser dans la signature de la demande.
Valeur par défaut : `us-east-1`
Requis : requis si vous utilisez Signature Version 4
`--sigv`*Version*
Version de signature à utiliser lors de la signature de la demande.
Valeurs valides : `2` \$1 `4`
Par défaut: `4`
Obligatoire : non
`-m, --manifest`*chemin*
Chemin d’accès au fichier manifeste.
Requis : vous devez spécifier `--prefix` ou `--manifest`.
`-p, --prefix` *prefix*
Préfixe du nom de fichier AMI groupé. Fournissez le préfixe entier. Par exemple, si le préfixe est image.img, utilisez `-p image.img`, non `-p image`.
Requis : vous devez spécifier `--prefix` ou `--manifest`.
`--clear`
Supprime le compartiment Amazon S3 s’il est vide après la suppression du groupe spécifié.
Obligatoire : non
`--retry`
Refait automatiquement des tentatives sur toutes les erreurs Amazon S3, jusqu’à cinq fois par opération.
Obligatoire : non
`-y, --yes`
Suppose automatiquement que la réponse à toutes les invites est oui.
Obligatoire : non
### Output
Amazon EC2 affiche des messages d'état indiquant les étapes et le statut du processus de suppression.
### Exemple
Cet exemple supprime un groupe de Amazon S3.
```
[ec2-user ~]$ ec2-delete-bundle -b amzn-s3-demo-bucket -a your_access_key_id -s your_secret_access_key
Deleting files:
amzn-s3-demo-bucket/image.manifest.xml
amzn-s3-demo-bucket/image.part.00
amzn-s3-demo-bucket/image.part.01
amzn-s3-demo-bucket/image.part.02
amzn-s3-demo-bucket/image.part.03
amzn-s3-demo-bucket/image.part.04
amzn-s3-demo-bucket/image.part.05
amzn-s3-demo-bucket/image.part.06
Continue? [y/n]
y
Deleted amzn-s3-demo-bucket/image.manifest.xml
Deleted amzn-s3-demo-bucket/image.part.00
Deleted amzn-s3-demo-bucket/image.part.01
Deleted amzn-s3-demo-bucket/image.part.02
Deleted amzn-s3-demo-bucket/image.part.03
Deleted amzn-s3-demo-bucket/image.part.04
Deleted amzn-s3-demo-bucket/image.part.05
Deleted amzn-s3-demo-bucket/image.part.06
ec2-delete-bundle complete.
```
## ec2-download-bundle
### Description
Télécharge le système Linux soutenu par Amazon S3 spécifié AMIs depuis le stockage Amazon S3.
### Syntaxe
****ec2-download-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* -k *path* [--url *url*] [--region *region*] [--sigv *version*] [-m *file*] [-p *prefix*] [-d *directory*] [--retry]**
### Options
`-b, --bucket` *compartiment*
Nom du compartiment Amazon S3 où se trouve le groupe, suivi d’un préfixe de chemin séparé par des « / »-facultatif.
Obligatoire : oui
`-a, --access-key` *access\$1key\$1id*
L'ID de la clé d' AWS accès.
Obligatoire : oui
`-s, --secret-key` *secret\$1access\$1key*
La clé d'accès AWS secrète.
Obligatoire : oui
`-k, --privatekey` *chemin*
Clé privée utilisée pour déchiffrer le manifeste.
Obligatoire : oui
`--url` *url*
URL du service Amazon S3.
Par défaut: `https://s3.amazonaws.com/`
Obligatoire : non
`--region` *région*
Région à utiliser dans la signature de la demande.
Valeur par défaut : `us-east-1`
Requis : requis si vous utilisez Signature Version 4
`--sigv` *version*
Version de signature à utiliser lors de la signature de la demande.
Valeurs valides : `2` \$1 `4`
Par défaut: `4`
Obligatoire : non
`-m, --manifest` *file*
Nom du fichier manifeste (sans le chemin d’accès). Nous vous recommandons de spécifier soit le manifeste (`-m`) soit un préfixe (`-p`).
Obligatoire : non
`-p, --prefix ` *prefix*
Préfixe du nom des fichiers AMI groupés.
Par défaut: `image`
Obligatoire : non
`-d, --directory ` *directory*
Répertoire dans lequel le groupe téléchargé est enregistré. Le répertoire doit exister.
Par défaut : le répertoire de travail actuel.
Obligatoire : non
`--retry`
Refait automatiquement des tentatives sur toutes les erreurs Amazon S3, jusqu’à cinq fois par opération.
Obligatoire : non
### Output
Les messages d’état indiquant les différentes étapes du processus de téléchargement s’affichent.
### Exemple
Cet exemple crée le répertoire `bundled` (à l’aide de la commande Linux **mkdir**) et télécharge le groupe depuis le compartiment Amazon S3 `amzn-s3-demo-bucket`.
```
[ec2-user ~]$ mkdir bundled
[ec2-user ~]$ ec2-download-bundle -b amzn-s3-demo-bucket/bundles/bundle_name -m image.manifest.xml -a your_access_key_id -s your_secret_access_key -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -d mybundle
Downloading manifest image.manifest.xml from amzn-s3-demo-bucket to mybundle/image.manifest.xml ...
Downloading part image.part.00 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.00 ...
Downloaded image.part.00 from amzn-s3-demo-bucket
Downloading part image.part.01 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.01 ...
Downloaded image.part.01 from amzn-s3-demo-bucket
Downloading part image.part.02 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.02 ...
Downloaded image.part.02 from amzn-s3-demo-bucket
Downloading part image.part.03 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.03 ...
Downloaded image.part.03 from amzn-s3-demo-bucket
Downloading part image.part.04 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.04 ...
Downloaded image.part.04 from amzn-s3-demo-bucket
Downloading part image.part.05 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.05 ...
Downloaded image.part.05 from amzn-s3-demo-bucket
Downloading part image.part.06 from amzn-s3-demo-bucket/bundles/bundle_name to mybundle/image.part.06 ...
Downloaded image.part.06 from amzn-s3-demo-bucket
```
## ec2-migrate-manifest
### Description
Modifie une AMI Linux basée sur Amazon S3 (par exemple, son certificat, son noyau et son disque RAM) de sorte qu’elle prenne en charge une autre région.
### Syntaxe
****ec2-migrate-manifest** -c *path* -k *path* -m *path* \$1(-a *access\$1key\$1id* -s *secret\$1access\$1key* --region *region*) \$1 (--no-mapping)\$1 [--ec2cert *ec2\$1cert\$1path*] [--kernel *kernel-id*] [--ramdisk *ramdisk\$1id*]**
### Options
`-c, --cert` *chemin*
Fichier de certificat de clé publique RSA code PEM de l’utilisateur.
Obligatoire : oui
`-k, --privatekey` *chemin*
Chemin d’accès au fichier de clé RSA codé PEM de l’utilisateur.
Obligatoire : oui
`--manifest` *chemin*
Chemin d’accès au fichier manifeste.
Obligatoire : oui
`-a, --access-key` *access\$1key\$1id*
L'ID de la clé d' AWS accès.
Requis : requis si vous utilisez le mappage automatique.
`-s, --secret-key ` *secret\$1access\$1key*
La clé d'accès AWS secrète.
Requis : requis si vous utilisez le mappage automatique.
`--region` *région*
Région à rechercher dans le fichier de mappage.
Requis : requis si vous utilisez le mappage automatique.
`--no-mapping`
Désactive le mappage automatique des noyaux et disques RAM.
Pendant la migration, Amazon EC2 remplace le noyau et le disque RAM du fichier manifeste par un noyau et un disque RAM conçus pour la région de destination. Si le paramètre `--no-mapping` n’est pas fourni, `ec2-migrate-bundle` peut utiliser les opérations `DescribeRegions` et `DescribeImages` pour effectuer les mappages automatiques.
Requis : requis si vous ne fournissez pas les options `-a`, `-s` et `--region` utilisées pour le mappage automatique.
`--ec2cert` *chemin*
Le chemin d'accès au certificat de clé publique Amazon EC2 X.509 utilisé pour chiffrer le manifeste d'image.
Les régions `us-gov-west-1`et `cn-north-1` utilisent un certificat de clé publique par défaut. Le chemin d’accès à ce certificat doit être spécifié avec cette option. Le chemin d’accès au certificat varie selon la méthode d’installation des outils AMI. Pour Amazon Linux, les certificats se trouvent à l'adresse `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Si vous avez installé les outils AMI à partir du fichier ZIP dans [Configurer les outils AMI Amazon EC2](set-up-ami-tools.md), les certificats se trouvent à l’adresse `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obligatoire : uniquement pour les régions `us-gov-west-1` et `cn-north-1`.
`--kernel` *kernel\$1id*
ID du noyau à sélectionner.
Nous vous recommandons d’utiliser PV-GRUB au lieu des noyaux et des disques RAM. Pour plus d’informations, consultez la section [Noyaux fournis par l’utilisateur](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) dans le *Guide de l’utilisateur Amazon Linux 2*.
Obligatoire : non
`--ramdisk` *ramdisk\$1id*
ID du disque RAM à sélectionner.
Nous vous recommandons d’utiliser PV-GRUB au lieu des noyaux et des disques RAM. Pour plus d’informations, consultez la section [Noyaux fournis par l’utilisateur](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) dans le *Guide de l’utilisateur Amazon Linux 2*.
Obligatoire : non
### Output
Messages d’état décrivant les étapes et le statut du processus de groupement.
### Exemple
Cet exemple copie l’AMI spécifiée dans le fichier manifeste `my-ami.manifest.xml` depuis les États-Unis vers l’Union européenne.
```
[ec2-user ~]$ ec2-migrate-manifest --manifest my-ami.manifest.xml --cert cert-HKZYKTAIG2ECMXYIBH3HXV4ZBZQ55CLO.pem --privatekey pk-HKZYKTAIG2ECMXYIBH3HXV4ZBZQ55CLO.pem --region eu-west-1
Backing up manifest...
Successfully migrated my-ami.manifest.xml It is now suitable for use in eu-west-1.
```
## ec2-unbundle
### Description
Recrée le groupe à partir d’une AMI Linux basée sur Amazon S3.
### Syntaxe
****ec2-unbundle** -k *path* -m *path* [-s *source\$1directory*] [-d *destination\$1directory*]**
### Options
`-k, --privatekey` *chemin*
Chemin d’accès à votre fichier de clé RSA codée PEM.
Obligatoire : oui
`-m, --manifest` *chemin*
Chemin d’accès au fichier manifeste.
Obligatoire : oui
`-s, --source` *source\$1directory*
Répertoire contenant le groupe.
Par défaut : le répertoire actuel.
Obligatoire : non
`-d, --destination` *destination\$1directory*
Répertoire dans lequel dégrouper l’AMI. Le répertoire de destination doit exister.
Par défaut : le répertoire actuel.
Obligatoire : non
### Exemple
Cet exemple Linux et UNIX dégroupe l’AMI spécifiée dans le fichier `image.manifest.xml`.
```
[ec2-user ~]$ mkdir unbundled
$ ec2-unbundle -m mybundle/image.manifest.xml -k pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -s mybundle -d unbundled
$ ls -l unbundled
total 1025008
-rw-r--r-- 1 root root 1048578048 Aug 25 23:46 image.img
```
### Output
Les messages d’état indiquant les différentes étapes du processus de dégroupement s’affichent.
## ec2-upload-bundle
### Description
Télécharge le bundle pour une AMI Linux basée sur Amazon S3 sur Amazon S3 et définit les listes de contrôle d'accès appropriées (ACLs) sur les objets chargés. Pour de plus amples informations, veuillez consulter [Création d’une AMI basée sur Amazon S3](creating-an-ami-instance-store.md).
**Note**
Pour télécharger des objets dans un compartiment S3 pour votre AMI Linux basée sur Amazon S3, vous ACLs devez activer le compartiment. Dans le cas contraire, Amazon ne EC2 sera pas en mesure ACLs de définir les objets à télécharger. Si votre compartiment de destination utilise le paramètre imposé par le propriétaire du compartiment pour la propriété des objets S3, cela ne fonctionnera pas car ils ACLs sont désactivés. Pour plus d'informations, consultez les [sections Contrôle de la propriété des objets et désactivation ACLs de votre compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html).
### Syntaxe
****ec2-upload-bundle** -b *bucket* -a *access\$1key\$1id* -s *secret\$1access\$1key* [-t *token*] -m *path* [--url *url*] [--region *region*] [--sigv *version*] [--acl *acl*] [-d *directory*] [--part *part*] [--retry] [--skipmanifest]**
### Options
`-b, --bucket` *compartiment*
Nom du compartiment Amazon S3 dans lequel stocker le groupe, suivi d’un préfixe de chemin séparé par des « / » facultatif. Si le compartiment n’existe pas, il est créé si le nom de compartiment est disponible. En outre, si le bucket n'existe pas et que la version des outils AMI est 1.5.18 ou ultérieure, cette commande définit le ACLs bucket.
Obligatoire : oui
`-a, --access-key` *access\$1key\$1id*
L'identifiant de votre clé d' AWS accès.
Obligatoire : oui
`-s, --secret-key` *secret\$1access\$1key*
Votre clé d'accès AWS secrète.
Obligatoire : oui
`-t, --delegation-token` *jeton*
Le jeton de délégation à transmettre à la AWS demande. Pour plus d’informations, consultez la section [Informations d’identification de sécurité temporaires](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) dans le *Guide de l’utilisateur IAM*.
Requis : uniquement lorsque vous utilisez des informations d’identification de sécurité temporaires.
Par défaut : valeur de la variable d’environnement `AWS_DELEGATION_TOKEN` (si elle est définie).
`-m, --manifest` *chemin*
Chemin d’accès au fichier manifeste. Le fichier manifeste est créé pendant la création d’un bundle ; il est disponible dans le répertoire contenant le groupe.
Obligatoire : oui
`--url` *url*
Obsolète. Utilisez plutôt l’option `--region`, sauf si votre compartiment est limité à l’emplacement `EU` (et pas `eu-west-1`). L’indicateur `--location` est le seul moyen de cibler cette restriction d’emplacement spécifique.
URL du service de point de terminaison Amazon S3.
Par défaut: `https://s3.amazonaws.com/`
Obligatoire : non
`--region` *région*
Région à utiliser dans la signature de la demande pour le compartiment de destination S3.
+ Si le compartiment n’existe pas et que vous ne spécifiez pas une région, l’outil crée le compartiment sans contrainte d’emplacement (dans `us-east-1`).
+ Si le compartiment n’existe pas et que vous spécifiez une région, l’outil crée le compartiment dans la région spécifiée.
+ Si le compartiment existe et que vous ne spécifiez pas une région, l’outil utilise emplacement du compartiment.
+ Si le compartiment existe et que vous spécifiez `us-east-1` comme région, l’outil utilise l’emplacement du compartiment sans aucun message d’erreur, tous les fichiers correspondants existants sont écrasés.
+ Si le compartiment existe et que vous spécifiez une région (autre que `us-east-1`) qui ne correspond pas à l’emplacement du compartiment, l’outil se termine avec une erreur.
Si votre compartiment est limité à l’emplacement `EU` (et pas `eu-west-1`), utilisez plutôt l’indicateur `--location`. L’indicateur `--location` est le seul moyen de cibler cette restriction d’emplacement spécifique.
Valeur par défaut : `us-east-1`
Requis : requis si vous utilisez Signature Version 4
`--sigv` *version*
Version de signature à utiliser lors de la signature de la demande.
Valeurs valides : `2` \$1 `4`
Par défaut: `4`
Obligatoire : non
`--acl` *acl*
Stratégie de liste de contrôle des accès de l’image groupée.
Valeurs valides : `public-read` \$1 `aws-exec-read`
Par défaut: `aws-exec-read`
Obligatoire : non
`-d, --directory` *directory*
Répertoire contenant les parties de l’AMI groupée.
Par défaut : le répertoire contenant le fichier manifeste (cf. l’option `-m`).
Obligatoire : non
`--part` *part*
Commence le chargement de la partie spécifiée et de toutes les parties suivantes. Par exemple, `--part 04`.
Obligatoire : non
`--retry`
Refait automatiquement des tentatives sur toutes les erreurs Amazon S3, jusqu’à cinq fois par opération.
Obligatoire : non
`--skipmanifest`
Ne charge pas le fichier manifeste.
Obligatoire : non
`--location` *location*
Obsolète. Utilisez plutôt l’option `--region`, sauf si votre compartiment est limité à l’emplacement `EU` (et pas `eu-west-1`). L’indicateur `--location` est le seul moyen de cibler cette restriction d’emplacement spécifique.
Contrainte d’emplacement du compartiment Amazon S3 de destination. Si le compartiment existe et que vous spécifiez un emplacement qui ne correspond pas à l’emplacement du compartiment, l’outil se termine avec une erreur. Si le compartiment existe et que vous ne spécifiez pas d’emplacement, l’outil utilise emplacement du compartiment. Si le compartiment n’existe pas et que vous spécifiez un emplacement, l’outil crée le compartiment dans l’emplacement spécifié. Si le compartiment n’existe pas et que vous ne spécifiez pas d’emplacement, l’outil crée le compartiment sans contrainte d’emplacement (dans `us-east-1`).
Par défaut : si `--region` est spécifié, l’emplacement est défini sur cette région spécifiée. Si `--region`n’est pas spécifié, l’emplacement par défaut est `us-east-1`.
Obligatoire : non
### Output
Amazon EC2 affiche des messages d'état indiquant les étapes et le statut du processus de téléchargement.
### Exemple
Cet exemple télécharge le groupe spécifié par le fichier manifeste `image.manifest.xml`.
```
[ec2-user ~]$ ec2-upload-bundle -b amzn-s3-demo-bucket/bundles/bundle_name -m image.manifest.xml -a your_access_key_id -s your_secret_access_key
Creating bucket...
Uploading bundled image parts to the S3 bucket amzn-s3-demo-bucket ...
Uploaded image.part.00
Uploaded image.part.01
Uploaded image.part.02
Uploaded image.part.03
Uploaded image.part.04
Uploaded image.part.05
Uploaded image.part.06
Uploaded image.part.07
Uploaded image.part.08
Uploaded image.part.09
Uploaded image.part.10
Uploaded image.part.11
Uploaded image.part.12
Uploaded image.part.13
Uploaded image.part.14
Uploading manifest ...
Uploaded manifest.
Bundle upload completed.
```
## Options courantes pour les outils AMI
La plupart des outils AMI acceptent les paramètres facultatifs suivants.
`--help, -h`
Affiche le message d’aide.
`--version`
Affiche la version et l’avis de droit d’auteur.
`--manual`
Affiche l’entrée manuelle.
`--batch`
S’exécute en mode de traitement par lots et supprime les invites interactives.
`--debug`
Affiche les informations qui peuvent être utiles pour la résolution de problèmes.
# Conversion de votre AMI basée sur Amazon S3 en AMI basée sur Amazon EBS
Vous pouvez convertir une image AMI Linux basée sur Amazon S3 que vous possédez en une image AMI Linux basée sur Amazon EBS.
**Important**
Vous ne pouvez pas convertir une AMI dont vous n’êtes pas le propriétaire.
**Pour convertir une AMI basée sur Amazon S3 en une AMI basée sur Amazon EBS**
1. Lancez une instance Amazon Linux à partir d’une AMI basée sur des volumes Amazon EBS. Pour de plus amples informations, veuillez consulter [Lancez une instance EC2 à l’aide de l’assistant de lancement d’instance de la console](ec2-launch-instance-wizard.md). Les outils AWS CLI et AMI sont préinstallés sur les instances Amazon Linux.
1. Chargez la clé privée X.509 que vous avez utilisée pour grouper votre AMI basée sur Amazon S3 vers votre instance. Nous utilisons cette clé pour garantir que seuls vous et Amazon EC2 peuvent accéder à votre AMI.
1. Créez un répertoire temporaire sur votre instance pour votre clé privée X.509 en suivant ce qui suit :
```
[ec2-user ~]$ mkdir /tmp/cert
```
1. Copiez votre clé privée X.509 depuis votre ordinateur vers le répertoire `/tmp/cert` de votre instance en utilisant un outil de copie sécurisé comme [scp](linux-file-transfer-scp.md). Le *my-private-key* paramètre de la commande suivante est la clé privée que vous utilisez pour vous connecter à votre instance via SSH. Par exemple :
```
you@your_computer:~ $ scp -i my-private-key.pem /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem ec2-user@ec2-203-0-113-25.compute-1.amazonaws.com:/tmp/cert/
pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem 100% 717 0.7KB/s 00:00
```
1. Configurez vos variables d’environnement pour utiliser l’ AWS CLI. Pour plus d’informations, consultez la section [Variables d’environnement](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html).
1. (Recommandé) Définissez des variables d'environnement pour votre clé AWS d'accès, votre clé secrète et votre jeton de session.
```
[ec2-user ~]$ export AWS_ACCESS_KEY_ID=your_access_key_id
[ec2-user ~]$ export AWS_SECRET_ACCESS_KEY=your_secret_access_key
[ec2-user ~]$ export AWS_SESSION_TOKEN=your_session_token
```
1. Définissez des variables d'environnement pour votre clé AWS d'accès et votre clé secrète.
```
[ec2-user ~]$ export AWS_ACCESS_KEY_ID=your_access_key_id
[ec2-user ~]$ export AWS_SECRET_ACCESS_KEY=your_secret_access_key
```
1. Préparer un volume Amazon Elastic Block Store (Amazon EBS) pour votre nouvelle AMI.
1. Créez un volume EBS vide dans la même zone de disponibilité que votre instance à l’aide de la commande [create-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-volume.html). Notez l’ID du volume dans la sortie de la commande.
**Important**
Ce volume EBS doit avoir la même taille ou une taille plus importante que le volume racine de stockage d’instance original.
```
aws ec2 create-volume \
--size 10 \
--region us-west-2 \
--availability-zone us-west-2b
```
1. Attachez le volume à votre instance basée sur Amazon EBS en utilisant la commande [attach-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/attach-volume.html).
```
aws ec2 attach-volume \
--volume-id vol-01234567890abcdef \
--instance-id i-1234567890abcdef0 \
--region us-west-2
```
1. Créez un dossier pour votre groupe.
```
[ec2-user ~]$ mkdir /tmp/bundle
```
1. Téléchargez le groupe pour votre AMI basée sur le stockage d’instance sur `/tmp/bundle` en utilisant la commande [ec2-download-bundle](ami-tools-commands.md#ami-download-bundle).
```
[ec2-user ~]$ ec2-download-bundle -b amzn-s3-demo-bucket/bundle_folder/bundle_name -m image.manifest.xml -a $AWS_ACCESS_KEY_ID -s $AWS_SECRET_ACCESS_KEY --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem -d /tmp/bundle
```
1. Reconstituez le fichier image à partir du groupe en utilisant la commande [ec2-unbundle](ami-tools-commands.md#ami-unbundle).
1. Déplacez les répertoires vers le dossier du groupe.
```
[ec2-user ~]$ cd /tmp/bundle/
```
1. Exécutez la commande [ec2-unbundle](ami-tools-commands.md#ami-unbundle).
```
[ec2-user bundle]$ ec2-unbundle -m image.manifest.xml --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem
```
1. Copiez les fichiers depuis l’image dégroupée vers le nouveau volume EBS.
```
[ec2-user bundle]$ sudo dd if=/tmp/bundle/image of=/dev/sdb bs=1M
```
1. Examinez le volume pour voir si de nouvelles partitions ont été dégroupées.
```
[ec2-user bundle]$ sudo partprobe /dev/sdb1
```
1. Affichez les périphériques de stockage en mode bloc pour trouver le nom du périphérique à monter.
```
[ec2-user bundle]$ lsblk
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
/dev/sda 202:0 0 8G 0 disk
└─/dev/sda1 202:1 0 8G 0 part /
/dev/sdb 202:80 0 10G 0 disk
└─/dev/sdb1 202:81 0 10G 0 part
```
Dans cet exemple, la partition à monter est `/dev/sdb1`, mais le nom de votre périphérique sera probablement différent. Si votre volume n’est pas partitionné, l’appareil à monter sera similaire à `/dev/sdb` (sans chiffre de fin de partition de périphérique).
1. Créez un point de montage pour le nouveau volume EBS et montez le volume.
```
[ec2-user bundle]$ sudo mkdir /mnt/ebs
[ec2-user bundle]$ sudo mount /dev/sdb1 /mnt/ebs
```
1. Ouvrez le fichier `/etc/fstab` sur le volume EBS avec votre éditeur de texte préféré (comme **vim** ou **nano**) et supprimez toutes les entrées pour les volumes (éphémères) de stockage d’instance. Étant donné que le volume EBS est monté sur `/mnt/ebs`, le fichier `fstab` se situe à l’emplacement `/mnt/ebs/etc/fstab`.
```
[ec2-user bundle]$ sudo nano /mnt/ebs/etc/fstab
#
LABEL=/ / ext4 defaults,noatime 1 1
tmpfs /dev/shm tmpfs defaults 0 0
devpts /dev/pts devpts gid=5,mode=620 0 0
sysfs /sys sysfs defaults 0 0
proc /proc proc defaults 0 0
/dev/sdb /media/ephemeral0 auto defaults,comment=cloudconfig 0 2
```
Dans cet exemple, la dernière ligne devrait être supprimée.
1. Démontez le volume et détachez-le de l’instance.
```
[ec2-user bundle]$ sudo umount /mnt/ebs
[ec2-user bundle]$ aws ec2 detach-volume --volume-id vol-01234567890abcdef --region us-west-2
```
1. Créez une AMI à partir du nouveau volume EBS comme suit.
1. Créez un instantané du nouveau volume EBS.
```
[ec2-user bundle]$ aws ec2 create-snapshot --region us-west-2 --description "your_snapshot_description" --volume-id vol-01234567890abcdef
```
1. Vérifiez si votre instantané est terminé.
```
[ec2-user bundle]$ aws ec2 describe-snapshots --region us-west-2 --snapshot-id snap-0abcdef1234567890
```
1. Identifiez l’architecture de processeur, le type de virtualisation et l’image noyau (`aki`) utilisée sur l’AMI originale avec la commande **describe-images**. Pour cette étape, vous avez besoin de l’ID de l’AMI basée sur Amazon S3 d’origine.
```
[ec2-user bundle]$ aws ec2 describe-images --region us-west-2 --image-id ami-0abcdef1234567890 --output text
IMAGES x86_64 amazon/amzn-ami-pv-2013.09.2.x86_64-s3 ami-8ef297be amazon available public machine aki-fc8f11cc instance-store paravirtual xen
```
Dans cet exemple, l’architecture est `x86_64` et l’ID de l’image noyau est `aki-fc8f11cc`. Utilisez ces valeurs dans l’étape suivante. Si le résultat de la commande ci-dessus liste aussi un ID `ari`, prenez également note de cela.
1. Enregistrez votre nouvelle AMI avec l’ID d’instantané de votre nouveau volume EBS et les valeurs de l’étape précédente. Si la sortie de la commande précédente a répertorié un ID `ari`, incluez-le dans la commande suivante avec `--ramdisk-id ari_id`.
```
[ec2-user bundle]$ aws ec2 register-image --region us-west-2 --name your_new_ami_name --block-device-mappings DeviceName=device-name,Ebs={SnapshotId=snap-0abcdef1234567890} --virtualization-type paravirtual --architecture x86_64 --kernel-id aki-fc8f11cc --root-device-name device-name
```
1. (Facultatif) Après avoir vérifié que vous pouvez lancer une instance à partir de votre nouvelle AMI, vous pouvez supprimer le volume EBS que vous avez créé pour cette procédure.
```
aws ec2 delete-volume --volume-id vol-01234567890abcdef
```