# Conversão da AMI baseada no Amazon S3 em uma AMI baseada no EBS É possível converter uma AMI do Linux de sua propriedade, que é baseada no Amazon S3, em uma AMI do Linux baseada no Amazon EBS. **Importante** Não é possível converter uma AMI que não lhe pertença. **Para converter uma AMI baseada no Amazon S3 em uma AMI baseada no Amazon EBS** 1. Execute uma instância do Amazon Linux a partir de uma AMI baseada no Amazon EBS. Para obter mais informações, consulte [Executar uma instância do EC2 usando o assistente de inicialização de instâncias no console](ec2-launch-instance-wizard.md). As instâncias do Amazon Linux têm a AWS CLI e as ferramentas da AMI pré-instaladas. 1. Faça upload da chave privada X.509 usada para criar a AMI baseada no Amazon S3 para a 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 ``` 1. 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](linux-file-transfer-scp.md). 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 ``` 1. Configure as variáveis de ambiente para usar o AWS CLI. Para obter mais informações, consulte [Environment variables](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html). 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 ``` 1. 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 ``` 1. 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](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-volume.html). 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. ``` aws ec2 create-volume \ --size 10 \ --region us-west-2 \ --availability-zone us-west-2b ``` 1. Associe o volume à sua instância baseada no Amazon EBS usando o comando [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. Crie uma pasta para o seu pacote. ``` [ec2-user ~]$ mkdir /tmp/bundle ``` 1. Baixe o pacote para sua AMI com armazenamento de instâncias para `/tmp/bundle` usando o comando [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. Reconstitua o arquivo de imagem do pacote usando o comando [ec2-unbundle](ami-tools-commands.md#ami-unbundle). 1. Altere os diretórios para a pasta de pacotes. ``` [ec2-user ~]$ cd /tmp/bundle/ ``` 1. Execute o comando [ec2-unbundle](ami-tools-commands.md#ami-unbundle). ``` [ec2-user bundle]$ ec2-unbundle -m image.manifest.xml --privatekey /path/to/pk-HKZYKTAIG2ECMXYIBH3HXV4ZBEXAMPLE.pem ``` 1. 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 ``` 1. Teste o volume quanto a quaisquer novas partições não empacotadas. ``` [ec2-user bundle]$ sudo partprobe /dev/sdb1 ``` 1. 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). 1. 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 ``` 1. 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. 1. 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 vol-01234567890abcdef --region us-west-2 ``` 1. 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 vol-01234567890abcdef ``` 1. Verifique se seu snapshot está concluído. ``` [ec2-user bundle]$ aws ec2 describe-snapshots --region us-west-2 --snapshot-id snap-0abcdef1234567890 ``` 1. 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**. Nesta etapa, você precisará do ID da AMI correspondente à AMI original que é baseada no Amazon S3. ``` [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 ``` 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. 1. 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=snap-0abcdef1234567890} --virtualization-type paravirtual --architecture x86_64 --kernel-id aki-fc8f11cc --root-device-name device-name ``` 1. (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 vol-01234567890abcdef ```