# Criação de uma AMI baseada no Amazon S3
A AMI especificada no momento da inicialização da instância define o tipo do volume raiz para a instância.
Para criar uma AMI do Linux baseada no Amazon S3, comece com uma instância iniciada a partir de uma AMI do Linux baseada no Amazon S3 existente. Depois de personalizar a instância para atender às suas necessidades, empacote o volume e registre uma nova AMI, que é possível usar para executar novas instâncias com essas personalizações.
Não é possível criar uma AMI do Windows baseada no Amazon S3, já que as AMIs do Windows não permitem usar armazenamento de instância como volume raiz.
**Importante**
Somente os seguintes tipos de instância são compatíveis com um volume de armazenamento de instância como volume raiz e exigem uma AMI baseada no Amazon S3: C1, C3, D2, I2, M1, M2, M3, R3 e X1.
O processo de criação da AMI é diferente para AMIs baseadas no Amazon EBS. Para obter mais informações, consulte [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md).
**Topics**
+ [Visão geral da criação de uma AMI](#process-creating-an-ami-instance-store)
+ [Pré-requisitos](#bundle-ami-prerequisites)
+ [Criar uma AMI de uma instância do Linux da Amazon](#amazon_linux_instructions)
+ [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md)
+ [Referência de ferramentas de AMI do Amazon EC2](ami-tools-commands.md)
+ [Conversão da AMI baseada no Amazon S3 em uma AMI baseada no EBS](Using_ConvertingS3toEBS.md)
## Visão geral da criação de uma AMI
O diagrama apresentado a seguir resume o processo de criação de uma AMI usando uma instância com volume raiz de armazenamento de instância.
![\[Processo de criação de uma AMI baseada no Amazon S3.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ami_create_instance_store.png)
Primeiro, execute uma instância de uma AMI semelhante à AMI que você deseja criar. É possível conectá-la à sua instância e personalizá-la. Quando a instância estiver configurada da forma como você deseja, é possível empacotá-la. Demora vários minutos para o processo de empacotamento ser concluído. Depois de o processo ser concluído, você terá um pacote, que consiste em um manifesto de imagem (`image.manifest.xml`) e nos arquivos (`image.part.`*xx*) que contêm um modelo para o volume raiz. Em seguida, você carrega o pacote para seu bucket Amazon S3 e registra sua AMI.
**nota**
Para fazer upload de objetos em um bucket do S3 da AMI do Linux baseada no Amazon S3, é necessário que as ACLs estejam habilitadas no bucket. Caso contrário, o Amazon EC2 não poderá definir ACLs nos objetos a serem carregados. Se o bucket de destino usar a configuração imposta pelo proprietário do bucket para propriedade de objeto do S3, isso não funcionará, porque as ACLs estarão desabilitadas. Para obter mais informações, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html).
Quando você executa uma instância usando a nova AMI, criamos o volume do dispositivo raiz da instância usando o pacote que você carregou para o Amazon S3. O espaço de armazenamento usado pelo pacote no Amazon S3 gera cobranças na sua conta até que você o exclua. Para obter mais informações, consulte [Cancelar o registro de uma AMI do Amazon EC2](deregister-ami.md).
Se além do volume raiz, você adicionar volumes de armazenamento de instância à sua instância, o mapeamento de dispositivos de blocos da nova AMI conterá informações sobre esses volumes, e os mapeamentos de dispositivos de blocos das instâncias que você iniciar usando a nova AMI conterão automaticamente informações sobre esses volumes. Para obter mais informações, consulte [Mapeamento de dispositivos de blocos para volumes em instâncias do Amazon EC2](block-device-mapping-concepts.md).
## Pré-requisitos
Antes que você crie uma AMI, é preciso concluir as tarefas seguir:
+ Instale as ferramentas da AMI. Para obter mais informações, consulte [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md).
+ Instale o AWS CLI. Para obter mais informações, consulte [ Conceitos básicos do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
+ Verifique se você tem um bucket do S3 para o pacote e se o bucket tem ACLs habilitadas. Para obter mais informações sobre a configuração de ACLs, consulte [Configuração de ACLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/managing-acls.html).
+ Para criar um bucket do S3 usando o Console de gerenciamento da AWS, abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/) e escolha **Criar bucket**.
+ Para criar um bucket do S3 com a AWS CLI, é possível usar o comando [mb](https://docs.aws.amazon.com/cli/latest/reference/s3/mb.html). Se a versão instalada das ferramentas da AMI for 1.5.18 ou posterior, também será possível usar o comando `ec2-upload-bundle` para criar o bucket do S3. Para obter mais informações, consulte [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle).
+ Certifique-se de que os arquivos em seu pacote não estejam criptografados no bucket do S3. Caso precise de criptografia para sua AMI, será possível usar uma AMI baseada no EBS em vez disso. Para obter mais informações, consulte [Usar criptografia com AMIs com EBS](AMIEncryption.md).
+ Verifique se você tem seu ID de conta da AWS. Para obter mais informações, consulte [Visualizar identificadores de Conta da AWS](https://docs.aws.amazon.com/accounts/latest/reference/manage-acct-identifiers.html) no *Guia de referência de gerenciamento de contas da AWS*.
+ Certifique-se de ter credenciais para usar o AWS CLI. Para obter mais informações, consulte [Credenciais de acesso e autenticação para o AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-authentication.html) no *Guia do usuário do AWS Command Line Interface*.
+ Verifique se você tem um certificado x.509 e a chave privada correspondente.
+ Se você precisar criar um certificado X.509, consulte [Gerenciar certificados de assinatura](set-up-ami-tools.md#ami-tools-managing-certs). O certificado X.509 e a chave privada são usados para criptografar e descriptografar sua AMI.
+ [China (Pequim)] Use o certificado `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-cn-north-1.pem`.
+ [AWS GovCloud (US-West)] Use o certificado `$EC2_AMITOOL_HOME/etc/ec2/amitools/cert-ec2-gov.pem`.
+ Conecte-se à sua instância e personalize-a. Por exemplo, é possível instalar softwares e aplicações, copiar dados, excluir arquivos temporários e modificar a configuração do Linux.
## Criar uma AMI de uma instância do Linux da Amazon
Os procedimentos apresentados a seguir explicam como criar uma AMI usando uma instância com um volume raiz de armazenamento de instância que está executando o Amazon Linux 1. Eles podem não funcionar para instâncias em execução em outras distribuições do Linux.
**Para se preparar para usar as ferramentas da AMI (somente instâncias do HVM)**
1. As ferramentas de AMI exigem GRUB Legacy para inicializarem corretamente. Use o comando a seguir para instalar o GRUB:
```
[ec2-user ~]$ sudo yum install -y grub
```
1. Instale os pacotes de gerenciamento de partição com o seguinte comando:
```
[ec2-user ~]$ sudo yum install -y gdisk kpartx parted
```
**Para criar uma AMI usando uma instância do Amazon Linux com volume raiz de armazenamento de instância**
Este procedimento pressupõe que você atendeu aos pré-requisitos de [Pré-requisitos](#bundle-ami-prerequisites).
Nos comandos a seguir, substitua cada *espaço reservado para entrada do usuário* por suas próprias informações.
1. Carregue suas credenciais para sua instância. Usamos essas credenciais 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 suas credenciais, da seguinte forma:
```
[ec2-user ~]$ mkdir /tmp/cert
```
Isso permite que você exclua suas credenciais da imagem criada.
1. Copie o certificado X.509 e a chave privada correspondente do seu computador para o diretório `/tmp/cert` na sua instância usando uma ferramenta de cópia segura, como [scp](linux-file-transfer-scp.md). A opção `-i my-private-key.pem` no comando **scp** é a chave privada que você usa para se conectar à sua instância com o SSH, não a chave privada X.509. Por exemplo:
```
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
```
Como alternativa, por serem arquivos de texto simples, é possível abrir o certificado e a chave em um editor de texto e copiar o conteúdo para novos arquivos em `/tmp/cert`.
1. Prepare o pacote para carregar para o Amazon S3 executando o comando [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) em sua instância. Não se esqueça de especificar a opção `-e` para de excluir o diretório onde suas credenciais estão armazenadas. Por padrão, o processo de colocação em pacotes exclui arquivos que possam conter informações confidenciais. Esses arquivos incluem `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` e `*/.bash_history`. Para incluir todos os arquivos, use a opção `--no-filter`. Para incluir alguns dos arquivos, use a opção `--include`.
**Importante**
Por padrão, o processo de empacotamento da AMI cria um conjunto de arquivos compactados e criptografados no diretório `/tmp` que representa o volume raiz. Se você não tem o espaço em disco suficiente em `/tmp` para armazenar o pacote, precisa especificar um local diferente para o pacote ser armazenado com a opção `-d /path/to/bundle/storage`. Algumas instâncias têm armazenamento temporário montado em `/mnt` ou `/media/ephemeral0` que você pode usar, ou você pode também criar, associar e montar um novo volume do Amazon EBS para armazenar o pacote. Para obter mais informações, consulte [Criar um volume do Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html) no *Guia do usuário do Amazon EC2*.
1. Execute o comando **ec2-bundle-vol** como raiz. Na maioria dos comandos, é possível usar **sudo** para ganhar permissões elevadas, mas neste caso, é necessário executar **sudo -E su** para manter as variáveis do ambiente.
```
[ec2-user ~]$ sudo -E su
```
Observe que prompt bash agora identifica você como usuário raiz, e o cifrão foi substituído por uma hashtag, sinalizando que você está em um shell raiz:
```
[root ec2-user]#
```
1. Para criar o pacote de AMIs, execute o comando [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol) da seguinte forma:
```
[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
```
**nota**
Para as regiões China (Pequim) e AWS GovCloud (US-West), use o parâmetro `--ec2cert` e especifique os certificados de acordo com os [pré-requisitos](#bundle-ami-prerequisites).
Pode demorar alguns minutos para criar a imagem. Quando esse comando for concluído, o diretório `/tmp` (ou não padrão) conterá o pacote (`image.manifest.xml`, além de vários arquivos `image.part.`*xx*).
1. Saída do shell raiz.
```
[root ec2-user]# exit
```
1. (Opcional) Para adicionar mais volumes de armazenamento de instâncias, edite os mapeamentos de dispositivos de blocos no arquivo `image.manifest.xml` para sua AMI. Para obter mais informações, consulte [Mapeamento de dispositivos de blocos para volumes em instâncias do Amazon EC2](block-device-mapping-concepts.md).
1. Crie um backup do seu arquivo `image.manifest.xml`.
```
[ec2-user ~]$ sudo cp /tmp/image.manifest.xml /tmp/image.manifest.xml.bak
```
1. Reformate o arquivo `image.manifest.xml` para que seja mais fácil ler e editar.
```
[ec2-user ~]$ sudo xmllint --format /tmp/image.manifest.xml.bak > /tmp/image.manifest.xml
```
1. Edite os mapeamentos de dispositivos de blocos em `image.manifest.xml` com um editor de texto. O exemplo abaixo mostra uma nova entrada para o volume do armazenamento de instâncias `ephemeral1`.
**nota**
Para obter uma lista dos arquivos excluídos, consulte [ec2-bundle-vol](ami-tools-commands.md#ami-bundle-vol).
```
ami
sda
ephemeral0
sdb
ephemeral1
sdc
root
/dev/sda1
```
1. Salve o arquivo `image.manifest.xml` e saia do seu editor de texto.
1. Para fazer upload do pacote para o Amazon S3, execute o comando [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle) da seguinte forma.
```
[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
```
**Importante**
Para registrar a AMI em uma região diferente de US East (N. Virginia), é preciso especificar tanto a região de destino com a opção `--region` quanto um caminho do bucket que já exista na região de destino, ou um caminho de bucket exclusivo que possa ser criado na região de destino.
1. (Opcional) Depois de o pacote ser carregado para o Amazon S3, é possível removê-lo do diretório `/tmp` na instância usando o comando **rm** a seguir:
```
[ec2-user ~]$ sudo rm /tmp/image.manifest.xml /tmp/image.part.* /tmp/image
```
**Importante**
Se você tiver especificado um caminho com a opção `-d /path/to/bundle/storage` em [Step 2](#step_with_bundle_path_amazon_linux), use esse caminho em vez de `/tmp`.
1. Para registrar a AMI, execute o comando [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) da seguinte maneira.
```
[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
```
**Importante**
Se você tiver especificado previamente uma região para o comando [ec2-upload-bundle](ami-tools-commands.md#ami-upload-bundle), especifique essa região novamente para esse comando.
# Configurar as ferramentas de AMIs do Amazon EC2
Você pode usar as ferramentas da AMI para criar e gerenciar AMIs do Linux baseadas no Amazon S3. Para usar as ferramentas, é necessário instalá-las na sua instância do Linux. As ferramentas das AMIs estão disponíveis como RPM e arquivo .zip para distribuições Linux incompatíveis com RPM.
**Para definir as ferramentas da AMI usando RPM**
1. Instale o Ruby usando o gerenciador de pacotes para sua distribuição do Linux, como yum. Por exemplo:
```
[ec2-user ~]$ sudo yum install -y ruby
```
1. Baixe o arquivo RPM usando uma ferramenta como wget ou curl. Por exemplo:
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.noarch.rpm
```
1. Verifique se a assinatura do arquivo RPM está usando o seguinte comando:
```
[ec2-user ~]$ rpm -K ec2-ami-tools.noarch.rpm
```
O comando acima deve indicar que os hashes SHA1 e MD5 do arquivo estão `OK.` Se o comando indicar que os hashes estão `NOT OK`, use o seguinte comando para ver os hashes SHA1 e MD5 do cabeçalho do arquivo:
```
[ec2-user ~]$ rpm -Kv ec2-ami-tools.noarch.rpm
```
Em seguida, compare os hashes SHA1 e MD5 do cabeçalho do arquivo com os seguintes hashes das ferramentas de AMIs verificadas para confirmar a autenticidade do arquivo:
+ SHA1 do cabeçalho: a1f662d6f25f69871104e6a62187fa4df508f880
+ MD5: 9faff05258064e2f7909b66142de6782
Se os hashes SHA1 e MD5 do cabeçalho do arquivo corresponder aos hashes das ferramentas de AMI verificadas, vá para a próxima etapa.
1. Instale o RPM usando o comando a seguir:
```
[ec2-user ~]$ sudo yum install ec2-ami-tools.noarch.rpm
```
1. Verifique a instalação das suas ferramentas da AMI usando o comando [ec2-ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**nota**
Se você receber um erro de carregamento, como "não é possível carregar esse arquivo -- ec2/amitools/version (LoadError)", realize a próxima etapa para adicionar o local de instalação das suas ferramentas da AMI para seu `RUBYLIB` caminho.
1. (Opcional) Se você tiver recebido um erro na etapa anterior, adicione a localização das suas ferramentas da AMI para seu caminho `RUBYLIB`.
1. Execute o comando a seguir para determinar os caminhos a adicionar.
```
[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
```
No exemplo acima, o arquivo ausente no erro de carga anterior está localizado em `/usr/lib/ruby/site_ruby` e `/usr/lib64/ruby/site_ruby`.
1. Adicione os locais da etapa anterior ao seu caminho de `RUBYLIB`.
```
[ec2-user ~]$ export RUBYLIB=$RUBYLIB:/usr/lib/ruby/site_ruby:/usr/lib64/ruby/site_ruby
```
1. Verifique a instalação das suas ferramentas da AMI usando o comando [ec2-ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
**Para configurar as ferramentas da AMI usando o arquivo .zip**
1. Instale o Ruby e descompacte usando o gerenciador de pacotes para sua distribuição do Linux, como **apt-get**. Por exemplo:
```
[ec2-user ~]$ sudo apt-get update -y && sudo apt-get install -y ruby unzip
```
1. Baixe o arquivo .zip usando uma ferramenta como wget ou curl. Por exemplo:
```
[ec2-user ~]$ wget https://s3.amazonaws.com/ec2-downloads/ec2-ami-tools.zip
```
1. Descompacte os arquivos em um diretório de instalação apropriado, como `/usr/local/ec2`.
```
[ec2-user ~]$ sudo mkdir -p /usr/local/ec2
$ sudo unzip ec2-ami-tools.zip -d /usr/local/ec2
```
Observe que o arquivo .zip contém uma pasta ec2-ami-tools-*x*.*x*.*x*, em que *x*.*x*.*x* é o número da versão das ferramentas (por exemplo, `ec2-ami-tools-1.5.7`).
1. Ajuste a variável de ambiente `EC2_AMITOOL_HOME` para o diretório de instalação para as ferramentas. Por exemplo:
```
[ec2-user ~]$ export EC2_AMITOOL_HOME=/usr/local/ec2/ec2-ami-tools-x.x.x
```
1. Adicione as ferramentas à sua variável de ambiente `PATH`. Por exemplo:
```
[ec2-user ~]$ export PATH=$EC2_AMITOOL_HOME/bin:$PATH
```
1. É possível verificar a instalação das suas ferramentas da AMI usando o comando [ec2-ami-tools-version](ami-tools-commands.md#ami-tools-version).
```
[ec2-user ~]$ ec2-ami-tools-version
```
## Gerenciar certificados de assinatura
Determinados comandos nas ferramentas da AMI exigem a assinatura de um certificado (também conhecido como certificado X.509). É necessário criar o certificado e, então, carregá-lo para a AWS. Por exemplo, é possível usar uma ferramenta de terceiros, como OpenSSL, para criar o certificado.
**Para criar um certificado de assinatura**
1. Instale e configure o OpenSSL.
1. Crie uma chave privada usando o comando `openssl genrsa` e salve a saída em um arquivo `.pem`. Recomendamos que você crie uma chave RSA de 2048 ou 4096 bits.
```
openssl genrsa 2048 > private-key.pem
```
1. Gere um certificado usando o comando `openssl req`.
```
openssl req -new -x509 -nodes -sha256 -days 365 -key private-key.pem -outform PEM -out certificate.pem
```
Para carregar o certificado para a AWS, use o comando [upload-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/upload-signing-certificate.html).
```
aws iam upload-signing-certificate --user-name user-name --certificate-body file://path/to/certificate.pem
```
Para listar os certificados para um usuário, use o comando [list-signing-certificates](https://docs.aws.amazon.com/cli/latest/reference/iam/list-signing-certificates.html):
```
aws iam list-signing-certificates --user-name user-name
```
Para desabilitar ou reabilitar um certificado de assinatura para um usuário, use o comando [update-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/update-signing-certificate.html). O comando a seguir desabilita o certificado:
```
aws iam update-signing-certificate --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE --status Inactive --user-name user-name
```
Para excluir um certificado, use o comando [delete-signing-certificate](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-signing-certificate.html):
```
aws iam delete-signing-certificate --user-name user-name --certificate-id OFHPLP4ZULTHYPMSYEX7O4BEXAMPLE
```
# Referência de ferramentas de AMI do Amazon EC2
É possível usar os comandos das ferramentas da AMI para criar e gerenciar AMIs do Linux baseadas no Amazon S3. Para configurar as ferramentas, consulte [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md).
Para obter mais informações sobre as chaves de acesso, consulte [Gerenciamento de chaves de acesso de usuários do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) no *Guia do usuário do 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)
+ [Opções comuns de ferramentas da AMI](#common-args-ami)
## ec2-ami-tools-version
### Descrição
Descreve a versão das ferramentas da AMI.
### Sintaxe
**ec2-ami-tools-version**
### Resultado
As informações da versão.
### Exemplo
Este comando de exemplo exibe as informações da versão das ferramentas de AMI que você está usando.
```
[ec2-user ~]$ ec2-ami-tools-version
1.5.2 20071010
```
## ec2-bundle-image
### Descrição
Cria uma AMI do Linux baseada no Amazon S3 usando uma imagem do sistema operacional gerada em um arquivo loopback.
### Sintaxe
****ec2-bundle-image** -c *path* -k *path* -u *account* -i *path* [-d *path*] [--ec2cert *path*] [-r *architecture*] [--productcodes *code1*,*code2*,...] [-B *mapping*] [-p *prefix*]**
### Opções
`-c, --cert` *path*
O arquivo de certificado de chave pública RSA codificado por PEM do usuário.
Obrigatório: sim
`-k, --privatekey` *path*
O caminho para um arquivo de chave RSA codificado por PEM. Será necessário especificar essa chave para desfazer esse pacote e, assim, mantê-lo em um lugar seguro. Observe que a chave não precisa estar registrada na conta da AWS.
Obrigatório: sim
`-u, --user ` *account*
O ID da conta da AWS do usuário, sem traços.
Obrigatório: sim
`-i, --image` *path*
O caminho até imagem para fazer o pacote.
Obrigatório: sim
`-d, --destination` *path*
O diretório no qual o pacote deve ser criado.
Padrão: `/tmp`
Exigido: Não
`--ec2cert` *path*
O caminho até o certificado de chave pública X.509 do Amazon EC2 usado para criptografar o manifesto da imagem.
As regiões `us-gov-west-1` e `cn-north-1` usam um certificado de chave pública não padrão e o caminho para esse certificado deve ser especificado com essa opção. O caminho para o certificado varia de acordo com o método de instalação das ferramentas da AMI. Para o Amazon Linux, os certificados estão localizados em `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se você tiver instalado as ferramentas da AMI do arquivo RPM ou ZIP em [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md), os certificados estarão localizados em `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obrigatório: apenas para as regiões `us-gov-west-1` e `cn-north-1`.
`-r, --arch` *architecture*
Arquitetura da imagem. Se você não tiver fornecido a arquitetura na linha de comando, ela será solicitada quando o empacotamento for iniciado.
Valores válidos: `i386` \$1 `x86_64`
Exigido: Não
`--productcodes` *code1,code2,...*
Os códigos de produto para associar à imagem no momento do registro, separado por vírgulas.
Exigido: Não
`-B, --block-device-mapping` *mapping*
Define como dispositivos de blocos são expostos a uma instância dessa AMI, caso esse tipo de instância seja compatível com o dispositivo especificado.
Especifique uma lista separada por vírgulas de pares de valor-chave, nos quais cada chave é um nome virtual e cada valor é o nome do dispositivo correspondente. Os nomes virtuais incluem o seguinte:
+ `ami` — o dispositivo do sistema de arquivos raiz, como visto pela instância
+ `root` — o dispositivo do sistema de arquivos raiz, como visto pelo kernel
+ `swap` — o dispositivo de troca, como visto pela instância
+ `ephemeralN` — o enésimo volume de armazenamento de instâncias
Exigido: Não
`-p, --prefix` *prefix*
O prefixo do nome dos arquivos de AMI em pacote.
Padrão: O nome de arquivo de imagem. Por exemplo: se o caminho da imagem for `/var/spool/my-image/version-2/debian.img`, o prefixo padrão será `debian.img`.
Exigido: Não
`--kernel` *kernel\$1id*
Suspenso. Use [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) para configurar o kernel.
Exigido: Não
`--ramdisk` *ramdisk\$1id*
Suspenso. Use [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) para configurar o disco RAM, se necessário.
Obrigatório: Não
### Resultado
Mensagens de status que descrevem os estágios e o status do processo de empacotamento.
### Exemplo
Este exemplo cria uma AMI empacotada a partir de uma imagem de sistema operacional criada em um arquivo de loopback.
```
[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
### Descrição
Cria uma AMI do Linux baseada no Amazon S3 ao compactar, criptografar e assinar uma cópia do volume raiz da instância.
O Amazon EC2 tenta herdar códigos de produto, configurações de kernel, configurações do disco RAM e mapeamentos de dispositivos de blocos a partir da instância.
Por padrão, o processo de colocação em pacotes exclui arquivos que possam conter informações confidenciais. Esses arquivos incluem `*.sw`, `*.swo`, `*.swp`, `*.pem`, `*.priv`, `*id_rsa*`, `*id_dsa*` `*.gpg`, `*.jks`, `*/.ssh/authorized_keys` e `*/.bash_history`. Para incluir todos os arquivos, use a opção `--no-filter`. Para incluir alguns dos arquivos, use a opção `--include`.
Para obter mais informações, consulte [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md).
### Sintaxe
****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*]**
### Opções
`-c, --cert` *path*
O arquivo de certificado de chave pública RSA codificado por PEM do usuário.
Obrigatório: sim
`-k, --privatekey ` *path*
O caminho até o arquivo de chaves RSA codificado por PEM do usuário.
Obrigatório: sim
`-u, --user` *account*
O ID da conta da AWS do usuário, sem traços.
Obrigatório: sim
`-d, --destination` *destination*
O diretório no qual o pacote deve ser criado.
Padrão: `/tmp`
Exigido: Não
`--ec2cert` *path*
O caminho até o certificado de chave pública X.509 do Amazon EC2 usado para criptografar o manifesto da imagem.
As regiões `us-gov-west-1` e `cn-north-1` usam um certificado de chave pública não padrão e o caminho para esse certificado deve ser especificado com essa opção. O caminho para o certificado varia de acordo com o método de instalação das ferramentas da AMI. Para o Amazon Linux, os certificados estão localizados em `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se você tiver instalado as ferramentas da AMI do arquivo RPM ou ZIP em [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md), os certificados estarão localizados em `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obrigatório: apenas para as regiões `us-gov-west-1` e `cn-north-1`.
`-r, --arch ` *architecture*
A arquitetura da imagem. Se você não tiver fornecido isso na linha de comando, ela será solicitada a fornecer quando o empacotamento for iniciado.
Valores válidos: `i386` \$1 `x86_64`
Exigido: Não
`--productcodes` *code1,code2,...*
Os códigos de produto para associar à imagem no momento do registro, separado por vírgulas.
Exigido: Não
`-B, --block-device-mapping` *mapping*
Define como dispositivos de blocos são expostos a uma instância dessa AMI, caso esse tipo de instância seja compatível com o dispositivo especificado.
Especifique uma lista separada por vírgulas de pares de valor-chave, nos quais cada chave é um nome virtual e cada valor é o nome do dispositivo correspondente. Os nomes virtuais incluem o seguinte:
+ `ami` — o dispositivo do sistema de arquivos raiz, como visto pela instância
+ `root` — o dispositivo do sistema de arquivos raiz, como visto pelo kernel
+ `swap` — o dispositivo de troca, como visto pela instância
+ `ephemeralN` — o enésimo volume de armazenamento de instâncias
Exigido: Não
`-a, --all`
Inclua todos os diretórios, incluindo aqueles em sistemas de arquivos montados remotamente.
Exigido: Não
`-e, --exclude ` *directory1,directory2,...*
Uma lista de caminhos absolutos e arquivos no diretório para excluir a operação de pacotes. Esse parâmetro substitui a opção `--all`. Quando a exclusão for especificada, os diretórios subdiretórios listados com esse parâmetro não serão reunidos com o volume.
Exigido: Não
`-i, --include ` *file1,file2,...*
Uma lista de arquivos a serem incluídos na operação de pacotes. Os arquivos especificados seriam excluídos da AMI, pois poderiam conter informações sigilosas.
Exigido: Não
`--no-filter`
Se especificado, não excluiremos os arquivos da AMI, pois eles podem conter informações sigilosas.
Exigido: Não
`-p, --prefix ` *prefix*
O prefixo do nome dos arquivos de AMI em pacote.
Padrão: `image`
Exigido: Não
`-s, --size` *size*
O tamanho, em MB (1024 x 1024 bytes), do arquivo de imagem a ser criado. O tamanho máximo é de 10240 MB.
Padrão: 10240
Exigido: Não
`--[no-]inherit`
Indica se a imagem deve herdar metadados da instância (o padrão é herdar). O empacotamento falhará se você habilitar `--inherit`, mas os metadados de instância não estiverem acessíveis.
Exigido: Não
`-v, --volume ` *volume*
O caminho absoluto até o volume montado, a partir do qual o pacote deve ser criado.
Padrão: O diretório de raiz (/)
Exigido: Não
`-P, --partition` *type*
Indica se a imagem do disco deve usar uma tabela de partição. Se você não especificar um tipo de tabela de partição, o padrão será o tipo usado no dispositivo de blocos do volume, se aplicável; caso contrário, o padrão é `gpt`.
Valores válidos: `mbr` \$1 `gpt` \$1 `none`
Exigido: Não
`-S, --script` *script*
Um script de personalização a ser sido executado logo antes do empacotamento. O script deve esperar um único argumento, o ponto de montagem do volume.
Exigido: Não
`--fstab` *path*
O caminho até fstab para empacotar na imagem. Se isso não estiver especificado, o Amazon EC2 empacotará /etc/fstab.
Exigido: Não
`--generate-fstab`
Empacote o volume usando um fstab fornecido pelo Amazon EC2.
Exigido: Não
`--grub-config`
O caminho para um arquivo alternativo de configuração do GRUB para empacotar na imagem. Por padrão, `ec2-bundle-vol` espera que `/boot/grub/menu.lst` ou `/boot/grub/grub.conf` exista na imagem clonada. Essa opção permite que você especifique um caminho para um arquivo alternativo de configuração do GRUB, que será então copiado para os padrões (se presente).
Exigido: Não
`--kernel` *kernel\$1id*
Suspenso. Use [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) para configurar o kernel.
Exigido: Não
`--ramdisk`*ramdisk\$1id*
Suspenso. Use [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) para configurar o disco RAM, se necessário.
Obrigatório: Não
### Resultado
Mensagens de status que descrevem os estágios e o status do empacotamento.
### Exemplo
Esse exemplo criar uma AMI empacotada ao comprimir, criptografar e assinar um snapshot do sistema de arquivos raiz da máquina 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
### Descrição
Exclui o pacote especificado do armazenamento Amazon S3. Após excluir um pacote, você não pode executar instâncias a partir da AMI correspondente.
### Sintaxe
****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]**
### Opções
`-b, --bucket `*bucket*
O nome do bucket do Amazon S3 que contém a AMI empacotada, seguido por um prefixo de caminho opcional delimitado por '/'
Obrigatório: sim
`-a, --access-key` *access\$1key\$1id*
O ID da chave de acesso da AWS.
Obrigatório: sim
`-s, --secret-key` *secret\$1access\$1key*
A chave de acesso secreta da AWS.
Obrigatório: sim
`-t, --delegation-token` *token*
O token de delegação para repassar à solicitação da AWS. Para obter mais informações, consulte [Credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.
Obrigatório: Somente quando você usar credenciais temporárias de segurança.
Padrão: O valor da variável de ambiente `AWS_DELEGATION_TOKEN` (se definida).
`--region`*region*
A região a ser usada na assinatura da solicitação.
Padrão: `us-east-1`
Obrigatório: Sim se estiver usando a assinatura versão 4
`--sigv`*versão*
A versão da assinatura a ser usada ao assinar a solicitação.
Valores válidos: `2` \$1 `4`
Padrão: `4`
Exigido: Não
`-m, --manifest`*path*
O caminho até o arquivo manifesto.
Obrigatório: Especifique `--prefix` ou `--manifest`.
`-p, --prefix` *prefix*
O prefixo do nome de arquivo da AMI empacotada. Forneça o prefixo inteiro. Por exemplo, se o prefixo for image.img, use `-p image.img`, não. `-p image`
Obrigatório: Especifique `--prefix` ou `--manifest`.
`--clear`
Exclui o bucket Amazon S3 se estiver vazio depois do pacote especificado.
Exigido: Não
`--retry`
Tenta novamente mais uma vez todos os erros de Amazon S3, até cinco vezes por operação.
Exigido: Não
`-y, --yes`
Pressupõe automaticamente que a resposta a todos os avisos é sim.
Obrigatório: Não
### Resultado
O Amazon EC2 exibe mensagens de status indicando os estágios e o status do processo de exclusão.
### Exemplo
Este exemplo exclui um pacote do 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
### Descrição
Realiza download das AMIs do Linux baseadas no Amazon S3 especificadas usando o armazenamento do Amazon S3.
### Sintaxe
****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]**
### Opções
`-b, --bucket` *bucket*
O nome do bucket Amazon S3 no qual o pacote está localizado, seguido por um prefixo de caminho opcional delimitado por '/'.
Obrigatório: sim
`-a, --access-key` *access\$1key\$1id*
O ID da chave de acesso da AWS.
Obrigatório: sim
`-s, --secret-key` *secret\$1access\$1key*
A chave de acesso secreta da AWS.
Obrigatório: sim
`-k, --privatekey` *path*
A chave privada usada para descriptografar o manifesto.
Obrigatório: sim
`--url` *url*
O URL do serviço Amazon S3.
Padrão: `https://s3.amazonaws.com/`
Exigido: Não
`--region` *region*
A região a ser usada na assinatura da solicitação.
Padrão: `us-east-1`
Obrigatório: Sim se estiver usando a assinatura versão 4
`--sigv` *version*
A versão da assinatura a ser usada ao assinar a solicitação.
Valores válidos: `2` \$1 `4`
Padrão: `4`
Exigido: Não
`-m, --manifest` *file*
O nome do arquivo manifesto (sem o caminho). Recomendamos que você especifique o manifesto (`-m`) ou um prefixo (`-p`).
Exigido: Não
`-p, --prefix ` *prefix*
O prefixo do nome dos arquivos de AMI em pacote.
Padrão: `image`
Exigido: Não
`-d, --directory ` *directory*
O diretório no qual o pacote baixado é salvo. O diretório deve existir.
Padrão: O diretório de trabalho atual.
Exigido: Não
`--retry`
Tenta novamente mais uma vez todos os erros de Amazon S3, até cinco vezes por operação.
Obrigatório: Não
### Resultado
São exibidas as mensagens de status que indicam os vários estágios do processo de download.
### Exemplo
Este exemplo cria o diretório `bundled` (usando o comando Linux **mkdir**) e faz download do pacote do bucket `amzn-s3-demo-bucket` do Amazon S3.
```
[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
### Descrição
Modifica uma AMI do Linux baseada no Amazon S3 (por exemplo, o certificado, o kernel e o disco de RAM) para que a AMI se torne compatível com uma região diferente.
### Sintaxe
****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*]**
### Opções
`-c, --cert` *path*
O arquivo de certificado de chave pública RSA codificado por PEM do usuário.
Obrigatório: sim
`-k, --privatekey` *path*
O caminho até o arquivo de chaves RSA codificado por PEM do usuário.
Obrigatório: sim
`--manifest` *path*
O caminho até o arquivo manifesto.
Obrigatório: sim
`-a, --access-key` *access\$1key\$1id*
O ID da chave de acesso da AWS.
Obrigatório: Obrigatório se estiver usando o mapeamento automático.
`-s, --secret-key ` *secret\$1access\$1key*
A chave de acesso secreta da AWS.
Obrigatório: Obrigatório se estiver usando o mapeamento automático.
`--region` *region*
A região a pesquisar no arquivo de mapeamento.
Obrigatório: Obrigatório se estiver usando o mapeamento automático.
`--no-mapping`
Desabilita o mapeamento automático de kernels e discos RAM.
Durante a migração, o Amazon EC2 substitui o kernel e o disco RAM no arquivo manifesto por um kernel e disco RAM projetados para a região de destino. A menos que o parâmetro `--no-mapping` seja fornecido, `ec2-migrate-bundle` poderá usar as operações `DescribeRegions` e `DescribeImages` para executar mapeamentos automatizados.
Obrigatório: Obrigatório se não fornecer as opções `-a`, `-s` e `--region` usadas para mapeamento automático.
`--ec2cert` *path*
O caminho até o certificado de chave pública X.509 do Amazon EC2 usado para criptografar o manifesto da imagem.
As regiões `us-gov-west-1` e `cn-north-1` usam um certificado de chave pública não padrão e o caminho para esse certificado deve ser especificado com essa opção. O caminho para o certificado varia de acordo com o método de instalação das ferramentas da AMI. Para o Amazon Linux, os certificados estão localizados em `/opt/aws/amitools/ec2/etc/ec2/amitools/`. Se você tiver instalado as ferramentas da AMI do arquivo ZIP em [Configurar as ferramentas de AMIs do Amazon EC2](set-up-ami-tools.md), os certificados estarão localizados em `$EC2_AMITOOL_HOME/etc/ec2/amitools/`.
Obrigatório: apenas para as regiões `us-gov-west-1` e `cn-north-1`.
`--kernel` *kernel\$1id*
O ID do kernel para selecionar.
Recomendamos que você use PV-GRUB em vez de kernels e discos RAM. Para obter mais informações, consulte [User provided kernels](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) no *Amazon Linux 2 User Guide*.
Obrigatório: Não
`--ramdisk` *ramdisk\$1id*
O ID do disco RAM para selecionar.
Recomendamos que você use PV-GRUB em vez de kernels e discos RAM. Para obter mais informações, consulte [User provided kernels](https://docs.aws.amazon.com/linux/al2/ug/UserProvidedKernels.html) no *Amazon Linux 2 User Guide*.
Obrigatório: Não
### Resultado
Mensagens de status que descrevem os estágios e o status do processo de empacotamento.
### Exemplo
Este exemplo copia a AMI especificada no manifesto `my-ami.manifest.xml` dos EUA para a União Europeia.
```
[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
### Descrição
Recria o pacote usando uma AMI do Linux baseada no Amazon S3.
### Sintaxe
****ec2-unbundle** -k *path* -m *path* [-s *source\$1directory*] [-d *destination\$1directory*]**
### Opções
`-k, --privatekey` *path*
O caminho para seu arquivo de chave RSA codificado por PEM.
Obrigatório: sim
`-m, --manifest` *path*
O caminho até o arquivo manifesto.
Obrigatório: sim
`-s, --source` *source\$1directory*
O diretório que contém o pacote.
Padrão: O diretório atual.
Exigido: Não
`-d, --destination` *destination\$1directory*
O diretório no qual o pacote da AMI deve ser desfeito. O diretório de destino deve existir.
Padrão: O diretório atual.
Obrigatório: Não
### Exemplo
Este exemplo de Linux e UNIX desfaz o pacote da AMI especificado no arquivo `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
```
### Resultado
São exibidas mensagens de status indicando os vários estágios do processo de desempacotamento.
## ec2-upload-bundle
### Descrição
Faz upload do pacote de uma AMI do Linux baseada no Amazon S3 para o Amazon S3 e define as listas de controle de acesso (ACLs) apropriadas nos objetos carregados. Para obter mais informações, consulte [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md).
**nota**
Para fazer upload de objetos em um bucket do S3 da AMI do Linux baseada no Amazon S3, é necessário que as ACLs estejam habilitadas no bucket. Caso contrário, o Amazon EC2 não poderá definir ACLs nos objetos a serem carregados. Se o bucket de destino usar a configuração imposta pelo proprietário do bucket para propriedade de objeto do S3, isso não funcionará, porque as ACLs estarão desabilitadas. Para obter mais informações, consulte [Controlar a propriedade de objetos e desabilitar ACLs para seu bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html).
### Sintaxe
****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]**
### Opções
`-b, --bucket` *bucket*
O nome do bucket Amazon S3 no qual armazenar o pacote, seguido por um prefixo de caminho opcional delimitado por '/'. Se o bucket não existir, ele será criado se o nome do bucket estiver disponível. Além disso, se o bucket não existir e a versão das ferramentas da AMI for 1.5.18 ou posterior, esse comando definirá as ACLs para o bucket.
Obrigatório: Sim
`-a, --access-key` *access\$1key\$1id*
Seu ID de chave de acesso da AWS.
Obrigatório: sim
`-s, --secret-key` *secret\$1access\$1key*
Sua chave de acesso secreta da AWS.
Obrigatório: sim
`-t, --delegation-token` *token*
O token de delegação para repassar à solicitação da AWS. Para obter mais informações, consulte [Credenciais de segurança temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html) no *Guia do usuário do IAM*.
Obrigatório: Somente quando você usar credenciais temporárias de segurança.
Padrão: O valor da variável de ambiente `AWS_DELEGATION_TOKEN` (se definida).
`-m, --manifest` *path*
O caminho até o arquivo manifesto. O arquivo manifesto é criado durante o processo de empacotamento e pode ser localizado no diretório que contém o pacote.
Obrigatório: sim
`--url` *url*
Suspenso. Use a opção `--region` a menos que seu bucket esteja restrito ao local `EU` (e não `eu-west-1`). A marca `--location` é uma única forma de destinar essa restrição específica de local.
O URL do serviço de endpoint do Amazon S3.
Padrão: `https://s3.amazonaws.com/`
Exigido: Não
`--region` *region*
A região a ser usada na assinatura da solicitação para o bucket do S3 de destino.
+ Se o bucket não existir e você não especificar uma região, a ferramenta criará o bucket sem uma restrição de local (em `us-east-1`).
+ Se o bucket não existir e você especificar uma região, a ferramenta criará o bucket na região especificada.
+ Se o bucket existir e você não especificar uma região, a ferramenta usará o local do bucket.
+ Se o bucket existir e você especificar `us-east-1` como região, a ferramenta usará o local real do bucket sem nenhuma mensagem de erro e todos os arquivos correspondentes serão substituídos.
+ Se o bucket existir e você especificar uma região (além de `us-east-1`) que não corresponde ao local real do bucket, a ferramenta sairá com um erro.
Se seu bucket estiver restrito ao local `EU` (e não `eu-west-1`), use a marca `--location`. A marca `--location` é uma única forma de destinar essa restrição específica de local.
Padrão: `us-east-1`
Obrigatório: Sim se estiver usando a assinatura versão 4
`--sigv` *version*
A versão da assinatura a ser usada ao assinar a solicitação.
Valores válidos: `2` \$1 `4`
Padrão: `4`
Exigido: Não
`--acl` *acl*
A política de lista de controle de acesso da imagem empacotada.
Valores válidos: `public-read` \$1 `aws-exec-read`
Padrão: `aws-exec-read`
Exigido: Não
`-d, --directory` *directory*
O diretório que contém as partes da AMI empacotadas.
Padrão: O diretório que contém o arquivo manifesto (veja a opção `-m`).
Exigido: Não
`--part` *part*
Inicia a transferência da parte especificada e de todas as partes subsequentes. Por exemplo, `--part 04`.
Exigido: Não
`--retry`
Tenta novamente mais uma vez todos os erros de Amazon S3, até cinco vezes por operação.
Exigido: Não
`--skipmanifest`
Não faz upload do manifesto.
Exigido: Não
`--location` *location*
Suspenso. Use a opção `--region`, a menos que seu bucket esteja restrito ao local `EU` (e não `eu-west-1`). A marca `--location` é uma única forma de destinar essa restrição específica de local.
A restrição do local do bucket Amazon S3 de destino. Se o bucket existir e você especificar um local que não corresponde ao local real do bucket, a ferramenta sairá com um erro. Se o bucket existir e você não especificar um local, a ferramenta usará o local do bucket. Se o bucket não existir e você especificar um local, a ferramenta criará o bucket no local especificado. Se o bucket não existir e você não especificar um local, a ferramenta criará o bucket sem uma restrição de local (em `us-east-1`).
Padrão: se `--region` for especificado, o local será definido para essa região especificada. Se `--region` não for especificado, o local padrão será `us-east-1`.
Obrigatório: Não
### Resultado
O Amazon EC2 exibe mensagens de status que indicam os estágios e o status do processo de upload.
### Exemplo
Esse exemplo faz uploads do pacote especificado pelo manifesto `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.
```
## Opções comuns de ferramentas da AMI
A maioria das ferramentas da AMI aceita os parâmetros opcionais a seguir.
`--help, -h`
Exibe a mensagem de ajuda.
`--version`
Exibe a notificação de versão e direitos autorais.
`--manual`
Exibe a entrada manual.
`--batch`
Executa no modo em lote, suprimindo prompts interativos.
`--debug`
Exibe informações que podem ser úteis ao resolver problemas.
# 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
```