Converter de uma AMI com armazenamento de instâncias em uma AMI baseada no Amazon EBS

É possível converter uma AMI do Linux com armazenamento de instâncias em uma AMI do Linux baseada no Amazon EBS.

Importante

Você não pode converter uma AMI do Windows com armazenamento de instâncias em uma AMI do Windows baseada no Amazon EBS, nem converter uma AMI que não seja sua.

Para converter uma AMI com armazenamento de instâncias em uma AMI baseada no Amazon EBS

Execute uma instância do Amazon Linux a partir de uma AMI baseada no Amazon EBS. Para ter mais informações, consulte Iniciar uma instância usando o novo assistente de inicialização de instância, versão beta. As instâncias do Amazon Linux têm a AWS CLI e as ferramentas da AMI pré-instaladas.
Carregue a chave privada X.509 usada para empacotar sua AMI com armazenamento de instâncias para sua instância. Usamos essa chave para garantir que só você e o Amazon EC2 possam acessar sua AMI.
1. Crie um diretório temporário na sua instância para a chave privada X.509 da seguinte forma:
```
[ec2-user ~]$ mkdir /tmp/cert
```
2. Copie a chave privada X.509 do seu computador para o diretório /tmp/cert na sua instância usando uma ferramenta de cópia segura, como a scp. O parâmetro my-private-key no comando a seguir é a chave privada que você usa para se conectar à sua instância com o SSH. Por exemplo:
```
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
```
Configure as variáveis de ambiente para usar o AWS CLI. Para obter mais informações, consulte Criar um par de chaves.
1. (Recomendado) Defina as variáveis de ambiente para sua chave de acesso, chave secreta e token de sessão da AWS.
```
[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
```
2. Defina as variáveis de ambiente para sua chave de acesso da AWS e uma chave secreta.
```
[ec2-user ~]$ export AWS_ACCESS_KEY_ID=your_access_key_id
[ec2-user ~]$ export AWS_SECRET_ACCESS_KEY=your_secret_access_key
```
Prepare um volume do Amazon Elastic Block Store (Amazon EBS) para sua nova AMI.
1. Crie um o volume do EBS vazio na mesma zona de disponibilidade que sua instância usando o comando create-volume. Observe o ID do volume na saída do comando.
  Importante
  Esse volume do EBS deve ter tamanho igual ou superior ao volume do dispositivo raiz do armazenamento de instâncias original.
```
[ec2-user ~]$ aws ec2 create-volume --size 10 --region us-west-2 --availability-zone us-west-2b						
```
2. Associe o volume à sua instância com Amazon EBS usando o comando attach-volume.
```
[ec2-user ~]$ aws ec2 attach-volume --volume-id volume_id --instance-id instance_id --device /dev/sdb --region us-west-2
```
Crie uma pasta para o seu pacote.
```
[ec2-user ~]$ mkdir /tmp/bundle
```

Baixe o pacote para sua AMI com armazenamento de instâncias para /tmp/bundle usando o comando ec2-download-bundle.


[ec2-user ~]$ ec2-download-bundle -b my-s3-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

Reconstitua o arquivo de imagem do pacote usando o comando ec2-unbundle.

Altere os diretórios para a pasta de pacotes.
```
[ec2-user ~]$ cd /tmp/bundle/
```

Execute o comando ec2-unbundle.


[ec2-user bundle]$ ec2-unbundle -m image.manifest.xml --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem

Copie os arquivos da imagem não empacotada para o novo volume do EBS.
```
[ec2-user bundle]$ sudo dd if=/tmp/bundle/image of=/dev/sdb bs=1M
```
Teste o volume quanto a quaisquer novas partições não empacotadas.
```
[ec2-user bundle]$ sudo partprobe /dev/sdb1
```
Liste os dispositivos de blocos para encontrar o nome do dispositivo para montar.
```
[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
```
Neste exemplo, a partição a montar é /dev/sdb1, mas o nome do seu dispositivo provavelmente será diferente. Se seu volume não estiver particionado, o dispositivo para montar será semelhante a /dev/sdb (sem um dígito final de partição do dispositivo).

Crie um ponto de montagem para o novo volume do EBS e monte o volume.


[ec2-user bundle]$ sudo mkdir /mnt/ebs
[ec2-user bundle]$ sudo mount /dev/sdb1 /mnt/ebs

Abra o arquivo /etc/fstab no volume do EBS com seu editor de texto favorito (como o vim ou o nano) e remova todas as entradas dos volumes de armazenamento de instâncias (temporários). Como o volume do EBS é montado em /mnt/ebs, o arquivo fstab é localizado em /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

Neste exemplo, a última linha deve ser removida.

Desmonte o volume e separe-o da instância.


[ec2-user bundle]$ sudo umount /mnt/ebs
[ec2-user bundle]$ aws ec2 detach-volume --volume-id volume_id --region us-west-2

Crie uma AMI a partir do novo volume do EBS, da seguinte forma.
1. Crie um snapshot do novo volume do EBS.
```
[ec2-user bundle]$ aws ec2 create-snapshot --region us-west-2 --description "your_snapshot_description" --volume-id volume_id
```
2. Verifique se seu snapshot está concluído.
```
[ec2-user bundle]$ aws ec2 describe-snapshots --region us-west-2 --snapshot-id snapshot_id
```
3. Identifique a arquitetura do processador, o tipo de virtualização e a imagem do kernel (aki) usados na AMI original com o comando describe-images. Para esta etapa, você precisa do ID da AMI com armazenamento de instâncias original.
```
[ec2-user bundle]$ aws ec2 describe-images --region us-west-2 --image-id ami-id --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
```
  Neste exemplo, arquitetura é x86_64 e o ID da imagem do kernel é aki-fc8f11cc. Use os valores a seguir na próxima etapa. Se a saída do comando acima também listar um ID ari, anote isso também.
4. Registre sua nova AMI com o ID do snapshot do seu novo volume do EBS e os valores da etapa anterior. Se a saída do comando anterior listou um ID ari, inclua-o no comando seguinte com --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=snapshot_id} --virtualization-type paravirtual --architecture x86_64 --kernel-id aki-fc8f11cc --root-device-name device-name
```
(Opcional) Depois de ter testado que pode executar uma instância a partir da nova AMI, é possível excluir o volume do EBS criado para esse procedimento.
```
aws ec2 delete-volume --volume-id volume_id
```

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Criar uma AMI a partir de uma instância com armazenamento de instâncias

Referência de ferramentas da AMI