# Ciclo de vida da AMI do Amazon EC2
Uma Imagem de máquina da Amazon (AMI) é uma imagem que contém a configuração de software necessária para configurar e inicializar uma instância. Especifique uma AMI ao iniciar uma instância. É possível usar as AMIs fornecidas pela Amazon ou criar as suas próprias AMIs. A AMI deve estar localizada na Região da AWS em que você deseja iniciar a instância.
O ciclo de vida de uma AMI inclui sua criação, cópia, descontinuação, desabilitação e exclusão (cancelamento do registro).
**Criar AMIs.** Embora a Amazon forneça AMIs que podem ser usadas para iniciar as suas instâncias, você pode criar próprias AMIs personalizadas, de acordo com as suas necessidades. Para criar uma AMI personalizada, inicie uma instância em uma AMI existente, personalize a instância (por exemplo, instale software e defina as configurações do sistema operacional) e depois crie uma AMI na instância. Todas as personalizações da instância são salvas na nova AMI para que as instâncias iniciadas na nova AMI incluam essas personalizações.
**AMIs atestáveis.** Para criar uma AMI compatível com a atestação de instância do EC2, consulte [AMIs atestáveis](attestable-ami.md).
**Copiar AMIs.** É possível usar uma AMI para iniciar uma instância apenas na Região da AWS em que a AMI está localizada. Se você precisar iniciar instâncias com a mesma configuração em várias regiões, copie a AMI para as outras regiões.
**Descontinuar AMIs.** Para marcar uma AMI como superada ou desatualizada, você pode definir uma data de descontinuação imediata ou futura. As AMIs descontinuadas não constam das listagens de AMIs, mas os usuários e serviços podem continuar usando as AMIs descontinuadas se souberem seu ID.
**Desabilitar AMIs.** Para impedir temporariamente o uso de uma AMI, você pode desabilitá-la. Quando uma AMI é desabilitada, ela não pode ser usada para inicializar novas instâncias. No entanto, se você reabilitar a AMI, ela poderá ser usada para inicializar instâncias novamente. Observação: a desabilitação de uma AMI não afeta as instâncias existentes que já foram inicializadas a partir dela.
**Cancelar (excluir) o registro de AMIs.** Quando não precisar mais de uma AMI, será possível cancelar seu registro, evitando que ela seja usada para iniciar novas instâncias. Se a AMI atender a uma regra de retenção, ela será movida para a Lixeira, onde poderá ser restaurada antes que o período de retenção expire, depois do que será excluída permanentemente. Se não atender a nenhuma regra de retenção, ela será imediatamente excluída de modo permanente. Observe que cancelar o registro de uma AMI não afeta as instâncias que foram inicializadas na AMI.
**Automatizar o ciclo de vida da AMI.** É possível usar Amazon Data Lifecycle Manager para automatizar a criação, a retenção, a cópia, a defasagem e a exclusão de AMIs baseadas no Amazon EBS e seus snapshots de backup. Você também pode usar o EC2 Image Builder para automatizar a criação, o gerenciamento e a implantação das AMIs personalizadas. [Para obter mais informações, consulte [Automate backups with Amazon Data Lifecycle Manager](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-lifecycle.html) no *Amazon EBS User Guide* e no EC2 Image Builder User Guide](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
**Topics**
+ [Criar uma AMI](creating-an-ami-ebs.md)
+ [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md)
+ [Criar uma AMI usando o Sysprep do Windows](ami-create-win-sysprep.md)
+ [Copiar um AMI](CopyingAMIs.md)
+ [Armazenar e restaurar uma AMI](ami-store-restore.md)
+ [Ancestralidade da AMI](ami-ancestry.md)
+ [Uso de AMIs](ec2-ami-usage.md)
+ [Defasar uma AMI](ami-deprecate.md)
+ [Desabilitar uma AMI](disable-an-ami.md)
+ [Cancelar o registro de uma AMI](deregister-ami.md)
# Criação de uma AMI baseada no Amazon EBS
É possível criar sua própria AMI baseada no Amazon EBS com uma instância do Amazon EC2 ou com o snapshot do volume raiz de uma instância do Amazon EC2.
Para criar uma AMI baseada no Amazon EBS com uma instância, comece executando uma instância usando uma AMI baseada no Amazon EBS existente. Essa AMI pode ser uma que você obteve do AWS Marketplace, criada usando [VM Import/Export](https://docs.aws.amazon.com/vm-import/latest/userguide/what-is-vmimport.html) ou qualquer outra AMI que você possa acessar. Depois de personalizar a instância para atender aos seus requisitos específicos, crie e registre uma nova AMI. É possível usar a nova AMI para executar novas instâncias com suas personalizações.
**nota**
Para criar uma AMI compatível com a atestação de instância do EC2, consulte [AMIs atestáveis](attestable-ami.md).
Os procedimentos descritos abaixo funcionam para instâncias do Amazon EC2 baseada em volumes do Amazon Elastic Block Store (Amazon EBS) criptografados (incluindo o volume raiz), bem como para volumes descriptografados.
O processo de criação de AMIs é diferente para AMIs baseadas no Amazon S3. Para obter mais informações, consulte [Criação de uma AMI baseada no Amazon S3](creating-an-ami-instance-store.md).
**Topics**
+ [Visão geral da criação de AMI usando uma instância](#process-creating-an-ami-ebs)
+ [Criação de uma AMI usando uma instância](#how-to-create-ebs-ami)
+ [Criar uma AMI de um snapshot](#creating-launching-ami-from-snapshot)
## Visão geral da criação de AMI usando uma instância
O diagrama a seguir resume o processo de criação de uma AMI baseada no Amazon EBS a partir de uma instância do EC2 em execução: comece com uma AMI existente, inicie uma instância, personalize-a, crie uma nova AMI a partir dela e, por fim, inicie uma instância de sua nova AMI. Os números no diagrama correspondem aos números na descrição a seguir.
![\[Fluxo de trabalho para a criação de uma AMI de uma instância\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/running-instance.png)
**1 – AMI \$11: comece com uma AMI existente**
Encontre uma AMI existente semelhante à AMI que você deseja criar. Pode ser uma AMI que você obteve do AWS Marketplace, uma AMI que você criou usando [VM Import/Export](https://docs.aws.amazon.com/vm-import/latest/userguide/what-is-vmimport.html) ou qualquer outra AMI que você possa acessar. Você personalizará essa AMI para suas necessidades.
No diagrama, **EBS root volume snapshot \$11** (Snapshot do volume raiz do EBS \$11) indica que a AMI é uma AMI baseada no Amazon EBS e que as informações sobre o volume raiz são armazenadas neste snapshot.
**2 – iniciar instância a partir da AMI existente**
A maneira de configurar uma AMI é iniciar uma instância a partir da AMI na qual você gostaria de basear sua nova AMI e, em seguida, personalizar a instância (indicado em **3** no diagrama). Em seguida, você vai criar uma nova AMI que inclua as personalizações (indicado em **4** no diagrama).
**3 – instância do EC2 \$11: personalize a instância**
Conecte-se à sua instância e personalize-a para suas necessidades. Sua nova AMI incluirá essas personalizações.
É possível executar qualquer uma destas ações em sua instância para personalizá-la:
+ Instalar o software e aplicações
+ Copiar dados
+ Reduzir o tempo de inicialização excluindo arquivos temporários e desfragmentando o disco rígido
+ Anexar volumes adicionais do EBS
**4 – Crie a imagem**
Quando você cria uma AMI a partir de uma instância, o Amazon EC2 desativa a instância antes de criar a AMI para garantir que tudo na instância seja interrompido e esteja em um estado consistente durante o processo de criação. Se você estiver seguro de que sua instância está em um estado consistente e apropriado para a criação da AMI, poderá informar ao Amazon EC2 para não desativar e reiniciar a instância. Alguns sistemas de arquivos, como o XFS, podem congelar e descongelar atividades, tornando seguro criar a imagem sem reinicializar a instância.
Durante o processo de criação da AMI, o Amazon EC2 cria snapshots do volume raiz de sua instância e de todos os outros volumes do EBS anexados à sua instância. Você é cobrado pelos snapshots até que você [cancele o registro da AMI](deregister-ami.md) e exclua os snapshots. Se qualquer volume anexado à instância estiver criptografado, a nova AMI só será iniciada com êxito em instâncias com suporte para a criptografia do Amazon EBS.
Dependendo do tamanho dos volumes, pode levar vários minutos para que o processo de criação da AMI se complete (às vezes até 24 horas). É possível achar mais eficiente criar snapshots de seus volumes antes de criar sua AMI. Dessa forma, apenas snapshots pequenos e incrementais precisam ser criados quando a AMI é criada, e o processo é concluído mais rapidamente (o tempo total para a criação de snapshot permanece o mesmo.)
**5 – AMI \$12: nova AMI**
Após a conclusão do processo, você terá novos AMI e snapshot (**snapshot \$12**) criados a partir do volume raiz da instância. Se você adicionou volumes de armazenamento de instância ou volumes do EBS à instância, além do volume raiz, o mapeamento de dispositivos de blocos para a nova AMI conterá informações sobre esses volumes.
O Amazon EC2 registra automaticamente a AMI para você.
**6 – inicie uma instância a partir da nova AMI**
É possível usar a nova AMI para iniciar uma instância.
**7 – instância do EC2 \$12: nova instância**
Quando você inicia uma instância usando a nova AMI, o Amazon EC2 cria um novo volume do EBS para o volume raiz da instância usando o snapshot. Se você adicionou volumes de armazenamento de instância ou volumes do EBS ao personalizar a instância, o mapeamento de dispositivos de blocos para a nova AMI conterá informações sobre esses volumes, e os mapeamentos de dispositivos de blocos para as instâncias iniciadas usando a nova AMI também incluirão, de forma automática, informações sobre esses volumes. Os volumes de armazenamento de instâncias especificados no mapeamento de dispositivos de blocos para a nova instância são novos e não contêm dados dos volumes de armazenamento de instâncias da instância usada para criar a AMI. Os dados nos volumes do EBS persistem. Para obter mais informações, consulte [Mapeamento de dispositivos de blocos para volumes em instâncias do Amazon EC2](block-device-mapping-concepts.md).
Ao criar uma nova instância de uma AMI com suporte do EBS, é necessário inicializar o volume raiz todo o armazenamento adicional EBS antes de colocá-lo em produção. Para obter mais informações, consulte [Inicializar volumes do Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-initialize.html) no *Guia do usuário do Amazon EBS*.
## Criação de uma AMI usando uma instância
Caso já tenha uma instância, você pode criar uma AMI dela.
------
#### [ Console ]
**Criar uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Selecione a instância da qual a AMI será criada e escolha **Actions** (Ações), **Image and templates** (Imagem e modelos), **Create image** (Criar imagem).
**dica**
Se essa opção está desabilitada, sua instância não é uma instância baseada no Amazon EBS.
1. Na página **Create image** (Criar imagem), especifique as seguintes informações:
1. Em **Image name** (Nome da imagem), insira um nome exclusivo para a imagem com até 127 caracteres.
1. Em **Image description** (Descrição da imagem), insira uma descrição opcional da imagem, com até 255 caracteres.
1. Em **Reinicializar instância**, mantenha a caixa de seleção marcada (o padrão) ou desmarque-a.
+ Se **Reinicializar instância** estiver desmarcado, quando o Amazon EC2 criar a nova AMI, ele reinicializará a instância para que ela possa obter snapshots dos volumes anexados enquanto os dados estiverem em repouso, a fim de garantir um estado consistente.
+ Se **Inicializar instância** estiver desmarcado, quando o Amazon EC2 criar a nova AMI, ele não fechará e reinicializará a instância.
**Atenção**
Se você desmarcar **Inicializar instância**, não poderemos garantir a integridade do sistema de arquivos da imagem criada.
1. **Volumes da instância**: você pode modificar o volume raiz e adicionar volumes do Amazon EBS e volumes com armazenamento de instância, como mostrado a seguir:
1. O volume raiz é definido na primeira linha.
+ Para alterar o tamanho do volume raiz, em **Size** (Tamanho), insira o valor necessário.
+ Se você selecionar **Delete on Termination** (Excluir ao encerrar), quando encerrar a instância criada a partir desta AMI, o volume do EBS será excluído. Se você não selecionar **Delete on Termination** (Excluir ao encerrar), quando encerrar a instância, o volume do EBS não será excluído. Para obter mais informações, consulte [Preservação de dados quando uma instância for encerrada](preserving-volumes-on-termination.md).
1. Para adicionar o volume do EBS; escolha **Add volume** (Adicionar volume) (que acrescenta uma nova linha). Em **Tipo de armazenamento**, escolha **EBS** e preencha os campos da linha. Quando você executa uma instância da nova AMI, os volumes adicionais são anexados automaticamente à instância. Os volumes vazios devem ser formatados e montados. Os volumes baseados em um snapshot devem ser montados.
1. Para adicionar um volume de armazenamento de instância, consulte [Adicionar volumes de armazenamento de instância a uma AMI do Amazon EC2](adding-instance-storage-ami.md). Quando você executa uma instância da nova AMI, os volumes adicionais são automaticamente inicializados e montados. Esses volumes não contêm dados de volumes de armazenamento de instâncias da instância em execução na qual a AMI foi baseada.
1. **Destino do snapshot**: se os volumes da instância estiverem em uma zona local que seja compatível com snapshots locais do EBS, escolha onde criar os snapshots da AMI:
+ **Região da AWS**: crie snapshots na região principal da zona local dos volumes.
+ **Zona local da AWS**: crie snapshots na mesma zona local dos volumes.
**nota**
Essa opção aparece somente em zonas locais compatíveis com snapshots locais do EBS e apenas se a instância foi criada em uma zona local. Se o volume estiver em uma região, essa opção não aparecerá e o snapshot será criado automaticamente na mesma região que o volume. Para obter mais informações, consulte [Local snapshots in Local Zones](https://docs.aws.amazon.com/ebs/latest/userguide/snapshots-localzones.html) no *Guia do usuário do Amazon EBS*.
**Importante**
Todos os snapshots dos volumes da instância devem estar no mesmo local. Verifique a localização dos snapshots existentes. Se algum snapshot existente estiver em um local diferente do destino selecionado, a criação da AMI falhará.
1. **Tags**: é possível marcar a AMI e os snapshots com as mesmas tags ou pode marcá-los com tags diferentes.
+ Para marcar a AMI e os snapshots com as *mesmas* tags, escolha **Tag image and snapshots together** (Marcar Imagem e snapshots juntos). As mesmas tags são aplicadas à AMI e a cada snapshot criado.
+ Para marcar a AMI e os snapshots com tags *diferentes*, escolha **Tag image and snapshots separately** (Marcar imagem e snapshots separadamente). Diferentes tags são aplicadas à AMI e aos snapshots criados. No entanto, todos os snapshots obtêm as mesmas tags; não é possível marcar cada snapshot com uma tag diferente.
(Opcional) Para adicionar uma tag, escolha **Add tag** (Adicionar tag) e digite a chave e o valor da tag. Repita esse procedimento para cada tag.
1. Quando você estiver pronto para criar a AMI, escolha **Create image** (Criar imagem).
1. Para visualizar o status da AMI enquanto ela estiver sendo criada:
1. No painel de navegação, selecione **AMIs**.
1. Defina o filtro como **Owned by me** (De minha propriedade) e encontre a AMI na lista.
Inicialmente, o status será `pending`, mas deverá mudar para `available` após alguns minutos.
1. (Opcional) Para visualizar o snapshot que foi criado para a nova AMI:
1. Anote o ID da AMI que você localizou na etapa anterior.
1. No painel de navegação, escolha **Snapshots**.
1. Defina o filtro como **Owned by me** (De minha propriedade) e, em seguida, localize o snapshot da novo ID da AMI na coluna **Description** (Descrição).
Ao iniciar uma instância com essa AMI, o Amazon EC2 usa esse snapshot para criar o volume raiz da instância.
------
#### [ AWS CLI ]
**Criar uma AMI**
Use o comando [create-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html).
```
aws ec2 create-image \
--instance-id i-1234567890abcdef0 \
--name "my-web-server" \
--description "My web server image" \
--no-reboot
```
------
#### [ PowerShell ]
**Criar uma AMI**
Use o cmdlet [New-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2Image.html).
```
New-EC2Image `
-InstanceId i-1234567890abcdef0 `
-Name "my-web-server" `
-Description "My web server image" `
-NoReboot $true
```
------
## Criar uma AMI de um snapshot
Caso você tenha um snapshot do volume raiz de uma instância, será possível criar uma AMI usando esse snapshot.
**nota**
Na maioria dos casos, as AMIs para Windows, Red Hat, SUSE e SQL Server exigem que as informações corretas de licenciamento estejam presentes na AMI. Para obter mais informações, consulte [Noções básicas sobre as informações de faturamento da AMI](ami-billing-info.md). Ao criar uma AMI de um snapshot, a operação `RegisterImage` obtém as informações de faturamento corretas dos metadados do snapshot, mas isso exige que os metadados apropriados estejam presentes. Para verificar se as informações de cobrança corretas foram aplicadas, verifique o campo **Detalhes da plataforma** na nova AMI. Se o campo estiver vazio ou não corresponder ao código esperado do sistema operacional (por exemplo, Windows, Red Hat, SUSE ou SQL), a criação da AMI não teve êxito e você deverá descartá-la e seguir as instruções em [Criação de uma AMI usando uma instância](#how-to-create-ebs-ami).
------
#### [ Console ]
**Criar uma AMI de um snapshot**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Snapshots**.
1. Selecione o snapshot do qual a AMI será criada e escolha **Actions**, (Ações), **Create image from snapshot** (Criar imagem do snapshot).
1. Na página **Criar imagem de um snapshot**, especifique as seguintes informações:
1. Em **Image name** (Nome da imagem), insira um nome descritivo para a imagem.
1. Em **Description** (Descrição), insira uma breve descrição da imagem.
1. Em **Architecture** (Arquitetura), escolha a arquitetura da imagem. Escolha **i386** para 32 bits, **x86\$164** para 64 bits, **arm64** para ARM de 64 bits ou **x86\$164** para macOS de 64 bits.
1. Em **Nome do dispositivo raiz**, insira o nome do dispositivo que será usado para o volume raiz. Para obter mais informações, consulte [Nomes de dispositivos para volumes em instâncias do Amazon EC2](device_naming.md).
1. Em **Virtualization type** (Tipo de virtualização), escolha o tipo de virtualização a ser usado por instâncias iniciadas partir dessa AMI. Para obter mais informações, consulte [Tipos de virtualização](ComponentsAMIs.md#virtualization_types).
1. (Somente para virtualização paravirtual) Em **Kernel ID** (ID do kernel), selecione o kernel do sistema operacional para a imagem. Se você estiver usando um snapshot do volume raiz de uma instância, selecione o mesmo ID de kernel da instância original. Se não tiver certeza, use o kernel padrão.
1. (Somente para virtualização paravirtual) Ema **RAM disk ID** (ID do disco de RAM), selecione o disco de RAM para a imagem. Se você selecionar um kernel específico, pode precisar selecionar um disco de RAM específico com os drivers que ofereçam suporte a ele.
1. Em **Modo de inicialização**, escolha o modo de inicialização para a imagem ou escolha **Usar padrão** para que, quando uma instância for iniciada com essa AMI, ela seja inicializada com o modo de inicialização com suporte para o tipo de instância. Para obter mais informações, consulte [Definir o modo de inicialização de uma AMI do Amazon EC2](set-ami-boot-mode.md).
1. (Opcional) Em **Mapeamentos de dispositivos de blocos**, personalize o volume raiz e adicione os demais volumes de dados.
Para cada volume, é possível especificar o tamanho, o tipo, as características de performance, o comportamento de exclusão ao término e o status da criptografia. Para o volume da raiz, o tamanho não pode ser menor do que o tamanho do snapshot. Para o tipo de volume, o SSD de uso geral `gp3` é a seleção padrão.
1. (Opcional) Em **Tags**, você pode adicionar uma ou mais tags à nova AMI. (Opcional) Para adicionar uma tag, escolha **Add tag** (Adicionar tag) e digite a chave e o valor da tag. Repita esse procedimento para cada tag.
1. Quando você estiver pronto para criar a AMI, escolha **Create image** (Criar imagem).
1. (Somente para Windows, Red Hat, SUSE e SQL Server) Para verificar se as informações de cobrança corretas foram aplicadas, verifique o campo **Detalhes da plataforma** na nova AMI. Se o campo estiver vazio ou não corresponder ao código esperado do sistema operacional (por exemplo, **Windows** ou **Red Hat**), a criação da AMI não teve êxito e você deverá descartá-la e seguir as instruções em [Criação de uma AMI usando uma instância](#how-to-create-ebs-ami).
------
#### [ AWS CLI ]
**Para criar uma AMI a partir de um snapshot usando a AWS CLI**
Use o comando [register-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html).
```
aws ec2 register-image \
--name my-image \
--root-device-name /dev/xvda \
--block-device-mappings DeviceName=/dev/xvda,Ebs={SnapshotId=snap-0db2cf683925d191f}
```
------
#### [ PowerShell ]
**Para criar uma AMI a partir de um snapshot usando o PowerShell**
Use o cmdlet [Register-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Register-EC2Image.html).
```
$block = @{SnapshotId=snap-0db2cf683925d191f}
Register-EC2Image `
-Name my-image `
-RootDeviceName /dev/xvda `
-BlockDeviceMapping @{DeviceName="/dev/xvda";Ebs=$block}
```
------
# 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
```
# Criar uma AMI do Amazon EC2 usando o Sysprep do Windows
A ferramenta Preparação do sistema da Microsoft (Sysprep do Windows) cria uma versão generalizada do sistema operacional, com a configuração do sistema específica da instância removida antes de capturar uma nova imagem.
Recomendamos que você use o [EC2 Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html) para automatizar a criação, o gerenciamento e a implantação de imagens de servidor “douradas” personalizadas, seguras e atualizadas que são pré-instaladas e pré-configuradas com software e configurações.
Você também pode usar o Sysprep do Windows para criar uma AMI padronizada usando os agentes de inicialização do Windows: EC2Launch v2, EC2Launch e EC2Config.
**Importante**
Não use o Sysprep do Windows para criar um backup da instância. O Sysprep do Windows remove informações específicas do sistema; a remoção dessas informações pode ter consequências não intencionais para um backup da instância.
Para solucionar problemas do Sysprep do Windows, consulte [Solucionar problemas de Sysprep com instâncias do Windows do Amazon EC2](sysprep-troubleshoot.md).
**Topics**
+ [Fases do Sysprep do Windows](#sysprep-phases)
+ [Antes de começar](#sysprep-begin)
+ [Usar o Sysprep do Windows com o EC2Launch v2](sysprep-using-ec2launchv2.md)
+ [Usar o Sysprep do Windows com o EC2Launch](ec2launch-sysprep.md)
+ [Usar o Sysprep do Windows com o EC2Config](sysprep-using.md)
## Fases do Sysprep do Windows
O Sysprep do Windows é executado nas seguintes fases:
+ **Generalizar**: a ferramenta Sysprep remove informações e configurações específicas da imagem. Por exemplo, o Sysprep do Windows remove o identificador de segurança (SID), o nome do computador, os logs de evento e drivers específicos, entre outros. Após essa fase ser encerrada, o sistema operacional (SO) estará pronto para criar a AMI.
**nota**
Quando você executa o Sysprep do Windows com os agentes de inicialização do Windows, o sistema impede que os drivers sejam removidos porque, por padrão, `PersistAllDeviceInstalls` é definida como verdadeira.
+ **Especializar**: o plug and play examina o computador e instala drivers para todos os dispositivos detectados. A ferramenta Sysprep gera requisitos do SO, como o nome do computador e o SID. Opcionalmente, é possível executar comandos nessa fase.
+ **Experiência Out-of-Box (OOBE)**: o sistema executa uma versão abreviada da configuração do Windows e pede para o usuário inserir informações como o idioma do sistema, o fuso horário e a organização registrada. Quando você executa o Sysprep do Windows com os agentes de inicialização do Windows, o arquivo de resposta automatiza essa fase.
## Antes de começar
+ Antes da execução do Sysprep do Windows, recomendamos que você remova todas as contas de usuário locais e todos os perfis de conta, exceto uma única conta de administrador em que o Sysprep do Windows será executado. Caso execute o Sysprep do Windows com contas e perfis adicionais, poderá ocorrer um comportamento inesperado, inclusive a perda de dados de perfil ou a falha de conclusão do Sysprep do Windows.
+ Saiba mais em [Visão geral do Sysprep](https://learn.microsoft.com/en-us/windows-hardware/manufacture/desktop/sysprep--system-preparation--overview).
+ Saiba quais [perfis do servidor são compatíveis com o Sysprep](https://learn.microsoft.com/en-us/windows-hardware/manufacture/desktop/sysprep-support-for-server-roles).
# Criar uma AMI usando o Sysprep do Windows com o EC2Launch v2
Quando você cria uma imagem de uma instância com o agente EC2Launch v2 instalado, ele realiza tarefas específicas à medida que a imagem é preparada. Isso inclui trabalhar com o Sysprep do Windows. Para obter mais informações, consulte [Fases do Sysprep do Windows](ami-create-win-sysprep.md#sysprep-phases).
**Topics**
+ [Ações do Sysprep do Windows](#sysprep-actions-ec2launchv2)
+ [Após Sysprep](#sysprep-post-ec2launchv2)
+ [Executar o Sysprep do Windows com o EC2Launch v2](#sysprep-gui-procedure-ec2launchv2)
## Ações do Sysprep do Windows
O Sysprep do Windows e o EC2Launch v2 executam as ações a seguir na preparação de uma imagem.
1. Quando você escolhe **Shutdown with Sysprep (Desligar com Sysprep)** na caixa de diálogo **EC2Launch settings (Configurações do EC2Launch)**, o sistema executa o comando `ec2launch sysprep`.
1. O EC2Launch v2 edita o conteúdo do arquivo `unattend.xml` lendo o valor do registro em `HKEY_USERS\.DEFAULT\Control Panel\International\LocaleName`. O arquivo está localizado no seguinte diretório: `C:\ProgramData\Amazon\EC2Launch\sysprep`.
1. O sistema executa o `BeforeSysprep.cmd`. Esse comando cria uma chave de registro da seguinte maneira:
**reg add "HKEY\$1LOCAL\$1MACHINE\$1SYSTEM\$1CurrentControlSet\$1Control\$1Terminal Server" /v fDenyTSConnections /t REG\$1DWORD /d 1 /f**
A chave de registro desabilita as conexões RDP até serem re-habilitadas. Desabilitar as conexões RDP é uma medida de segurança necessária, pois, na primeira sessão de inicialização após o Sysprep do Windows ser executado, há um breve período no qual o RDP permite conexões e a senha do Administrador fica em branco.
1. O serviço do EC2Launch v2 chama o Sysprep do Windows ao executar o seguinte comando:
**sysprep.exe /oobe /generalize /shutdown /unattend: "C:\$1ProgramData\$1Amazon\$1EC2Launch\$1sysprep\$1unattend.xml"**
### Generalizar a fase
+ O EC2Launch v2 remove informações e configurações específicas da imagem, como o nome do computador e o SID. Se a instância pertencer a um domínio, ela será removida do domínio. O arquivo de resposta `unattend.xml` inclui as seguintes configurações que afetam a fase:
+ **PersistAllDeviceInstalls**: essa configuração impede que a Configuração do Windows remova e reconfigure dispositivos, o que acelera o processo de preparação de imagem, pois as AMIs da Amazon exigem a execução de determinados drivers e a nova detecção desses drivers tomaria o tempo.
+ **DoNotCleanUpNonPresentDevices**: essa configuração retém informações de plug and play para dispositivos que não estão presentes no momento.
+ O Sysprep do Windows fecha o SO à medida que se prepara para criar a AMI. O sistema executa uma nova instância ou inicia a instância original.
### Fase especializada
O sistema gera requisitos específicos do sistema operacional, como um nome de computador e um SID. O sistema também executa as ações a seguir com base nas configurações que você especifica no arquivo de resposta `unattend.xml`.
+ **CopyProfile**: o Sysprep do Windows pode ser configurado para excluir todos os perfis de usuário, incluindo o perfil incorporado do Administrador. Essa configuração retém a conta incorporada do administrador, de forma que todas as personalizações que você fizer nessa conta serão transferidas para a nova imagem. O valor padrão é `True`.
**CopyProfile** substitui o perfil padrão pelo perfil de administrador local existente. Todas as contas em que você faz login depois da execução do Sysprep do Windows recebem uma cópia desse perfil e do conteúdo dele no primeiro login.
Se você não tiver personalizações específicas do perfil do usuário que deseja transferir para a nova imagem, altere essa configuração para `False`. O Sysprep do Windows removerá todos os perfis de usuário (isso economiza tempo e espaço em disco).
+ **TimeZone**: o fuso horário é definido como Coordinated Universal Time (UTC – Tempo universal coordenado), por padrão.
+ **Comando síncrono com pedido 1**: o sistema executa o comando a seguir, que habilita a conta do administrador e especifica o requisito de senha:
```
net user Administrator /ACTIVE:YES /LOGONPASSWORDCHG:NO /EXPIRES:NEVER /PASSWORDREQ:YES
```
+ **Comando síncrono com pedido 2**: o sistema vasculha a senha do administrador. Essa medida de segurança foi criada para impedir que a instância seja acessível após a conclusão do Sysprep do Windows, caso você não tenha configurado a tarefa `setAdminAccount`.
O sistema executa o seguinte comando no diretório local do agente de inicialização (`C:\Program Files\Amazon\EC2Launch\`).
```
EC2Launch.exe internal randomize-password --username Administrator
```
+ Para habilitar conexões de área de trabalho remota, o sistema define a chave de registro `fDenyTSConnections` do Terminal Server como false.
### Fase OOBE
1. O sistema especifica as seguintes configurações usando o arquivo de resposta do EC2Launch v2:
+ `en-US`
+ `en-US`
+ `en-US`
+ `en-US`
+ `true`
+ `true`
+ `3`
+ `false`
+ `UTC`
+ `Amazon.com`
+ `EC2`
**nota**
Durante as fases de generalização e de especialização, o EC2Launch v2 monitora o status do sistema operacional. Se o EC2Launch v2 detectar que o sistema operacional está na fase Sysprep, ele publicará a seguinte mensagem no log do sistema:
O Windows está sendo configurado. SysprepState=IMAGE\$1STATE\$1UNDEPLOYABLE
1. O sistema executa o EC2Launch v2.
## Após Sysprep
Após a conclusão do Sysprep do Windows, o EC2Launch v2 envia a seguinte mensagem para a saída do console:
```
Windows sysprep configuration complete.
```
Depois, o EC2Launch v2 executa as ações a seguir:
1. Lê o conteúdo do arquivo `agent-config.yml` e executa as tarefas configuradas.
1. Executa todas as tarefas no estágio `preReady`.
1. Após a conclusão, envia uma mensagem `Windows is ready` para os logs do sistema de instância.
1. Executa todas as tarefas no estágio `PostReady`.
Para obter mais informações sobre o EC2Launch v2, consulte [Usar o agente do EC2Launch v2 para realizar tarefas durante a execução da instância EC2 Windows](ec2launch-v2.md).
## Executar o Sysprep do Windows com o EC2Launch v2
Use o procedimento a seguir para criar uma AMI padronizada usando o Sysprep do Windows com o EC2Launch v2.
1. No console do Amazon EC2, localize uma AMI que você deseja duplicar.
1. Execute e conecte-se à sua instância do Windows.
1. Personalizar configurações
1. No menu **Start (Iniciar)** do Windows, procure e escolha **Amazon EC2Launch settings (Configurações do Amazon EC2Launch)**. Para obter mais informações sobre as opções e configurações na caixa de diálogo **Amazon EC2Launch settings (Configurações do Amazon EC2Launch)**, consulte [Definição das configurações do EC2Launch v2 para instâncias do Windows](ec2launch-v2-settings.md).
1. Se você fez alterações, escolha **Salvar** antes de desligar.
1. Selecione **Desligar com Sysprep** ou **Desligar sem Sysprep**.
Quando você receber uma solicitação para confirmar que deseja executar o Sysprep do Windows e desativar a instância, clique em **Sim**. O EC2Launch v2 executa o Sysprep do Windows. Você é desconectado da instância, e a instância é desligada. Se você verificar a página **Instances** (Instâncias) no console do Amazon EC2, o estado da instância será alterado de `Running` para `Stopping` e para `Stopped`. Nesse momento, é seguro criar uma AMI com base nessa instância.
Você pode invocar manualmente a ferramenta Sysprep do Windows pela linha de comando usando o seguinte comando:
```
"%programfiles%\amazon\ec2launch\ec2launch.exe" sysprep --shutdown=true
```
# Criar uma AMI usando o Sysprep do Windows com o EC2Launch
Quando você cria uma imagem de uma instância com o agente EC2Launch instalado, ele realiza tarefas específicas à medida que a imagem é preparada. Isso inclui trabalhar com o Sysprep do Windows. Para obter mais informações, consulte [Fases do Sysprep do Windows](ami-create-win-sysprep.md#sysprep-phases).
O EC2Launch oferece um arquivo de resposta padrão e arquivos em lote para o Sysprep do Windows que automatizam e protegem o processo de preparação de imagem na AMI. A modificação desses arquivos é opcional. Esses arquivos estão localizados no seguinte diretório por padrão: `C:\ProgramData\Amazon\EC2-Windows\Launch\Sysprep`.
**Importante**
Não use o Sysprep do Windows para criar um backup da instância. O Sysprep do Windows remove as informações específicas do sistema. Se você remover essas informações, poderá haver consequências não intencionais em um backup da instância.
**Topics**
+ [Arquivos de resposta e em lotes do EC2Launch para o Sysprep do Windows](#ec2launch-sysprep-answer-batch)
+ [Executar o Sysprep do Windows com o EC2Launch](#ec2launch-sysprep-running)
+ [Para atualizar rotas de metadados/KMS para o Server 2016 e posterior ao iniciar uma AMI personalizada](#update-metadata-KMS)
## Arquivos de resposta e em lotes do EC2Launch para o Sysprep do Windows
O arquivo de resposta e os arquivos em lote do EC2Launch para o Sysprep incluem o seguinte:
`Unattend.xml`
Esse é o arquivo de resposta padrão. Se você executar o `SysprepInstance.ps1` ou escolher **ShutdownWithSysprep** na interface do usuário, o sistema lerá a configuração nesse arquivo.
`BeforeSysprep.cmd`
Personalize esse arquivo em lote para executar comandos antes que o EC2Launch execute o Sysprep do Windows.
`SysprepSpecialize.cmd`
Personalize esse arquivo em lotes para executar comandos durante a fase de especialização do Sysprep do Windows.
## Executar o Sysprep do Windows com o EC2Launch
Na instalação completa do Windows Server 2016 e posterior (com uma experiência de desktop), é possível executar o Sysprep do Windows com o EC2Launch manualmente ou usando a aplicação **Configurações do EC2Launch**.
**Executar o Sysprep do Windows usando a aplicação Configurações do EC2Launch**
1. No console do Amazon EC2, localize ou crie uma AMI do Windows Server 2016 ou posterior.
1. Execute uma instância do Windows a partir da AMI.
1. Conecte-se à sua instância do Windows e personalize-a.
1. Pesquise e execute a aplicação **EC2LaunchSettings**. Por padrão, ele está localizado no seguinte diretório: `C:\ProgramData\Amazon\EC2-Windows\Launch\Settings`.
![\[Aplicação de configurações de execução do EC2\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ec2launch-sysprep.png)
1. Selecione ou limpe as opções conforme for necessário. Essas configurações são armazenadas no arquivo `LaunchConfig.json`.
1. Em **Administrator password**, faça uma das seguintes ações:
+ Escolha **Random**. O EC2Launch gera uma senha e criptografa-a usando a chave de usuário. O sistema desativa essa configuração depois da execução da instância, portanto, essa senha persistirá se a instância for reinicializada ou parada e iniciada.
+ Escolha **Specify** e digite a senha que atende aos requisitos do sistema. A senha é armazenada em `LaunchConfig.json` como texto não criptografado e será excluída depois que o Sysprep do Windows definir a senha de administrador. Se você fechar agora, a senha será definida imediatamente. O EC2Launch criptografa a senha usando a chave de usuário.
+ Escolha **DoNothing** e especifique uma senha no arquivo `unattend.xml`. Se você não especificar uma senha em `unattend.xml`, a conta de administrador ficará desativada.
1. Escolha **Shutdown with Sysprep (Desligar com Sysprep)**.
**Executar o Sysprep do Windows manualmente usando o EC2Launch**
1. No console do Amazon EC2, localize ou crie uma AMI Datacenter Edition do Windows Server 2016 ou posterior que você deseja duplicar.
1. Execute e conecte-se à sua instância do Windows.
1. Personalize a instância.
1. Especifique as configurações no arquivo `LaunchConfig.json`. Por padrão, esse arquivo está localizado no diretório `C:\ProgramData\Amazon\EC2-Windows\Launch\Config`.
Para `adminPasswordType`, especifique um dos seguintes valores:
`Random`
O EC2Launch gera uma senha e criptografa-a usando a chave de usuário. O sistema desativa essa configuração depois da execução da instância, portanto, essa senha persistirá se a instância for reinicializada ou parada e iniciada.
`Specify`
O EC2Launch usa a senha que você especifica `adminPassword`. Se a senha não atender aos requisitos de sistema, o EC2Launch gera uma senha aleatória. A senha é armazenada em `LaunchConfig.json` como texto não criptografado e será excluída depois que o Sysprep do Windows definir a senha de administrador. O EC2Launch criptografa a senha usando a chave de usuário.
`DoNothing`
O EC2Launch usa a senha que você especifica o arquivo `unattend.xml`. Se você não especificar uma senha em `unattend.xml`, a conta de administrador ficará desativada.
1. (Opcional) Especifique as configurações em `unattend.xml` e em outros arquivos de configuração. Se o plano atender à instalação, você não precisará fazer alterações nesses arquivos. Por padrão, os arquivos estão localizados no seguinte diretório: `C:\ProgramData\Amazon\EC2-Windows\Launch\Sysprep`.
1. No Windows PowerShell, execute `./InitializeInstance.ps1 -Schedule`. Por padrão, o script está localizado no seguinte diretório: `C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts`. Esse script agenda a instância para ser inicializada durante a próxima inicialização. Execute esse script antes de executar o script `SysprepInstance.ps1` na próxima etapa.
1. No Windows PowerShell, execute `./SysprepInstance.ps1`. Por padrão, o script está localizado no seguinte diretório: `C:\ProgramData\Amazon\EC2-Windows\Launch\Scripts`.
Você é desconectado da instância, e a instância é encerrada. Se você verificar a página **Instances** (Instâncias) no console do Amazon EC2, o estado da instância será alterado de `Running` para `Stopping` e, em seguida, para `Stopped`. Nesse momento, é seguro criar uma AMI com base nessa instância.
## Para atualizar rotas de metadados/KMS para o Server 2016 e posterior ao iniciar uma AMI personalizada
Para atualizar rotas de metadados/KMS para o Server 2016 e posterior ao iniciar uma AMI personalizada, siga estas etapas:
+ Execute a GUI EC2LaunchSettings (C:\$1ProgramData\$1Amazon\$1EC2-Windows\$1Launch\$1Settings\$1Ec2LaunchSettings.exe) e selecione a opção para encerrar com o Sysprep do Windows.
+ Execute EC2LaunchSettings e desligue sem o Sysprep do Windows antes de criar a AMI. Isso configura as tarefas de inicialização do EC2 para serem executadas na próxima inicialização, que definirá as rotas com base na sub-rede da instância.
+ Reprograme manualmente as tarefas de inicialização do EC2 antes de criar uma AMI do [PowerShell](ec2launch-config.md#ec2launch-inittasks).
**Importante**
Observe o comportamento padrão de redefinição de senha antes de reprogramar as tarefas.
+ Para atualizar as rotas em uma instância em execução que está passando por ativação do Windows ou comunicação com falhas de metadados de instância, consulte [“Não é possível ativar o Windows”](common-messages.md#activate-windows).
# Criar uma AMI usando o Sysprep do Windows com o EC2Config
Quando você cria uma imagem de uma instância com o serviço EC2Config instalado, ele realiza tarefas específicas à medida que a imagem é preparada. Isso inclui trabalhar com o Sysprep do Windows. Para obter mais informações, consulte [Fases do Sysprep do Windows](ami-create-win-sysprep.md#sysprep-phases).
**Topics**
+ [Ações do Sysprep do Windows](#sysprep-actions)
+ [Após Sysprep](#sysprep-post)
+ [Executar o Sysprep do Windows com o serviço do EC2Config](#sysprep-gui-procedure)
## Ações do Sysprep do Windows
O Sysprep do Windows e o serviço do EC2Config executam as ações a seguir na preparação de uma imagem.
1. Quando você escolhe **Encerrar com o Sysprep** na caixa de diálogo **Propriedades do EC2 Service)**, o sistema executa o comando **ec2config.exe -sysprep**.
1. O serviço EC2Config lê o conteúdo do arquivo `BundleConfig.xml`. Esse arquivo está localizado no diretório a seguir, por padrão: `C:\Program Files\Amazon\Ec2ConfigService\Settings`.
O arquivo `BundleConfig.xml` inclui as seguintes configurações. É possível alterar essas configurações:
+ **AutoSysprep**: indica se o Sysprep do Windows deve ser usado automaticamente. Você não precisará mudar esse valor se estiver executando o Sysprep do Windows pela caixa de diálogo de propriedades do serviço do EC2. O valor padrão é `No`.
+ **SetRDPCertificate**: define um certificado autoassinado para o servidor de Desktop Remoto. Isso permite que você use com segurança o Remote Desktop Protocol (RDP) para se conectar à instância. Altere o valor para `Yes` se as novas instâncias precisarem usar um certificado. Essa configuração não é usada com instâncias Windows Server 2012 porque esses sistemas operacionais podem gerar seus próprios certificados. O valor padrão é `No`.
+ **SetPasswordAfterSysprep**: define uma senha aleatória em uma instância recém-executada, criptografa-a com a chave de execução do usuário e gera a senha criptografada no console. Altere o valor para `No` se novas instâncias não precisarem ser definidas com uma senha criptografada aleatória. O valor padrão é `Yes`.
+ **PreSysprepRunCmd**: o local do comando para execução. Por padrão, o comando está localizado no seguinte diretório:: `C:\Program Files\Amazon\Ec2ConfigService\Scripts\BeforeSysprep.cmd`
1. O sistema executa o `BeforeSysprep.cmd`. Esse comando cria uma chave de registro da seguinte maneira:
```
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 1 /f
```
A chave de registro desabilita as conexões RDP até serem re-habilitadas. Desabilitar as conexões RDP é uma medida de segurança necessária, pois, na primeira sessão de inicialização após o Sysprep do Windows ser executado, há um breve período no qual o RDP permite conexões e a senha do Administrador fica em branco.
1. O serviço do EC2Config chama o Sysprep do Windows ao executar o seguinte comando:
```
sysprep.exe /unattend: "C:\Program Files\Amazon\Ec2ConfigService\sysprep2008.xml" /oobe /generalize /shutdown
```
### Generalizar a fase
+ A ferramenta remove informações específicas da imagem e as configurações, como nome de computador e SID. Se a instância pertencer a um domínio, ela será removida do domínio. O arquivo de resposta `sysprep2008.xml` inclui as seguintes configurações que afetam a fase:
+ **PersistAllDeviceInstalls**: essa configuração impede que a Configuração do Windows remova e reconfigure dispositivos, o que acelera o processo de preparação de imagem, pois as AMIs da Amazon exigem a execução de determinados drivers e a nova detecção desses drivers tomaria o tempo.
+ **DoNotCleanUpNonPresentDevices**: essa configuração retém informações de plug and play para dispositivos que não estão presentes no momento.
+ O Sysprep do Windows fecha o SO à medida que se prepara para criar a AMI. O sistema executa uma nova instância ou inicia a instância original.
### Fase especializada
O sistema gera requisitos específicos de SO, como um nome de computador e um SID. O sistema também executa as ações a seguir com base em configurações que você especifica no arquivo de resposta sysprep2008.xml.
+ **CopyProfile**: o Sysprep do Windows pode ser configurado para excluir todos os perfis de usuário, incluindo o perfil incorporado do Administrador. Essa configuração retém a conta de Administrador incorporada, de forma que todas as personalizações que você fizer nessa conta serão transferidas para a nova imagem. O valor padrão é Verdadeiro.
**CopyProfile** substitui o perfil padrão pelo perfil de administrador local existente. Todas as contas conectadas depois da execução de Sysprep do Windows receberão uma cópia desse perfil e do conteúdo dele no primeiro login.
Se você não tiver personalizações específicas do perfil do usuário que deseja transferir para a nova imagem, altere essa configuração para falso. O Sysprep do Windows removerá todos os perfis de usuário; isso economiza tempo e espaço em disco.
+ **TimeZone**: o fuso horário é definido como Coordinated Universal Time (UTC – Tempo universal coordenado), por padrão.
+ **Comando síncrono com pedido 1**: o sistema executa o comando a seguir, que habilita a conta do administrador e especifica o requisito de senha.
**net user Administrator /ACTIVE:YES /LOGONPASSWORDCHG:NO /EXPIRES:NEVER /PASSWORDREQ:YES**
+ **Comando síncrono com pedido 2**: o sistema vasculha a senha do administrador. Essa medida de segurança é criada para impedir que a instância fique acessível após o Sysprep do Windows ser concluído, caso você não tenha habilitado a configuração ec2setpassword.
C:\$1Program Files\$1Amazon\$1Ec2ConfigService\$1ScramblePassword.exe" -u Administrator
+ **Comando síncrono com pedido 3**: o sistema executa o seguinte comando:
C:\$1Program Files\$1Amazon\$1Ec2ConfigService\$1Scripts\$1SysprepSpecializePhase.cmd
Esse comando adiciona a seguinte chave de registro, que re-habilita a RDP:
reg add "HKEY\$1LOCAL\$1MACHINE\$1SYSTEM\$1CurrentControlSet\$1Control\$1Terminal Server" /v fDenyTSConnections /t REG\$1DWORD /d 0 /f
### Fase OOBE
1. Usando o arquivo de resposta do serviço EC2Config, o sistema especifica as seguintes configurações:
+ en-US
+ en-US
+ en-US
+ en-US
+ true
+ true
+ Other
+ 3
+ false
+ UTC
+ Amazon.com
+ Amazon
**nota**
Durante as fases de generalização e especialização, o serviço EC2Config monitora o status do SO. Se o EC2Config detectar que o sistema operacional está na fase Sysprep, ele publicará a seguinte mensagem no log do sistema:
EC2ConfigMonitorState: 0 O Windows está sendo configurado. SysprepState=IMAGE\$1STATE\$1UNDEPLOYABLE
1. Após a conclusão da fase OOBE, o sistema executa `SetupComplete.cmd` a partir do seguinte local: `C:\Windows\Setup\Scripts\SetupComplete.cmd`. Na AMIs públicas da Amazon antes de abril de 2015 este arquivo estava vazio e não executava nada na imagem. Em AMIs públicas posteriores a abril de 2015, o arquivo inclui o seguinte valor: **call "C:\$1Program Files\$1Amazon\$1Ec2ConfigService\$1Scripts\$1PostSysprep.cmd"**.
1. O sistema executa `PostSysprep.cmd`, que realiza as seguintes operações:
+ Define a senha do Administrador para não expirar. Se a senha expirou, os Administradores podem não conseguir fazer login.
+ Define o nome da máquina MSSQLServer (se instalada) para que o nome esteja em sincronia com a AMI.
## Após Sysprep
Após o Sysprep do Windows ser concluído, os serviços do EC2Config enviam a seguinte mensagem para a saída do console:
```
Windows sysprep configuration complete.
Message: Sysprep Start
Message: Sysprep End
```
O EC2Config então executa as ações a seguir:
1. Lê o conteúdo do arquivo config.xml e lista todos os plug-ins habilitados.
1. Executa todos os plug-ins "Antes que o Windows esteja pronto" ao mesmo tempo.
+ Ec2SetPassword
+ Ec2SetComputerName
+ Ec2InitializeDrives
+ Ec2EventLog
+ Ec2ConfigureRDP
+ Ec2OutputRDPCert
+ Ec2SetDriveLetter
+ Ec2WindowsActivate
+ Ec2DynamicBootVolumeSize
1. Após estar concluído, envia uma mensagem "O Windows está pronto" para os logs do sistema de instância.
1. Executa todos os plug-ins "Após o Windows estar pronto" ao mesmo tempo.
+ Amazon CloudWatch Logs
+ UserData
+ AWS Systems Manager (Systems Manager)
Para obter mais informações sobre plug-ins do Windows, consulte [Usar o serviço EC2Config para realizar tarefas durante a execução da instância herdada do sistema operacional Windows do EC2](ec2config-service.md).
## Executar o Sysprep do Windows com o serviço do EC2Config
Use o procedimento a seguir para criar uma AMI padronizada usando o Sysprep do Windows e o serviço do EC2Config.
1. No console do Amazon EC2, localize ou [crie](creating-an-ami-ebs.md) a AMI que deseja duplicar.
1. Execute e conecte-se à sua instância do Windows.
1. Personalize-a.
1. Especifique as definições de configuração no arquivo de resposta do serviço EC2Config:
`C:\Program Files\Amazon\Ec2ConfigService\sysprep2008.xml`
1. No menu **Iniciar** do Windows, escolha **Todos os Programas** e **Configurações do EC2ConfigService**.
1. Escolha a guia **Image (Imagem)** na caixa de diálogo **Ec2 Service Properties (Propriedades do serviço Ec2)**. Para obter mais informações sobre as opções e as configurações da caixa de diálogo Ec2 Service Properties (Propriedades do serviço Ec2), consulte [Propriedades do serviço Ec2](ec2config-service.md).
1. Selecione uma opção para a senha do Administrador e selecione **Shutdown with Sysprep (Desativação com Sysprep)** ou **Shutdown without Sysprep (Desativação sem Sysprep)**. O EC2Config edita os arquivos de configuração com base na opção de senha selecionada.
+ **Random (Aleatório)**: o EC2Config gera uma senha, criptografa-a com a chave do usuário e exibe a senha criptografada no console. Nós desabilitamos essa configuração depois da primeira execução, de forma que essa senha persistirá se a instância for reinicializada ou parada e inicializada.
+ **Especificar**: a senha é armazenada no arquivo de resposta do Sysprep do Windows de forma não criptografada (texto não criptografado). Quando o Sysprep do Windows é executado em seguida, ele define a senha do Administrador. Se você fechar agora, a senha será definida imediatamente. Quando o serviço é reiniciado novamente, a senha do Administrador é removida. É importante recordar essa senha, pois você não poderá recuperá-la depois.
+ **Manter existente**: a senha existente para a conta do Administrador não muda quando o Sysprep do Windows é executado ou o EC2Config é reiniciado. É importante recordar essa senha, pois você não poderá recuperá-la depois.
1. Escolha **OK**.
Quando você receber uma solicitação para confirmar que deseja executar o Sysprep do Windows e desativar a instância, clique em **Sim**. Você verá que o EC2Config executa o Sysprep do Windows. Em seguida, você é desconectado da instância e a instância é desligada. Se você verificar a página **Instances** (Instâncias) no console do Amazon EC2, o estado da instância mudará de `Running` para `Stopping` e, finalmente, para `Stopped`. Nesse momento, é seguro criar uma AMI com base nessa instância.
Você pode invocar manualmente a ferramenta Sysprep do Windows pela linha de comando usando o seguinte comando:
```
"%programfiles%\amazon\ec2configservice\"ec2config.exe -sysprep""
```
**nota**
As aspas duplas no comando não serão necessárias se o shell do seu CMD já estiver no diretório C:\$1Program Files\$1Amazon\$1EC2ConfigService\$1.
Contudo, é necessário ser muito cuidadoso para que as opções do arquivo XML especificadas na pasta `Ec2ConfigService\Settings` estejam corretas; caso contrário, pode não conseguir conectar-se à instância. Para obter mais informações sobre os arquivos de configurações, consulte [Arquivos de configurações do EC2Config](ec2config-service.md#UsingConfigXML_WinAMI). Para ver um exemplo de como configurar e executar o Sysprep do Windows pela linha de comando, consulte `Ec2ConfigService\Scripts\InstallUpdates.ps1`.
# Copiar uma AMI do Amazon EC2
Quando precisar de uma configuração consistente de instância do Amazon EC2 em várias regiões, será possível usar uma única imagem de máquina da Amazon (AMI) como modelo para inicializar todas as instâncias. No entanto, as AMIs são recursos específicos de uma região. Para inicializar uma instância em uma determinada Região da AWS, a AMI precisará estar localizada nessa região. Portanto, para usar a mesma AMI em várias regiões, você precisará copiá-la da região de origem para cada região de destino.
O método usado para copiar uma AMI dependerá de você estar copiando entre regiões *dentro da mesma [partição](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#partition)* ou *entre diferentes partições*:
+ **Cópia entre regiões**: copie AMIs entre regiões *na mesma partição*, por exemplo, entre regiões na partição comercial. Esse método de cópia está descrito neste tópico.
+ **Cópia entre partições:**: copie AMIs *de uma partição da para outra partição*, por exemplo, da partição comercial para a partição AWS GovCloud (US). Para obter informações sobre esse método de cópia, consulte [Armazenar e restaurar uma AMIAMIs permitidas](ami-store-restore.md).
+ **Cópia entre contas**: crie uma cópia de uma AMI que outra Conta da AWS tenha [compartilhado com a sua Conta da AWS](sharingamis-explicit.md). Esse método de cópia está descrito neste tópico.
O tempo necessário para concluir a operação de cópia da AMI entre regiões e entre contas é apresentado com base no melhor esforço. Se precisar controlar o tempo de conclusão, será possível especificar uma janela de conclusão que varia de 15 minutos a 48 horas, garantindo que sua AMI seja copiada dentro do prazo exigido. Cobranças adicionais são aplicáveis a operações de cópia de AMI baseadas em tempo. Para obter mais informações, consulte [Cópias baseadas em tempo](https://docs.aws.amazon.com/ebs/latest/userguide/time-based-copies.html), no *Guia do usuário do Amazon EBS*.
**Topics**
+ [Considerações](#copy-ami-considerations)
+ [Custos](#copy-ami-costs)
+ [Conceder permissões para copiar AMIs do Amazon EC2](copy-ami-permissions.md)
+ [Copiar um AMI](#ami-copy-steps)
+ [Parar uma operação de cópia de AMI pendente](#ami-copy-stop)
+ [Como funciona a cópia de uma AMI do Amazon EC2](how-ami-copy-works.md)
## Considerações
+ **Permissão para copiar AMIs**: é possível usar políticas do IAM para conceder ou negar aos usuários permissão para copiar AMIs. A partir de 28 de outubro de 2024, você pode especificar permissões no nível do recurso para a ação `CopyImage` na AMI de origem. As permissões no nível do recurso da nova AMI estão disponíveis como antes.
+ **Permissões de execução e permissões de bucket do Amazon S3**: a AWS não copia permissões de execução nem permissões de bucket do Amazon S3 da AMI de origem para a nova AMI. Após a conclusão da operação de cópia, você pode aplicar permissões de inicialização e permissões de bucket do Amazon S3 à nova AMI.
+ **Tags**: é possível copiar somente as tags de AMI definidas pelo usuário que você anexou à AMI de origem. Tags do sistema (prefixadas com `aws:`) e tags definidas pelo usuário anexadas por outras Contas da AWS não serão copiadas. Ao copiar uma AMI, você pode anexar novas tags à nova AMI e seus snapshots de suporte.
+ **Cotas para cópias de AMI baseadas em tempo**: depois que você atingir sua *cota cumulativa de throughput para cópias de snapshot*, as solicitações subsequentes de cópias de AMI baseadas no tempo vão falhar. Para obter mais informações, consulte [Cotas para cópias baseadas em tempo](https://docs.aws.amazon.com/ebs/latest/userguide/time-based-copies.html#time-based-copies-quota), no *Guia do Usuário do Amazon EBS*.
+ **Cópias de origem-destino compatíveis**: a localização da AMI de origem determina se você pode copiá-la e os destinos permitidos para a nova AMI:
+ Se a AMI de origem estiver em uma região, será possível copiá-la dentro dessa região para outra região, para um Outpost associado a essa região ou para uma zona local na região.
+ Se a AMI de origem estiver em uma zona local, será possível copiá-la dentro dessa zona local para a região principal dessa zona local ou para outras zonas locais específicas com a mesma região principal.
+ Se a AMI de origem estiver em, um Outpost, você não poderá copiá-la.
+ **Parâmetros da CLI para origem e destino**: ao usar a CLI, os seguintes parâmetros são compatíveis para especificar o local de origem da AMI a ser copiada e o destino da nova AMI. Observe que a operação de cópia deve ser iniciada na região de destino; se você omitir o parâmetro `--region`, o destino assumirá a região padrão configurada em suas configurações da AWS CLI.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/CopyingAMIs.html)
## Custos
Não há cobrança pela cópia de uma AMI quando não houver nenhum tempo de conclusão especificado. No entanto, há cobranças adicionais para operações de cópia de AMI baseadas em tempo. Para obter mais informações, consulte [Cópias baseadas em tempo](https://docs.aws.amazon.com/ebs/latest/userguide/time-based-copies.html#time-based-copies-pricing), no *Guia do usuário do Amazon EBS*.
Aplicam-se as taxas padrão para transferência de dados e armazenamento. Se copiar uma AMI baseada em EBS, você será cobrado pelo armazenamento de snapshots adicionais do EBS.
# Conceder permissões para copiar AMIs do Amazon EC2
Para copiar uma AMI baseada no EBS ou no Amazon S3, são necessárias as seguintes permissões do IAM:
+ `ec2:CopyImage`: para copiar a AMI. Para AMIs baseadas no EBS, ele também concede permissão para copiar os snapshots de suporte da AMI.
+ `ec2:CreateTags`: para marcar a AMI de destino. Para AMIs baseadas no EBS, ele também concede permissão para marcar os snapshots de apoio da AMI de destino.
Se você estiver copiando uma AMI baseada em uma instância armazenada, as seguintes permissões *adicionais* do IAM serão necessárias:
+ `s3:CreateBucket`: para criar o bucket do S3 na região de destino da nova AMI
+ `s3:PutBucketOwnershipControls`: para habilitar ACLs para o bucket do S3 recém-criado para que os objetos possam ser gravados com a `aws-exec-read` [ACL pré-configurada](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl)
+ `s3:GetBucketAcl`: para ler as ACLs para o bucket de origem
+ `s3:ListAllMyBuckets`: para encontrar um bucket do S3 existente para AMIs na região de destino
+ `s3:GetObject`: para ler os objetos no bucket de origem
+ `s3:PutObject`: para escrever os objetos no bucket de destino
+ `s3:PutObjectAcl`: para escrever as permissões para os novos objetos no bucket de destino
**nota**
A partir de 28 de outubro de 2024, você pode especificar permissões no nível do recurso para a ação `CopyImage` na AMI de origem. As permissões no nível do recurso da AMI de destino estão disponíveis como antes. Para obter mais informações, consulte **CopyImage** na tabela em [Ações definidas pelo Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html#amazonec2-actions-as-permissions) na *Referência de autorização do serviço*.
## Exemplo de política do IAM para copiar uma AMI baseada em EBS e marcar a AMI e os snapshots de destino
O exemplo de política a seguir concede a você permissão para copiar qualquer AMI baseada no EBS e marcar a AMI de destino e seus snapshots de apoio.
**nota**
A partir de 28 de outubro de 2024, você pode especificar snapshots no elemento `Resource`. Para obter mais informações, consulte **CopyImage** na tabela em [Ações definidas pelo Amazon EC2](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonec2.html#amazonec2-actions-as-permissions) na *Referência de autorização do serviço*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "PermissionToCopyAllImages",
"Effect": "Allow",
"Action": [
"ec2:CopyImage",
"ec2:CreateTags"
],
"Resource": [
"arn:aws:ec2:*::image/*",
"arn:aws:ec2:*::snapshot/*"
]
}]
}
```
------
## Exemplo de política do IAM para copiar uma AMI baseada no EBS, mas negar a marcação de novos snapshots.
A permissão `ec2:CopySnapshot` é concedida automaticamente quando você recebe a permissão `ec2:CopyImage`. A permissão para marcar os novos snapshots de apoio pode ser negada explicitamente, anulando o efeito `Allow` da ação `ec2:CreateTags`.
O exemplo de política a seguir concede a você permissão para copiar qualquer AMI baseada no EBS, mas proíbe a marcação de novos snapshots de apoio da AMI de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": [
"ec2:CopyImage",
"ec2:CreateTags"
],
"Resource": [
"arn:aws:ec2:*::image/*",
"arn:aws:ec2:*::snapshot/*"
]
},
{
"Effect": "Deny",
"Action": "ec2:CreateTags",
"Resource": "arn:aws:ec2:::snapshot/*"
}
]
}
```
------
## Exemplo de política do IAM para copiar uma AMI baseada no Amazon S3 e adicionar marcação à AMI de destino
A política de exemplo apresentada a seguir concede permissão para copiar qualquer AMI baseada no Amazon S3 no bucket de origem especificado para a região indicada e adicionar etiquetas à AMI de destino.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "PermissionToCopyAllImages",
"Effect": "Allow",
"Action": [
"ec2:CopyImage",
"ec2:CreateTags"
],
"Resource": "arn:aws:ec2:*::image/*"
},
{
"Effect": "Allow",
"Action": "s3:ListAllMyBuckets",
"Resource": [
"arn:aws:s3:::*"
]
},
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": [
"arn:aws:s3:::amzn-s3-demo-source-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:CreateBucket",
"s3:GetBucketAcl",
"s3:PutObjectAcl",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::amis-for-111122223333-in-us-east-2-hash"
]
}
]
}
```
------
Para localizar o nome do recurso da Amazon (ARN) do bucket de origem da AMI, abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2](https://console.aws.amazon.com/ec2/). No painel de navegação, escolha **AMIs** e localize o nome do bucket na coluna **Source (Origem)**.
**nota**
Você precisa da permissão `s3:CreateBucket` apenas na primeira vez em que copiar uma AMI baseada no Amazon S3 para uma região específica. Depois disso, o bucket do Amazon S3 que foi criado na região será usado para armazenar todas as AMIs futuras que você copiar para essa região.
## Copiar um AMI
É possível copiar uma AMI de sua propriedade ou uma AMI compartilhada com você de outra conta. Para obter as combinações de origem e destino compatíveis, consulte [Considerações](#copy-ami-considerations).
------
#### [ Console ]
**Copiar uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Pela barra de navegação do console, selecione a região que contém a AMI.
1. No painel de navegação, selecione **AMIs** para exibir a lista de AMIs disponíveis para você na região.
1. Caso não veja a AMI que deseja copiar, selecione um filtro diferente. É possível filtrar por AMIs **Pertencentes a mim**, **Imagens privadas**, **Imagens públicas** e **Imagens desabilitadas**.
1. Selecione a AMI para copiar e escolha **Ações**, **Copiar AMI**.
1. Na página **Copy imagem de máquina da Amazon (AMI)**, especifique as seguintes informações:
1. **AMI copy name** (Nome da cópia da AMI): o nome da nova AMI. É possível incluir informações do sistema operacional no nome, pois o Amazon EC2 não fornece essas informações ao exibir detalhes sobre a AMI.
1. **AMI copy description**: (Descrição da cópia da AMI): por padrão, a descrição inclui informações sobre a AMI de origem, de forma que você possa distinguir uma cópia da original. É possível alterar essa descrição conforme necessário.
1. **Destination region** (Região de destino): a região para a qual a AMI deve ser copiada. Para obter mais informações, consulte [Cópia entre regiões](how-ami-copy-works.md#copy-amis-across-regions) e [Cópia entre contas](how-ami-copy-works.md#copy-ami-across-accounts).
1. **Copiar tags**: marque essa caixa de seleção para incluir as tags de AMI definidas pelo usuário ao copiar a AMI. Tags do sistema (prefixadas com `aws:`) e tags definidas pelo usuário anexadas por outras Contas da AWS não serão copiadas.
1. **Cópia com base emtempo**: você pode especificar se a operação de cópia será concluída dentro de um prazo específico ou com base no melhor esforço, da seguinte forma:
+ Para concluir a cópia dentro de um prazo específico:
+ Selecione **Habilitar cópia com base em tempo**.
+ Em **Duração da conclusão**, insira o número de minutos (em incrementos de 15 minutos) permitidos para a operação de cópia. A duração da conclusão é aplicável a todos os snapshots associados à AMI.
Para obter mais informações, consulte [Cópias baseadas em tempo](https://docs.aws.amazon.com/ebs/latest/userguide/time-based-copies.html), no *Guia do usuário do Amazon EBS*.
+ Para concluir a cópia com base no melhor esforço:
+ Deixe a opção **Habilitar cópia com base no tempo** desmarcada.
1. (Somente AMIs baseadas no EBS) **Criptografar snapshots do EBS de uma cópia da AMI**: marque essa caixa de seleção para criptografar os snapshots de destino ou para recriptografá-los usando uma chave diferente. Se a opção de criptografar por padrão estiver habilitada, a caixa de seleção **Criptografar snapshots do EBS da cópia da AMI** estará selecionada e não poderá ser desmarcada. Para obter mais informações, consulte [Criptografar e copiar](how-ami-copy-works.md#ami-copy-encryption).
1. (Somente AMIs baseadas no EBS) **Chave do KMS**: a chave do KMS usada para criptografar os snapshots de destino.
1. **Tags**: é possível marcar a nova AMI e os novos snapshots com as mesmas tags ou pode marcá-los com tags diferentes.
+ Para marcar a nova AMI e novos os snapshots com as *mesmas* tags, escolha **Marcar imagem e snapshots juntos**. As mesmas tags são aplicadas à nova AMI e a cada snapshot criado.
+ Para marcar a nova AMI e os snapshots com tags *diferentes*, escolha **Marcar imagem e snapshots separadamente**. Diferentes tags são aplicadas à nova AMI e aos snapshots criados. Observe, no entanto, que todos os novos snapshots criados recebem as mesmas tags; não é possível marcar cada snapshot com uma tag diferente.
(Opcional) Para adicionar uma tag, escolha **Add tag** (Adicionar tag) e digite a chave e o valor da tag. Repita esse procedimento para cada tag.
1. Quando estiver com tudo pronto para copiar a AMI, escolha **Copiar AMI**.
O status inicial da nova AMI é `Pending`. A operação de cópia da AMI estará concluída quando o status for `Available`.
------
#### [ AWS CLI ]
**Para copiar uma AMI de uma região para outra**
Use o comando [ copy-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/copy-image.html) (Copiar imagem). Especifique as regiões de origem e de destino. Especifique a região de origem usando o parâmetro `--source-region`. É possível especificar a região de destino usando o parâmetro `--region` (ou omitir esse parâmetro para assumir a região padrão configurada em suas configurações da AWS CLI).
```
aws ec2 copy-image \
--source-image-id ami-0abcdef1234567890 \
--source-region us-west-2 \
--name my-ami \
--region us-east-1
```
Quando você criptografar um snapshot de destino durante a cópia de AMI, precisará especificar os parâmetros adicionais: `--encrypted` e `--kms-key-id`.
**Para copiar uma AMI de uma região para uma zona local**
Use o comando [ copy-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/copy-image.html) (Copiar imagem). Você deve especificar a origem e o destino. Especifique a região de origem usando o parâmetro `--source-region`. Você especifica a zona local de destino usando o parâmetro `--destination-availability-zone` (você pode usar `--destination-availability-zone-id` em vez disso). Observe que você só pode copiar uma AMI de uma região para uma zona local dentro dessa mesma região.
```
aws ec2 copy-image \
--source-image-id ami-0abcdef1234567890 \
--source-region cn-north-1 \
--destination-availability-zone cn-north-1-pkx-1a \
--name my-ami \
--region cn-north-1
```
**Para copiar uma AMI de uma zona local para uma região**
Use o comando [ copy-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/copy-image.html) (Copiar imagem). Você deve especificar a origem e o destino. Especifique a região de origem usando o parâmetro `--source-region`. Você especifica a região de destino usando o parâmetro `--region` (ou omite esse parâmetro para assumir a região padrão configurada em suas configurações da AWS CLI). A zona local de origem é assumida da localização da ID da AMI de origem especificada. Observe que você só pode copiar uma AMI de uma zona local para sua região principal.
```
aws ec2 copy-image \
--source-image-id ami-0abcdef1234567890 \
--source-region cn-north-1 \
--name my-ami \
--region cn-north-1
```
**Para copiar uma AMI de uma zona local para outra**
Use o comando [ copy-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/copy-image.html) (Copiar imagem). Você deve especificar a origem e o destino. Você especifica a região de origem da zona local usando o parâmetro `--source-region`. Você especifica a zona local de destino usando o parâmetro `--destination-availability-zone` (você pode usar `--destination-availability-zone-id` em vez disso). A zona local de origem é assumida da localização da ID da AMI de origem especificada. Você especifica a região principal da zona local de destino usando o parâmetro `--region` (ou omite esse parâmetro para assumir a região padrão configurada em suas configurações da AWS CLI).
```
aws ec2 copy-image \
--source-image-id ami-0abcdef1234567890 \
--source-region cn-north-1 \
--destination-availability-zone cn-north-1-pkx-1a \
--name my-ami \
--region cn-north-1
```
------
#### [ PowerShell ]
**Para copiar uma AMI de uma região para outra**
Use o cmdlet [Copy-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Copy-EC2Image.html). Especifique as regiões de origem e de destino. Especifique a região de origem usando o parâmetro `-SourceRegion`. É possível especificar a região de destino usando o parâmetro `-Region` ou o cmdlet [Set-AWSDefaultRegion](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-installing-specifying-region.html).
```
Copy-EC2Image `
-SourceImageId ami-0abcdef1234567890 `
-SourceRegion us-west-2 `
-Name my-ami `
-Region us-east-1
```
Quando você criptografar um snapshot de destino durante a cópia de AMI, precisará especificar os parâmetros adicionais: `-Encrypted` e `-KmsKeyId`.
**Para copiar uma AMI de uma região para uma zona local**
Use o cmdlet [Copy-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Copy-EC2Image.html). Você deve especificar a origem e o destino. Especifique a região de origem usando o parâmetro `-SourceRegion`. Você especifica a zona local de destino usando o parâmetro `-DestinationAvailabilityZone` (você pode usar `-DestinationAvailabilityZoneId` em vez disso). Observe que você só pode copiar uma AMI de uma região para uma zona local dentro dessa mesma região.
```
Copy-EC2Image `
-SourceImageId ami-0abcdef1234567890 `
-SourceRegion cn-north-1 `
-DestinationAvailabilityZone cn-north-1-pkx-1a `
-Name my-ami `
-Region cn-north-1
```
**Para copiar uma AMI de uma zona local para uma região**
Use o cmdlet [Copy-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Copy-EC2Image.html). Você deve especificar a origem e o destino. Especifique a região de origem usando o parâmetro `-SourceRegion`. É possível especificar a região de destino usando o parâmetro `-Region` ou o cmdlet [Set-AWSDefaultRegion](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-installing-specifying-region.html). A zona local de origem é assumida da localização da ID da AMI de origem especificada. Observe que você só pode copiar uma AMI de uma zona local para sua região principal.
```
Copy-EC2Image `
-SourceImageId ami-0abcdef1234567890 `
-SourceRegion cn-north-1 `
-Name my-ami `
-Region cn-north-1
```
**Para copiar uma AMI de uma zona local para outra**
Use o cmdlet [Copy-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Copy-EC2Image.html). Você deve especificar a origem e o destino. Você especifica a região de origem da zona local usando o parâmetro `-SourceRegion`. Você especifica a zona local de destino usando o parâmetro `-DestinationAvailabilityZone` (você pode usar `-DestinationAvailabilityZoneId` em vez disso). A zona local de origem é assumida da localização da ID da AMI de origem especificada. É possível especificar a região principal da zona local de destino usando o parâmetro `-Region` ou o cmdlet [Set-AWSDefaultRegion](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-installing-specifying-region.html).
```
Copy-EC2Image `
-SourceImageId ami-0abcdef1234567890 `
-SourceRegion cn-north-1 `
-DestinationAvailabilityZone cn-north-1-pkx-1a `
-Name my-ami `
-Region cn-north-1
```
------
## Parar uma operação de cópia de AMI pendente
É possível interromper uma cópia pendente de uma AMI usando os procedimentos a seguir.
------
#### [ Console ]
**Para interromper uma operação de cópia de AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na barra de navegação, selecione a região de destino com o seletor de região.
1. No painel de navegação, selecione **AMIs**.
1. Selecione a AMI cuja cópia será interrompida e escolha **Ações** e **Cancelar registro da AMI**.
1. Quando a confirmação for solicitada, escolha **Deregister AMI** (Cancelar registro da AMI).
------
#### [ AWS CLI ]
**Para interromper uma operação de cópia de AMI**
Use o comando [deregister-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/deregister-image.html).
```
aws ec2 deregister-image --image-id ami-0abcdef1234567890
```
------
#### [ PowerShell ]
**Para interromper uma operação de cópia de AMI usando**
Use o cmdlet [Unregister-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Unregister-EC2Image.html).
```
Unregister-EC2Image -ImageId ami-0abcdef1234567890
```
------
# Como funciona a cópia de uma AMI do Amazon EC2
Copiar uma AMI de origem resulta em uma nova AMI idêntica, mas separada, que também é chamada de AMI de *destino*. A AMI de destino tem o próprio ID de AMI exclusivo. É possível alterar ou cancelar o registro da AMI de origem sem afetar a AMI de destino. O inverso também é verdadeiro.
No caso de uma AMI baseada no EBS, cada um de seus snapshots de suporte é copiado para um snapshot de destino idêntico, mas separado. Se você copiar uma AMI para uma nova Região, os snapshots serão cópias completas (não incrementais). Se você criptografar snapshots de suporte não criptografados ou criptografá-los para uma nova chave KMS, os snapshots serão cópias completas (não incrementais). Operações de cópia subsequentes de uma AMI resultam em cópias incrementais dos snapshots de suporte.
**Topics**
+ [Cópia entre regiões](#copy-amis-across-regions)
+ [Cópia entre contas](#copy-ami-across-accounts)
+ [Operações de cópia de AMI baseadas no tempo](#ami-time-based)
+ [Criptografar e copiar](#ami-copy-encryption)
## Cópia entre regiões
Copiar uma AMI entre regiões geograficamente diversas traz os seguintes benefícios:
+ Implantação global consistente: copiar uma AMI de uma região para outra permite que você execute instâncias consistentes com base na mesma AMI em diferentes regiões.
+ Escalabilidade: É possível mais facilmente projetar e construir aplicações globais que atendam às necessidades dos seus usuários, onde quer que estejam.
+ Performance: é possível aumentar a performance ao distribuir sua aplicação, além de localizar os componentes essenciais do sua aplicação em maior proximidade de seus usuários. Também é possível aproveitar recursos específicos da região, como tipos de instância ou outros serviços da AWS.
+ Alta disponibilidade: é possível projetar e implantar aplicações nas regiões da AWS, de forma a aumentar a disponibilidade.
O diagrama a seguir mostra as relações entre uma AMI de origem e duas AMIs copiadas em regiões diferentes, assim como as instâncias do EC2 executadas por cada uma. Ao executar uma instância a partir de uma AMI, ela residirá na mesma região em que a AMI reside. Se você fizer alterações à AMI de origem e quiser que essas alterações sejam refletidas nas AMIs das regiões de destino, deve recopiar a AMI de origem nas regiões de destino.
![\[AMIs copiadas em diferentes regiões\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ami_copy.png)
Ao copiar uma AMI baseada no Amazon S3 para uma região pela primeira vez, criamos um bucket do Amazon S3 para as AMIs copiadas para essa região. Todas as AMIs baseadas no Amazon S3 que você copia para essa região são armazenadas neste bucket. Os nomes do bucket têm o seguinte formato: amis-for-*account*-in-*region*-*hash*. Por exemplo: `amis-for-123456789012-in-us-east-2-yhjmxvp6`.
**Pré-requisito**
Antes de copiar uma AMI, é preciso garantir que o conteúdo da AMI de origem seja atualizado para oferecer suporte à execução em uma região diferente. Por exemplo, atualize todas as string de conexão com o banco de dados ou dados de configuração de aplicação para apontarem para os recursos apropriados. Caso contrário, as instâncias executadas pela nova AMI na região de destino ainda poderão usar os recursos da região de origem, o que pode afetar a performance e o custo.
**Limitações**
+ Regiões de destino estão limitadas a 300 operações de cópia de AMI simultâneas. Isso também é aplicável a operações de cópia de AMI baseadas no tempo.
+ Não é possível copiar uma AMI paravirtual (PV) em uma região que não oferece suporte a AMIs PV. Para obter mais informações, consulte [Tipos de virtualização](ComponentsAMIs.md#virtualization_types).
## Cópia entre contas
Se uma AMI de outra Conta da AWS for [compartilhada com a sua Conta da AWS](sharingamis-explicit.md), será possível copiar a AMI compartilhada. Isso é conhecido como cópia entre contas. A AMI que é compartilhada com você é a AMI de origem. Quando copia a AMI de origem, você cria uma nova AMI. A nova AMI geralmente é chamada de AMI de destino.
**Custos da AMI**
+ Para a AMI compartilhada, a cobrança pelo armazenamento na região é lançada na conta da AMI compartilhada.
+ Se copiar uma AMI compartilhada com sua conta, você será o proprietário da AMI de destino na sua conta.
+ As taxas de transferência padrão do Amazon EBS ou do Amazon S3 são cobradas do proprietário da AMI de origem.
+ O armazenamento da AMI de destino na região de destino é cobrado de você.
**Permissões de recursos**
Para copiar uma AMI compartilhada com você de outra conta, o proprietário da AMI de origem precisará conceder permissão de leitura para o armazenamento que suporta a AMI e não apenas para a própria AMI. O armazenamento corresponde ao snapshot do EBS associado, no caso de uma AMI baseada no Amazon EBS, ou a um bucket do S3 associado, no caso de uma AMI baseada no Amazon S3. Se a AMI compartilhada tiver snapshots criptografados, o proprietário deve compartilhar a chave ou as chaves com você. Para obter mais informações sobre a concessão de permissões de recursos para snapshots do EBS, consulte [Compartilhar um snapshot do Amazon EBS com outras Contas da AWS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modifying-snapshot-permissions.html) no *Guia do usuário do Amazon EBS*. Para buckets do S3, consulte [Gerenciamento de identidade e acesso no Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security-iam.html) no *Guia do usuário do Amazon S3*.
**nota**
As tags anexadas à AMI de origem não são copiadas entre contas para a AMI de destino.
## Operações de cópia de AMI baseadas no tempo
Quando você inicia uma operação de cópia de AMI baseada no tempo para uma AMI baseada no EBS com um único snapshot associado, ela se comporta da mesma maneira que uma **operação individual de cópia de snapshot baseada no tempo**, e as mesmas limitações de throughput são aplicáveis.
Quando você inicia uma operação de cópia de AMI baseada no tempo para uma AMI baseada no EBS com vários snapshots associados, ela se comporta da mesma maneira que **operações simultâneas de cópia de snapshot baseadas no tempo**, e as mesmas limitações de throughput são aplicáveis. Cada snapshot associado resulta em uma solicitação de cópia de snapshot separada, cada qual contribuindo para sua cota cumulativa de throughput de cópias de snapshots. A duração da conclusão que você especifica é aplicável a cada snapshot associado.
Para obter mais informações, consulte [Cópias baseadas em tempo](https://docs.aws.amazon.com/ebs/latest/userguide/time-based-copies.html), no *Guia do usuário do Amazon EBS*.
## Criptografar e copiar
A tabela a seguir mostra o suporte a criptografia para vários cenários de cópia de AMI. Apesar de ser possível copiar um snapshot não criptografado para render um snapshot criptografado, você não pode copiar um snapshot criptografado para render um não criptografado.
| Cenário | Descrição | Compatível |
| --- | --- | --- |
| 1 | Não criptografado para não criptografado | Sim |
| 2 | Criptografado para criptografado | Sim |
| 3 | Não criptografado para criptografado | Sim |
| 4 | Criptografado para não criptografado | Não |
**nota**
A criptografia durante a ação `CopyImage` se aplica somente a AMIs baseadas no Amazon EBS. Por não usar snapshots, uma AMI baseada no Amazon S3 não pode ter o status de criptografia alterado por meio da cópia.
Ao copiar uma AMI sem especificar parâmetros de criptografia, o snapshot de apoio é copiado com seu status de criptografia original por padrão. Portanto, se a AMI de origem for apoiada por um snapshot não criptografado, o snapshot de destino resultante também não será criptografado. Da mesma forma, se o snapshot da AMI de origem for criptografado, o snapshot de destino resultante também será criptografado pela mesma chave do AWS KMS. Em AMIs apoiadas por vários snapshots, cada snapshot de destino preserva o estado de criptografia do snapshot de origem correspondente.
Para alterar o estado de criptografia dos snapshots de destino de apoio durante uma cópia da AMI, você pode especificar parâmetros de criptografia. O exemplo a seguir mostra um caso não padrão, em que os parâmetros de criptografia são especificados com a ação `CopyImage` para alterar o estado de criptografia da AMI de destino.
**Copiar uma AMI de origem não criptografada para uma AMI de destino criptografada**
Nesse cenário, uma AMI baseada em um snapshot raiz não criptografado é copiada para uma AMI com um snapshot raiz criptografado. A ação `CopyImage` é invocada com dois parâmetros de criptografia, incluindo uma chave gerenciada pelo cliente. Como resultado, o status de criptografia do snapshot raiz muda, de modo que a AMI de destino tenha suporte de um snapshot raiz contendo os mesmos dados que o snapshot de origem, mas criptografado usando a chave especificada. Você incorre em custos de armazenamento para os snapshots em ambas as AMIs, bem como cobranças para todas as instâncias iniciadas a partir de uma AMI.
**nota**
Habilitar a criptografia por padrão tem o mesmo efeito que configurar o parâmetro `Encrypted` como `true` para todos os snapshots na AMI.
![\[Copiar AMI e criptografar snapshot em tempo real\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ami-to-ami-convert.png)
Configurar o parâmetro `Encrypted` criptografa o snapshot único dessa instância. Se você não especificar o parâmetro `KmsKeyId`, a chave gerenciada pelo cliente padrão será usada para criptografar a cópia do snapshot.
Para obter mais informações sobre como copiar AMIs com snapshots criptografados, consulte [Usar criptografia com AMIs com EBS](AMIEncryption.md).
# Armazenar e restaurar uma AMI usando o S3
É possível armazenar uma imagem de máquina da Amazon (AMI) em um bucket do Amazon S3, copiar a AMI para outro bucket do S3 e restaurá-la a partir do bucket do S3. Ao armazenar e restaurar uma AMI usando buckets do S3, é possível copiar AMIs de uma partição da AWS para outra, por exemplo, da principal partição comercial para a partição AWS GovCloud (US). Também é possível fazer cópias de arquivamento de AMIs armazenando-as em um bucket do S3.
As APIs compatíveis para armazenar e restaurar uma AMI usando o S3 são `CreateStoreImageTask``DescribeStoreImageTasks` e `CreateRestoreImageTask`.
`CopyImage` é a API recomendada para copiar AMIs *dentro* de uma partição da AWS. No entanto, `CopyImage` não pode copiar uma AMI para *outra* partição.
Para obter mais informações sobre as partições da AWS, consulte *partição* na página [Nomes do recurso da Amazon (ARN)](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference-arns.html) no *Guia do usuário do IAM*.
**Atenção**
Certifique-se de cumprir todas as leis e requisitos de negócios aplicáveis ao mover dados entre partições da AWS ou regiões da AWS, incluindo, entre outros, quaisquer regulamentos governamentais aplicáveis e requisitos de residência de dados.
**Topics**
+ [Casos de uso](#use-cases)
+ [Limitações](#ami-store-restore-limitations)
+ [Custos](#store-restore-costs)
+ [Como o armazenamento e a restauração de uma AMI funciona](store-restore-how-it-works.md)
+ [Criar uma tarefa de armazenamento de imagem](work-with-ami-store-restore.md)
## Casos de uso
**Topics**
+ [Copiar uma AMI entre partições da AWS](#copy-to-partition)
+ [Fazer cópias de arquivamento de AMIs](#archival-copies)
### Copiar uma AMI entre partições da AWS
Ao armazenar e restaurar uma AMI usando buckets do S3, é possível copiar uma AMI de uma partição da AWS para outra ou de uma região da AWS para outra. No exemplo a seguir, você copia uma AMI da partição comercial principal para a partição AWS GovCloud (US), especificamente da região `us-east-2` para a região `us-gov-east-1`.
Para copiar uma AMI de uma partição para outra, siga estas etapas:
+ Armazene a AMI em um bucket do S3 na região atual usando `CreateStoreImageTask`. Neste exemplo, o bucket do S3 está localizado em `us-east-2`.
+ Monitore o andamento da tarefa de armazenamento usando `DescribeStoreImageTasks`. O objeto fica visível no bucket do S3 quando a tarefa é concluída.
+ Copie o objeto da AMI armazenado para um bucket do S3 na partição de destino usando um procedimento de sua escolha. Neste exemplo, o bucket do S3 está localizado em `us-gov-east-1`.
**nota**
Como você precisa de credenciais diferentes da AWS para cada partição, você não pode copiar um objeto S3 diretamente de uma partição para outra. O processo para copiar um objeto S3 entre partições está fora do escopo desta documentação. Fornecemos os processos de cópia a seguir como exemplos, mas use o processo de cópia que atenda aos seus requisitos de segurança.
Para copiar uma AMI entre partições, o processo de cópia pode ser tão simples quanto o seguinte: [baixe o objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/download-objects.html) do bucket de origem para um host intermediário (por exemplo, uma instância do EC2 ou um laptop) e [carregue o objeto](https://docs.aws.amazon.com/AmazonS3/latest/userguide/upload-objects.html) do host intermediário no bucket de destino. Para cada etapa do processo, use as credenciais da AWS para a partição.
Para um uso mais sustentável, considere desenvolver uma aplicação que gerencia as cópias, potencialmente usando [downloads e uploads de várias partes](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html)do S3.
+ Restaure a AMI do bucket do S3 na partição de destino usando `CreateRestoreImageTask`. Neste exemplo, o bucket do S3 está localizado em `us-gov-east-1`.
+ Monitore o andamento da tarefa de restauração descrevendo a AMI para verificar quando seu estado se torna disponível. Também é possível monitorar as porcentagens de progresso dos snapshots que compõem a AMI restaurada descrevendo os instantâneos.
### Fazer cópias de arquivamento de AMIs
É possível fazer cópias de arquivamento de AMIs armazenando-as em um bucket do S3. A AMI é embalada em um único objeto no S3 e todos os metadados da AMI (excluindo informações de compartilhamento) são preservados como parte da AMI armazenada. Os dados da AMI são compactados como parte do processo de armazenamento. AMIs que contêm dados que podem ser facilmente compactados resultarão em objetos menores no S3. Para reduzir custos, é possível usar camadas de armazenamento S3 mais econômicas. Para obter mais informações, consulte [Classes de armazenamento do Amazon S3](https://aws.amazon.com/s3/storage-classes/) e [definição de preço do Amazon S3](https://aws.amazon.com/s3/pricing/)
## Limitações
+ Para armazenar uma AMI, sua Conta da AWS deve possuir a AMI e seus snapshots, ou a AMI e seus snapshots devem ser [compartilhados diretamente com sua conta](sharingamis-explicit.md). Você não pode armazenar uma AMI se ela for [compartilhada publicamente](sharingamis-intro.md) apenas.
+ Somente AMIs baseadas no EBS podem ser armazenadas usando essas APIs.
+ Não há suporte a AMIs paravirtuais (PV).
+ O tamanho de uma AMI (antes da compactação) que pode ser armazenada é limitado a 5.000 GB.
+ Cota em solicitações de imagem de armazenamento: 1.200 GB de trabalho de armazenamento (dados de snapshots) em andamento.
+ Cota em solicitações de imagem de restauração: 600 GB de trabalho de restauração (dados de snapshots) em andamento.
+ Durante a tarefa de armazenamento, os snapshots não devem ser excluídos e a entidade principal do IAM que faz o armazenamento deve ter acesso aos snapshots, caso contrário o processo de armazenamento apresentará falha.
+ Não é possível criar várias cópias de uma AMI no mesmo bucket do S3.
+ Uma AMI armazenada em um bucket do S3 não pode ser restaurada com seu ID de AMI original. É possível mitigar isso usando [Alias de AMI](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-ec2-aliases.html).
+ Atualmente, as APIs de armazenamento e restauração só são compatíveis se for utilizada a AWS Command Line Interface, os AWS SDKs e a API do Amazon EC2. Não é possível armazenar e restaurar uma AMI usando o console do Amazon EC2.
## Custos
Quando você armazena e restaura AMIs usando o S3, é cobrado pelos serviços usados pelas APIs de armazenamento e restauração e pela transferência de dados. As APIs usam o S3 e a API direta do EBS (usadas internamente por essas APIs para acessar os dados do snapshot). Para obter mais informações, consulte [Definição de preço do Amazon S3](https://aws.amazon.com/s3/pricing/) e [Definição de preço do Amazon EBS](https://aws.amazon.com/ebs/pricing/).
# Como o armazenamento e a restauração de uma AMI funciona
Para armazenar e restaurar uma AMI usando o S3, use as seguintes APIs:
+ `CreateStoreImageTask` – Armazena a AMI em um bucket do S3
+ `DescribeStoreImageTasks` – Fornece o andamento da tarefa de armazenamento da AMI
+ `CreateRestoreImageTask` – Restaura a AMI de um bucket do S3
**Topics**
+ [CreateStoreImageTask](#CreateStoreImageTask)
+ [DescriboesToreImageTasks](#DescribeStoreImageTasks)
+ [CreateRestoreImageTask](#CreateRestoreImageTask)
+ [Caminhos do arquivo](#file-paths-in-s3)
## CreateStoreImageTask
A API `CreateStoreImageTask` armazena uma AMI como um único objeto em um bucket do S3.
A API cria uma tarefa que lê todos os dados da AMI e seus snapshots e, a seguir, usa um [multipart upload do S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/mpuoverview.html) para armazenar os dados em um objeto do S3. A API leva todos os componentes da AMI, incluindo a maioria dos metadados de AMI não específicos da região e todos os snapshots do EBS contidos na AMI, e os empacota em um único objeto no S3. Os dados são compactados como parte do processo de upload para reduzir a quantidade de espaço usado no S3; portanto, o objeto no S3 pode ser menor do que a soma dos tamanhos dos snapshots na AMI.
Se houver tags de AMI e de snapshot visíveis para a conta chamando essa API, elas serão preservadas.
O objeto no S3 tem o mesmo ID que a AMI, mas com uma extensão `.bin`. Os dados a seguir também são armazenados como tags de metadados do S3 no objeto do S3: nome da AMI, descrição da AMI, data de registro da AMI, conta de proprietário da AMI e um timestamp para a operação de armazenamento.
O tempo necessário para concluir a tarefa depende do tamanho da AMI. Também depende de quantas outras tarefas estão em andamento porque as tarefas estão em fila. É possível acompanhar o andamento da tarefa chamando a API `DescribeStoreImageTasks`.
A soma dos tamanhos de todas as AMIs em andamento é limitada a 1.200 GB de dados de snapshot do EBS por conta. A criação de tarefas adicionais será rejeitada até que as tarefas em andamento sejam inferiores ao limite. Por exemplo, se uma AMI com 200 GB de dados de snapshot e outra AMI com 400 GB de dados de snapshot estiverem sendo armazenadas no momento, outra solicitação será aceita, pois o total em andamento é de 600 GB, que é inferior ao limite. Mas se uma única AMI com 1.200 GB de dados de snapshot estiver sendo armazenada no momento, outras tarefas serão rejeitadas até que a tarefa seja concluída.
## DescriboesToreImageTasks
A API `DescribeStoreImageTasks` descreve o andamento das tarefas de armazenamento de uma AMI. É possível descrever tarefas para AMIs especificadas. Se você não especificar AMIs, receberá uma lista paginada de todas as tarefas de imagem de armazenamento que foram processadas nos últimos 31 dias.
Para cada tarefa de AMI, a resposta indica se a tarefa é `InProgress``Completed` ou `Failed`. Para tarefas `InProgress`, a resposta mostra um andamento estimado como uma porcentagem.
As tarefas são listadas em ordem cronológica inversa.
No momento, somente as tarefas do mês anterior podem ser visualizadas.
## CreateRestoreImageTask
A API `CreateRestoreImageTask` inicia uma tarefa que restaura uma AMI de um objeto do S3 que foi criado anteriormente usando uma solicitação `CreateStoreImageTask`.
A tarefa de restauração pode ser executada na mesma região ou em uma região diferente daquela em que a tarefa de armazenamento foi executada.
O bucket do S3 a partir do qual o objeto da AMI será restaurado deve estar na mesma região em que a tarefa de restauração é solicitada. A AMI será restaurada nessa região.
A AMI é restaurada com seus metadados, como o nome, a descrição e os mapeamentos de dispositivos de blocos correspondentes aos valores da AMI armazenada. O nome deve ser exclusivo para AMIs na região dessa conta. Se você não fornecer um nome, a nova AMI obterá o mesmo nome da AMI original. A AMI obtém um novo ID de AMI que é gerado no momento do processo de restauração.
O tempo necessário para a conclusão da tarefa de restauração da AMI depende do tamanho da AMI. Também depende de quantas outras tarefas estão em andamento porque as tarefas estão em fila. É possível visualizar o andamento da tarefa descrevendo a AMI ([describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html)) ou seus snapshots do EBS ([describe-snapshots](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-snapshots.html)). Se a tarefa falhar, a AMI e os snapshots serão movidos para um estado com falha.
A soma dos tamanhos de todas as AMIs em andamento é limitada a 600 GB (com base no tamanho após a restauração) de dados de snapshot do EBS por conta. A criação de tarefas adicionais será rejeitada até que as tarefas em andamento sejam inferiores ao limite.
## Caminhos do arquivo
É possível usar caminhos de arquivo ao armazenar e restaurar AMIs, da seguinte forma:
+ Ao armazenar uma AMI no S3, o caminho do arquivo pode ser adicionado ao nome do bucket. Internamente, o sistema separa o caminho do nome do bucket e, em seguida, adiciona o caminho à chave do objeto que é gerada para armazenar a AMI. O caminho completo do objeto é mostrado na resposta da chamada de API.
+ Ao restaurar a AMI, como um parâmetro de chave de objeto está disponível, o caminho pode ser adicionado ao início do valor da chave do objeto.
**Exemplo: nome do bucket com caminho de arquivo anexado**
Ao armazenar a AMI, especifique o caminho do arquivo após o nome do bucket.
```
amzn-s3-demo-bucket/path1/path2
```
A chave do objeto resultante é mostrada a seguir.
```
path1/path2/ami-0abcdef1234567890.bin
```
Ao restaurar a AMI, especifique o nome do bucket e a chave do objeto. Para obter exemplos, consulte [Criar uma tarefa de armazenamento de imagem](work-with-ami-store-restore.md#create-store-image-task).
# Criar uma tarefa de armazenamento de imagem
Quando você armazena uma AMI em um bucket do S3, uma tarefa de armazenamento de imagem é criada. É possível usar a tarefa de armazenamento de imagem para monitorar o andamento e o resultado do processo.
**Topics**
+ [Proteger suas AMIs](#securing-amis)
+ [Permissões para armazenar e restaurar AMIs usando o S3](#ami-s3-permissions)
+ [Criar uma tarefa de armazenamento de imagem](#create-store-image-task)
+ [Criar uma tarefa de restauração de imagem](#create-restore-image-task)
## Proteger suas AMIs
É importante garantir que o bucket do S3 esteja configurado com segurança suficiente para proteger o conteúdo da AMI e que a segurança seja mantida enquanto os objetos da AMI permanecerem no bucket. Se isso não puder ser feito, o uso dessas APIs não é recomendado. Não permita acesso público ao bucket do S3. Recomendamos que você ative a [Criptografia do lado do servidor](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) para os buckets do S3 nos quais você armazena as AMIs, embora não seja necessário.
Para obter informações sobre como definir as configurações de segurança apropriadas para os buckets do S3, consulte os seguintes tópicos de segurança:
+ [Bloquear o acesso público ao armazenamento do Amazon S](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html)
+ [Definir o comportamento padrão da criptografia para os buckets do Amazon S](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html)
+ [Qual política de bucket do S3 devo usar para seguir a regra s3-bucket-ssl-requests-only do AWS Config?](https://repost.aws/knowledge-center/s3-bucket-policy-for-config-rule)
+ [Habilitar o log de acesso ao servidor do Amazon S](https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html)
Quando os snapshots da AMI são copiados para o objeto S3, os dados são copiados em conexões TLS. É possível armazenar AMIs com snapshots criptografados, mas os snapshots são descriptografados como parte do processo de armazenamento.
## Permissões para armazenar e restaurar AMIs usando o S3
Caso as entidades principais do IAM armazenem ou restaurem AMIs usando o Amazon S3, você precisará conceder a elas as permissões necessárias.
A política de exemplo a seguir inclui todas as ações necessárias para permitir que uma entidade principal do IAM execute as tarefas de armazenamento e restauração.
Também é possível criar políticas do IAM que concedam às entidades principais acesso apenas a recursos específicos. Para obter mais exemplos de políticas, consulte [Gerenciamento de acesso para recursos da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html) no *Guia do usuário do IAM*.
**nota**
Se os snapshots que compõem a AMI estiverem criptografados ou se a conta estiver habilitada para criptografia por padrão, seu principal do IAM deverá ter permissão para usar a chave KMS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:DeleteObject",
"s3:GetObject",
"s3:ListBucket",
"s3:PutObject",
"s3:PutObjectTagging",
"s3:AbortMultipartUpload",
"ebs:CompleteSnapshot",
"ebs:GetSnapshotBlock",
"ebs:ListChangedBlocks",
"ebs:ListSnapshotBlocks",
"ebs:PutSnapshotBlock",
"ebs:StartSnapshot",
"ec2:CreateStoreImageTask",
"ec2:DescribeStoreImageTasks",
"ec2:CreateRestoreImageTask",
"ec2:GetEbsEncryptionByDefault",
"ec2:DescribeTags",
"ec2:CreateTags"
],
"Resource": "*"
}
]
}
```
------
## Criar uma tarefa de armazenamento de imagem
Para armazenar uma AMI em um bucket do S3, comece criando uma tarefa de armazenamento de imagem. O tempo necessário para concluir a tarefa depende do tamanho da AMI. É possível acompanhar o andamento da tarefa até que ela tenha êxito ou falhe.
------
#### [ AWS CLI ]
**Para criar a tarefa de armazenamento de imagem**
Use o comando [create-store-image-task](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-store-image-task.html).
```
aws ec2 create-store-image-task \
--image-id ami-0abcdef1234567890 \
--bucket amzn-s3-demo-bucket
```
O seguinte é um exemplo de saída.
```
{
"ObjectKey": "ami-0abcdef1234567890.bin"
}
```
**Para descrever o andamento de uma tarefa de armazenamento de AMI**
Use o comando [describe-store-image-tasks](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-store-image-tasks.html).
```
aws ec2 describe-store-image-tasks \
--image-ids ami-0abcdef1234567890 \
--query StoreImageTaskResults[].StoreTaskState \
--output text
```
O seguinte é um exemplo de saída.
```
InProgress
```
------
#### [ PowerShell ]
**Para criar a tarefa de armazenamento de imagem**
Use o cmdlet [New-EC2StoreImageTask](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2StoreImageTask.html).
```
New-EC2StoreImageTask `
-ImageId ami-0abcdef1234567890 `
-Bucket amzn-s3-demo-bucket
```
O seguinte é um exemplo de saída.
```
ObjectKey : ami-0abcdef1234567890.bin
```
**Para descrever o andamento de uma tarefa de armazenamento de AMI**
Use o cmdlet [Get-EC2StoreImageTask](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2StoreImageTask.html).
```
(Get-EC2StoreImageTask -ImageId ami-0abcdef1234567890).StoreTaskState
```
O seguinte é um exemplo de saída.
```
InProgress
```
------
## Criar uma tarefa de restauração de imagem
É necessário especificar um nome para a AMI restaurada. O nome deve ser exclusivo para AMIs na região dessa conta. A AMI restaurada obtém um novo ID de AMI.
------
#### [ AWS CLI ]
**Para criar uma tarefa de armazenamento de imagem**
Use o comando [create-restore-image-task](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-restore-image-task.html).
```
aws ec2 create-restore-image-task \
--object-key ami-0abcdef1234567890.bin \
--bucket amzn-s3-demo-bucket \
--name "my-restored-ami"
```
O seguinte é um exemplo de saída.
```
{
"ImageId": "ami-1234567890abcdef0"
}
```
------
#### [ PowerShell ]
**Para criar uma tarefa de armazenamento de imagem**
Use o cmdlet [New-EC2RestoreImageTask](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2RestoreImageTask.html).
```
New-EC2RestoreImageTask `
-ObjectKey ami-0abcdef1234567890.bin `
-Bucket amzn-s3-demo-bucket `
-Name "my-restored-ami"
```
O seguinte é um exemplo de saída.
```
ImageId : ami-1234567890abcdef0
```
------
# Use a ancestralidade da AMI para rastrear a origem de uma AMI
A ancestralidade da AMI ajuda você a rastrear a origem de uma AMI retornando os IDs e as regiões de todas as AMIs ancestrais. Quando você cria ou copia uma AMI, a nova AMI retém o ID e a região de sua AMI de origem (principal). Isso permite que você rastreie a cadeia de AMIs até a AMI raiz.
**Benefícios principais**
O uso dos ancestrais de AMI é útil para que você:
+ Rastreie os derivados de AMI para garantir a conformidade com as políticas internas.
+ Identifique AMIs potencialmente vulneráveis quando um problema de segurança for encontrado em uma AMI ancestral.
+ Mantenha a visibilidade das origens da AMI em várias regiões.
**Topics**
+ [Como funciona a ascendência da AMI](#how-ami-ancestry-works)
+ [Considerações](#ami-ancestry-conditions)
+ [Visualizar ascendência de AMI](#view-ami-ancestry)
+ [Identificar a AMI de origem](#identify-source-ami-used-to-create-new-ami)
## Como funciona a ascendência da AMI
A ascendência da AMI identifica a AMI principal que foi usada para criar a AMI especificada, a principal da principal e assim por diante, até a AMI raiz. Como isso funciona:
+ Cada AMI exibe o ID e a região de sua AMI de origem (principal).
+ Começando com a AMI selecionada, a lista de entradas de ascendência exibe cada AMI principal em sequência.
+ A lista de entradas de ascendência remonta até chegar à AMI raiz. A AMI raiz é uma das seguintes:
+ Uma AMI pública de um [provedor verificado](sharing-amis.md#verified-ami-provider) (identificada pelo alias do proprietário, que é `amazon` ou`aws-marketplace`).
+ Uma AMI sem ancestral registrado. Por exemplo, ao usar [RegisterImage](creating-an-ami-ebs.md#creating-launching-ami-from-snapshot) para criar uma AMI diretamente de um conjunto de snapshots, não há nenhuma AMI de origem para rastrear, diferente da criação de uma AMI a partir de uma instância.
+ Uma AMI cuja AMI de origem é de uma [partição](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#partition) diferente.
+ A 50ª AMI da lista. O número máximo de AMI em uma lista de ancestrais é 50.
## Considerações
+ [O ID e a região da AMI de origem só estão disponíveis para AMIs criadas usando [CreateImage](creating-an-ami-ebs.md#how-to-create-ebs-ami), [CopyImage](CopyingAMIs.md#ami-copy-steps) ou CreateRestoreImageTask](store-restore-how-it-works.md#CreateRestoreImageTask).
+ Nas AMIs criadas utilizando [CreateImage](creating-an-ami-ebs.md#how-to-create-ebs-ami) (cria uma AMI usando uma instância), o ID da AMI de origem é o ID da AMI utilizada para iniciar a instância.
+ As informações de origem da AMI não estão disponíveis para:
+ AMIs criadas usando [RegisterImage](creating-an-ami-ebs.md#creating-launching-ami-from-snapshot) porque foram criadas a partir de instantâneos.
+ Para algumas AMIs mais antigas.
+ As informações da AMI de origem são preservadas quando:
+ As AMIs são copiadas em todas as regiões.
+ As AMIs de origem são canceladas (excluídas).
+ Você não tem acesso às AMI de origem.
+ Cada lista de ascendência é limitada a 50 AMIs.
## Visualizar ascendência de AMI
É possível visualizar a ascendência de uma AMI usando os seguintes métodos.
------
#### [ Console ]
**Para visualizar a ascendência de uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione uma AMI e escolha a guia **Ancestralidade da AMI**.
1. A tabela de **entradas de ancestralidade da AMI** lista todas as AMIs na lista de ancestralidade.
+ **ID da AMI** — O identificador de cada AMI na lista de ancestralidade. A primeira entrada na tabela é a AMI selecionada, seguida por seus ancestrais.
+ **ID da AMI de origem** — A ID da AMI a partir da qual a AMI na coluna **ID da AMI** foi criada. Um traço (**-**) indica o fim da lista de ascendência da AMI.
+ **Região da AMI de origem** — Região da AWS Onde a AMI de origem está localizada.
+ **Nível de ascendência** — A posição na lista de ascendência, onde:
+ **0 (AMI de entrada)** indica a AMI selecionada cuja ascendência você deseja conhecer.
+ Números crescentes mostram ancestrais mais antigos.
+ ***n* (AMI original)** indica a AMI raiz, com o número indicando até onde vai a lista de ancestrais.
+ **Data de criação** — Quando a AMI foi criada, no formato UTC.
+ **Alias do proprietário** — O alias do proprietário da AMI (por exemplo, `amazon`). Um traço (**-**) indica que a AMI não tem alias de proprietário.
------
#### [ AWS CLI ]
**Para visualizar a ascendência de uma AMI**
Use o comando [get-image-ancestry](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-image-ancestry.html) e especifique o ID da AMI.
```
aws ec2 get-image-ancestry \
--image-id ami-1111111111EXAMPLE \
--region us-east-1
```
O seguinte é um exemplo de saída. A saída lista as AMIs em ordem de ascendência: a primeira entrada é a AMI especificada (de entrada), seguida pela principal, principal da principal e assim por diante, e termina com a AMI raiz.
```
{
"ImageAncestryEntries": [
{
"CreationDate": "2025-01-17T18:37:50.000Z",
"ImageId": "ami-1111111111EXAMPLE", // Input AMI
"SourceImageId": "ami-2222222222EXAMPLE",
"SourceImageRegion": "us-east-1"
},
{
"CreationDate": "2025-01-17T18:37:50.000Z",
"ImageId": "ami-2222222222EXAMPLE", // Parent AMI
"SourceImageId": "ami-3333333333EXAMPLE",
"SourceImageRegion": "us-east-1"
},
...
{
"CreationDate": "2025-01-17T18:37:50.000Z",
"ImageId": "ami-8888888888EXAMPLE", // Root AMI
"ImageOwnerAlias": "aws-marketplace",
"SourceImageId": "ami-9999999999EXAMPLE",
"SourceImageRegion": "us-east-2"
}
]
}
```
------
#### [ PowerShell ]
**Para visualizar a ancestralidade de uma AMI**
Use o cmdlet [Get-EC2ImageAncestry](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageAncestry.html).
```
Get-EC2ImageAncestry -ImageId ami-1111111111EXAMPLE
```
O seguinte é um exemplo de saída. A saída lista as AMIs em ordem de ascendência: a primeira entrada é a AMI especificada (de entrada), seguida pela principal, pela principal da principal e assim por diante, e termina com a AMI raiz.
```
ImageAncestryEntries : {
@{
CreationDate = "2025-01-17T18:37:50.000Z"
ImageId = "ami-1111111111EXAMPLE" # Input AMI
SourceImageId = "ami-2222222222EXAMPLE"
SourceImageRegion = "us-east-1"
},
@{
CreationDate = "2025-01-17T18:37:50.000Z"
ImageId = "ami-2222222222EXAMPLE" # Parent AMI
SourceImageId = "ami-3333333333EXAMPLE"
SourceImageRegion = "us-east-1"
},
...
@{
CreationDate = "2025-01-17T18:37:50.000Z"
ImageId = "ami-8888888888EXAMPLE" # Root AMI
ImageOwnerAlias = "aws-marketplace"
SourceImageId = "ami-9999999999EXAMPLE"
SourceImageRegion = "us-east-2"
}
}
```
------
## Identificar a AMI de origem
Se você precisar identificar apenas a AMI principal imediata (de origem) usada para criar uma AMI, use os métodos a seguir.
------
#### [ Console ]
**Para identificar a AMI de origem usada para criar a AMI selecionada**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione a AMI para visualizar os detalhes.
As informações da AMI de origem aparecem nos seguintes campos: **ID da AMI de origem** e **Região da AMI de origem**
------
#### [ AWS CLI ]
**Para identificar a AMI de origem usada para criar a AMI especificada**
Use o comando [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html).
```
aws ec2 describe-images \
--region us-east-1 \
--image-ids ami-0abcdef1234567890 \
--query "Images[].{ID:SourceImageId,Region:SourceImageRegion}"
```
O seguinte é um exemplo de saída.
```
[
{
"ID": "ami-0abcdef1234567890",
"Region": "us-west-2"
}
}
```
------
#### [ PowerShell ]
**Para identificar a AMI de origem usada para criar a AMI especificada**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
Get-EC2Image -ImageId ami-0abcdef1234567890 | Select SourceImageId, SourceImageRegion
```
O seguinte é um exemplo de saída.
```
SourceImageId SourceImageRegion
------------- -----------------
ami-0abcdef1234567890 us-west-2
```
------
# Gerenciar e monitorar o uso de AMIs
A AWS fornece vários recursos para ajudar você a gerenciar e monitorar o uso de AMIs de forma eficaz. É possível rastrear quais contas estão usando suas AMIs compartilhadas, identificar quando elas foram usadas pela última vez e descobrir quais recursos em sua Conta da AWS estão referenciando AMIs específicas.
A tabela a seguir fornece uma visão geral dos recursos para gerenciar e monitorar o uso de AMIs:
| Recurso | Caso de uso | Benefícios principais |
| --- | --- | --- |
| [Relatórios de uso de AMIs](your-ec2-ami-usage.md) | Obtenha visibilidade sobre quais Contas da AWS estão usando suas AMIs e o quanto cada AMI está sendo usada. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/ec2-ami-usage.html) |
| [Último rastreamento usado](ami-last-launched-time.md) | Verifique quando sua AMI foi usada pela última vez. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/ec2-ami-usage.html) |
| [Verificação de referência de AMIs](ec2-ami-references.md) | Garanta que seus recursos da AWS estejam usando as AMIs compatíveis mais recentes. | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/ec2-ami-usage.html) |
**Topics**
+ [Visualizar seu uso de AMIs](your-ec2-ami-usage.md)
+ [Verificar quando uma AMI do Amazon EC2 foi usada pela última vez](ami-last-launched-time.md)
+ [Identificar seus recursos que referenciam AMIs específicas](ec2-ami-references.md)
# Visualizar seu uso de AMIs
Se você compartilhar suas imagens de máquina da Amazon (AMI) com outras Contas da AWS, seja com Contas da AWS específicas, organizações, unidades organizacionais (UOs) ou publicamente, você poderá ver como essas AMIs são usadas criando relatórios de uso de AMIs. Os relatórios fornecem visibilidade sobre:
+ Quais Contas da AWS estão usando suas AMIs em instâncias do EC2 ou modelos de inicialização
+ Quantas instâncias do EC2 ou modelos de reinicialização estão referenciando cada AMI
Os relatórios de uso de AMIs ajudam você a gerenciar suas AMIs com mais eficiência:
+ Identifique as Contas da AWS e os tipos de recursos que referenciam suas AMIs para que você possa cancelar o registro ou desabilitar as AMIs com segurança.
+ Identifique AMIs não utilizadas para o cancelamento do registro para reduzir custos de armazenamento.
+ Identifique suas AMIs mais usadas.
**Topics**
+ [Como funcionam os relatórios de uso de AMIs](#how-ami-usage-reports-work)
+ [Criar um relatório de uso de AMIs](#create-ami-usage-reports)
+ [Visualizar relatórios de uso de AMIs](#view-ami-usage-reports)
+ [Excluir um relatório de uso de AMI](#delete-ami-usage-reports)
+ [Cotas de relatórios](#ami-usage-report-quotas)
## Como funcionam os relatórios de uso de AMIs
Ao criar um relatório de uso de AMIs, especifique:
+ A AMI a ser relatada.
+ As Contas da AWS a serem verificadas (contas específicas ou todas as contas).
+ Os tipos de recursos a serem verificados (instâncias do EC2, modelos de inicialização ou ambos).
+ Para modelos de inicialização, o número de versões a serem verificadas (o padrão é as 20 versões mais recentes).
O Amazon EC2 cria um relatório separado para cada AMI. Cada relatório fornece:
+ Uma lista das Contas da AWS usando a AMI.
+ Uma contagem dos recursos que referenciam a AMI por tipo de recurso por conta. Observe que, para modelos de inicialização, se uma AMI for referenciada em várias versões de um modelo de inicialização, a contagem será de apenas um.
**Importante**
Quando você gera um relatório de uso de AMIs, ele pode não conter a atividade mais recente. A atividade da instância das últimas 24 horas e a atividade do modelo de inicialização dos últimos dias podem não aparecer no relatório.
O Amazon EC2 exclui automaticamente um relatório 30 dias após ser criado. Você pode baixar os relatórios no console do EC2 para reter localmente.
## Criar um relatório de uso de AMIs
Para ver como sua AMI está sendo usada, primeiro você deve criar um relatório de uso de AMIs, especificando as contas e os tipos de recursos a serem relatados. Depois que o relatório for criado, será possível visualizar o conteúdo do relatório. Você também pode baixar os relatórios no console do EC2.
------
#### [ Console ]
**Para criar um relatório de uso de AMIs**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione uma AMI e escolha **Ações**, **Uso de AMIs**, **Visualizar meu uso de AMIs**.
1. Na página **Criar meu relatório de uso de AMIs**, faça o seguinte:
1. Em **Tipos de recursos**, selecione um ou mais tipos de recursos a serem relatados.
1. Em **IDs de contas**, siga um destes procedimentos:
+ Escolha **Especificar IDs de contas** e depois **Adicionar ID de conta** para cada conta a ser relatada.
+ Escolha **Incluir todas as contas** para gerar relatórios sobre todas as contas.
1. Escolha **Criar meu relatório de uso de AMIs**.
1. Na página AMI, escolha a guia **Meu uso de AMIs**.
1. Escolha um ID de relatório para visualizar seus detalhes.
------
#### [ AWS CLI ]
**Para criar um relatório de uso de AMIs para uma lista de contas**
Use o comando [create-image-usage-report](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image-usage-report.html) com os seguintes parâmetros obrigatórios:
+ `--image-id`: o ID da AMI sobre a ser relatada.
+ `--resource-types`: os tipos de recursos a serem verificados. No exemplo a seguir, os tipos de recursos a serem verificados são instâncias do EC2 e modelos de inicialização. Além disso, o número de versões do modelo de inicialização a serem verificadas também é especificado (`version-depth=100`).
Para relatar contas específicas, use o parâmetro `--account-ids` para especificar o ID de cada conta a ser relatada.
```
aws ec2 create-image-usage-report \
--image-id ami-0abcdef1234567890 \
--account-ids 111122223333 444455556666 123456789012 \
--resource-types ResourceType=ec2:Instance \
'ResourceType=ec2:LaunchTemplate,ResourceTypeOptions=[{OptionName=version-depth,OptionValues=100}]'
```
**Para criar um relatório de uso de AMIs de todas as contas**
Para relatar todas as contas usando a AMI especificada, use o mesmo comando, mas omita o parâmetro `--account-ids`.
```
aws ec2 create-image-usage-report \
--image-id ami-0abcdef1234567890 \
--resource-types ResourceType=ec2:Instance \
'ResourceType=ec2:LaunchTemplate,ResourceTypeOptions=[{OptionName=version-depth,OptionValues=100}]'
```
O seguinte é um exemplo de saída.
```
{
"ReportId": "amiur-00b877d192f6b02d0"
}
```
**Para monitorar o status da criação do relatório**
Use o comando [describe-image-usage-reports](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-usage-reports.html) e especifique o ID do relatório.
```
aws ec2 describe-image-usage-reports --report-ids amiur-00b877d192f6b02d0
```
O seguinte é um exemplo de saída. O valor inicial do campo `State` é `pending`. Para poder visualizar as entradas do relatório, o estado deve ser `available`.
```
{
"ImageUsageReports": [
{
"ImageId": "ami-0e9ae3dc21c2b3a64",
"ReportId": "amiur-abcae3dc21c2b3999",
"ResourceTypes": [
{"ResourceType": "ec2:Instance"}
],
"State": "pending",
"CreationTime": "2025-09-29T13:27:12.322000+00:00",
"ExpirationTime": "2025-10-28T13:27:12.322000+00:00"
}
]
}
```
------
#### [ PowerShell ]
**Para criar um relatório de uso de AMIs para uma lista de contas**
Use o cmdlet [New-EC2ImageUsageReport](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2ImageUsageReport.html) com os seguintes parâmetros obrigatórios:
+ `-ImageId`: o ID da AMI sobre a ser relatada.
+ `-ResourceType`: os tipos de recursos a serem verificados. No exemplo a seguir, os tipos de recursos a serem verificados são instâncias do EC2 e modelos de inicialização. Além disso, o número de versões do modelo de inicialização a serem verificadas também é especificado (`'version-depth' = 100`).
Para relatar contas específicas, use o parâmetro `-AccountId` para especificar o ID de cada conta a ser relatada.
```
New-EC2ImageUsageReport `
-ImageId ami-0abcdef1234567890 `
-AccountId 111122223333 444455556666 123456789012 `
-ResourceType @(
@{ResourceType = 'ec2:Instance'},
@{ResourceType = 'ec2:LaunchTemplate'ResourceTypeOptions = @{'version-depth' = 100}
})
```
**Para criar um relatório de uso de AMIs de todas as contas**
Para relatar todas as contas usando a AMI especificada, use o mesmo comando, mas omita o parâmetro `-AccountId`.
```
New-EC2ImageUsageReport `
-ImageId ami-0abcdef1234567890 `
-ResourceType @(
@{ResourceType = 'ec2:Instance'},
@{ResourceType = 'ec2:LaunchTemplate'ResourceTypeOptions = @{'version-depth' = 100}
})
```
O seguinte é um exemplo de saída.
```
ReportId
--------
amiur-00b877d192f6b02d0
```
**Para monitorar o status da criação do relatório**
Use o comando [Get-EC2ImageUsageReport](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageUsageReport.html) e especifique o ID do relatório.
```
Get-EC2ImageUsageReport -ReportId amiur-00b877d192f6b02d0
```
O seguinte é um exemplo de saída. O valor inicial do campo `State` é `pending`. Para poder visualizar as entradas do relatório, o estado deve ser `available`.
```
ImageUsageReports
-----------------
{@{ImageId=ami-0e9ae3dc21c2b3a64; ReportId=amiur-abcae3dc21c2b3999; ResourceTypes=System.Object[]; State=pending; CreationTime=2025-09-29; ExpirationTime=2025-10-28}}
```
------
## Visualizar relatórios de uso de AMIs
Você pode ver todos os relatórios de uso que criou para uma AMI nos últimos 30 dias. O Amazon EC2 exclui automaticamente um relatório 30 dias após ser criado.
Para cada relatório, você pode ver as Contas da AWS que estão usando a AMI, e para cada conta, uma contagem dos recursos que referenciam a AMI por tipo de recurso. Você também pode ver quando a criação do relatório foi iniciada. Essas informações só estão disponíveis quando o relatório está no estado **Concluído** (console) ou `available` (AWS CLI).
**Importante**
Quando você gera um relatório de uso de AMIs, ele pode não conter a atividade mais recente. A atividade da instância das últimas 24 horas e a atividade do modelo de inicialização dos últimos dias podem não aparecer no relatório.
------
#### [ Console ]
**Para visualizar um relatório de uso de AMIs**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione uma AMI.
1. Escolha a guia **Meus relatórios de uso**.
A lista de relatórios mostra:
+ Todos os relatórios gerados nos últimos 30 dias para a AMI selecionada.
+ Para cada relatório, a coluna **Hora de início do relatório** mostra a data em que o relatório foi criado.
1. Escolha o ID do relatório para visualizar seu conteúdo.
1. Para voltar à guia **Meus relatórios de uso** na página de detalhes da AMI, escolha **Exibir todos os relatórios dessa AMI**.
------
#### [ AWS CLI ]
**Para listar todos os relatórios de uso de AMIs para a AMI especificada**
Use o comando [describe-image-usage-reports](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-usage-reports.html) e especifique o ID da AMI para obter uma lista de seus relatórios.
```
aws ec2 describe-image-usage-reports --image-ids ami-0abcdef1234567890
```
O seguinte é um exemplo de saída. Cada ID de relatório é listado junto com os tipos de recursos que foram verificados e as datas de criação e expiração do relatório. Você pode usar essas informações para identificar os relatórios cujas entradas você deseja visualizar.
```
{
"ImageUsageReports": [
{
"ImageId": "ami-0abcdef1234567890",
"ReportId": "amiur-1111111111111111",
"ResourceTypes": [
{
"ResourceType": "ec2:Instance"
}
],
"State": "available",
"CreationTime": "2025-09-29T13:27:12.322000+00:00",
"ExpirationTime": "2025-10-28T13:27:12.322000+00:00",
"Tags": []
},
{
"ImageId": "ami-0abcdef1234567890",
"ReportId": "amiur-22222222222222222",
"ResourceTypes": [
{
"ResourceType": "ec2:Instance"
},
{
"ResourceType": "ec2:LaunchTemplate"
}
],
"State": "available",
"CreationTime": "2025-10-01T13:27:12.322000+00:00",
"ExpirationTime": "2025-10-30T13:27:12.322000+00:00",
"Tags": []
}
],
"NextToken": "opaque"
}
```
**Para visualizar o conteúdo de um relatório de uso de AMI para a AMI especificada**
Use o comando [describe-image-usage-report-entries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-usage-report-entries.html) e especifique o ID da AMI. A resposta retorna todos os relatórios da AMI especificada, mostrando as contas que usaram a AMI e suas contagens de recursos.
```
aws ec2 describe-image-usage-report-entries --image-ids ami-0abcdef1234567890
```
O seguinte é um exemplo de saída.
```
{
"ImageUsageReportEntries": [
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:Instance",
"AccountId": "123412341234",
"UsageCount": 15,
"ReportCreationTime": "2025-09-29T13:27:12.322000+00:00",
"ReportId": "amiur-1111111111111111"
},
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:Instance",
"AccountId": "123412341234",
"UsageCount": 2,
"ReportCreationTime": "2025-10-01T13:27:12.322000+00:00",
"ReportId": "amiur-22222222222222222"
},
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:Instance",
"AccountId": "001100110011",
"UsageCount": 39,
"ReportCreationTime": "2025-10-01T13:27:12.322000+00:00",
"ReportId": "amiur-22222222222222222"
}
],
"NextToken": "opaque"
}
```
**Para visualizar o conteúdo de um relatório de uso de AMI do relatório especificado**
Use o comando [describe-image-usage-report-entries](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-usage-report-entries.html) e especifique o ID do relatório. A resposta retorna todas as entradas do relatório especificado, mostrando as contas que usaram a AMI e suas contagens de recursos.
```
aws ec2 describe-image-usage-report-entries --report-ids amiur-11111111111111111
```
O seguinte é um exemplo de saída.
```
{
"ImageUsageReportEntries": [
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:Instance",
"AccountId": "123412341234",
"UsageCount": 15,
"ReportCreationTime": "2025-09-29T13:27:12.322000+00:00",
"ReportId": "amiur-11111111111111111"
},
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:LaunchTemplate",
"AccountId": "123412341234",
"UsageCount": 4,
"ReportCreationTime": "2025-09-29T13:27:12.322000+00:00",
"ReportId": "amiur-11111111111111111"
},
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:LaunchTemplate",
"AccountId": "001100110011",
"UsageCount": 2,
"ReportCreationTime": "2025-09-29T13:27:12.322000+00:00",
"ReportId": "amiur-11111111111111111"
}
],
"NextToken": "opaque"
}
```
------
#### [ PowerShell ]
**Para listar todos os relatórios de uso de AMIs para a AMI especificada**
Use o cmdlet [Get-EC2ImageUsageReport](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageUsageReport.html) e especifique o ID da AMI para obter uma lista de seus relatórios.
```
Get-EC2ImageUsageReport -ImageId ami-0abcdef1234567890
```
O seguinte é um exemplo de saída. Cada ID de relatório é listado junto com os tipos de recursos que foram verificados e as datas de criação e expiração do relatório. Você pode usar essas informações para identificar os relatórios cujas entradas você deseja visualizar.
```
@{
ImageUsageReports = @(
@{
ImageId = "ami-0abcdef1234567890"
ReportId = "amiur-1111111111111111"
ResourceTypes = @(
@{
ResourceType = "ec2:Instance"
}
)
State = "available"
CreationTime = "2025-09-29T13:27:12.322000+00:00"
ExpirationTime = "2025-10-28T13:27:12.322000+00:00"
},
@{
ImageId = "ami-0abcdef1234567890"
ReportId = "amiur-22222222222222222"
ResourceTypes = @(
@{
ResourceType = "ec2:Instance"
}
)
State = "available"
CreationTime = "2025-09-30T13:27:12.322000+00:00"
ExpirationTime = "2025-10-29T13:27:12.322000+00:00"
},
@{
ImageId = "ami-0abcdef1234567890"
ReportId = "amiur-33333333333333333"
ResourceTypes = @(
@{
ResourceType = "ec2:Instance"
}
)
State = "available"
CreationTime = "2025-10-01T13:27:12.322000+00:00"
ExpirationTime = "2025-10-30T13:27:12.322000+00:00"
}
)
NextToken = "opaque"
}
```
**Para visualizar o conteúdo de um relatório de uso de AMI para a AMI especificada**
Use o cmdlet [Get-EC2ImageUsageReportEntry](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageUsageReportEntry.html) e especifique o ID da AMI. A resposta retorna todos os relatórios da AMI especificada, mostrando as contas que usaram a AMI e suas contagens de recursos.
```
Get-EC2ImageUsageReportEntry -ImageId ami-0abcdef1234567890
```
O seguinte é um exemplo de saída.
```
ImageUsageReportEntries : {@{
ImageId = "ami-0abcdef1234567890"
ResourceType = "ec2:Instance"
AccountId = "123412341234"
UsageCount = 15
ReportCreationTime = "2025-09-29T13:27:12.322000+00:00"
ReportId = "amiur-1111111111111111"
}, @{
ImageId = "ami-0abcdef1234567890"
ResourceType = "ec2:Instance"
AccountId = "123412341234"
UsageCount = 7
ReportCreationTime = "2025-09-30T13:27:12.322000+00:00"
ReportId = "amiur-22222222222222222"
}...}
NextToken : opaque
```
**Para visualizar o conteúdo de um relatório de uso de AMI do relatório especificado**
Use o cmdlet [Get-EC2ImageUsageReportEntry](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageUsageReportEntry.html) e especifique o ID do relatório. A resposta retorna todas as entradas do relatório especificado, mostrando as contas que usaram a AMI e suas contagens de recursos.
```
Get-EC2ImageUsageReportEntry -ReportId amiur-11111111111111111
```
O seguinte é um exemplo de saída.
```
ImageUsageReportEntries : {@{
ImageId = "ami-0abcdef1234567890"
ResourceType = "ec2:Instance"
AccountId = "123412341234"
UsageCount = 15
ReportCreationTime = "2025-09-29T13:27:12.322000+00:00"
ReportId = "amiur-11111111111111111"
}, @{
ImageId = "ami-0abcdef1234567890"
ResourceType = "ec2:LaunchTemplate"
AccountId = "123412341234"
UsageCount = 4
ReportCreationTime = "2025-09-29T13:27:12.322000+00:00"
ReportId = "amiur-11111111111111111"
}, @{
ImageId = "ami-0abcdef1234567890"
ResourceType = "ec2:LaunchTemplate"
AccountId = "************"
UsageCount = 2
ReportCreationTime = "2025-09-29T13:27:12.322000+00:00"
ReportId = "amiur-11111111111111111"
}}
NextToken : opaque
```
------
## Excluir um relatório de uso de AMI
O Amazon EC2 exclui automaticamente um relatório 30 dias após ser criado. Você pode excluí-lo manualmente antes desse período.
------
#### [ Console ]
**Para excluir um relatório de uso de AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione uma AMI.
1. Escolha a guia **Meu uso de AMIs**.
1. Escolha o botão **Excluir** ao lado do relatório a ser excluído.
------
#### [ AWS CLI ]
**Para excluir um relatório de uso de AMI**
Use o comando [delete-image-usage-report](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-image-usage-report.html) e especifique o ID do relatório.
```
aws ec2 delete-image-usage-report --report-id amiur-0123456789abcdefg
```
------
#### [ PowerShell ]
**Para excluir um relatório de uso de AMI**
Use o cmdlet [Remove-EC2ImageUsageReport](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2ImageUsageReport.html) e especifique o ID do relatório.
```
Remove-EC2ImageUsageReport -ReportId amiur-0123456789abcdefg
```
------
## Cotas de relatórios
As cotas a seguir se aplicam à criação de relatórios de uso de AMIs. Estas cotas são aplicáveis por Região da AWS.
| Descrição | Quota |
| --- | --- |
| Relatórios de uso de AMIs em andamento (pending) por Conta da AWS | 2.000 |
| Relatórios de uso de AMIs em andamento (pending) por AMI | 1 |
# Verificar quando uma AMI do Amazon EC2 foi usada pela última vez
O Amazon EC2 rastreia a data e a hora quando a AMI foi usada a última vez para executar uma instância. Se tiver uma AMI que não tenha sido usada para executar uma instância há muito tempo, considere se a AMI é uma boa candidata para [cancelamento de registro](deregister-ami.md) ou [defasagem](ami-deprecate.md).
**Considerações**
+ Quando uma AMI é usada para iniciar uma instância, há um atraso de 24 horas antes que o uso seja incluído em relatórios.
+ Você precisa ser o proprietário da AMI para obter a hora da última execução.
+ Os dados de uso das AMIs estão disponíveis a partir de abril de 2017.
------
#### [ Console ]
**Como visualizar a última hora de início de uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação à esquerda, selecione **AMIs**.
1. Na barra de filtros, escolha **Owned by me** (Sou proprietário).
1. Marque a caixa de seleção da AMI.
1. Na guia **Detalhes**, encontre **Hora da última inicialização**.
------
#### [ AWS CLI ]
**Para visualizar a hora da última inicialização descrevendo a AMI**
Use o comando [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html). Se `LastLaunchedTime` não estiver presente na saída, verifique se você é o proprietário da AMI.
```
aws ec2 describe-images \
--image-id ami-0abcdef1234567890 \
--query Images[].LastLaunchedTime \
--output text
```
O seguinte é um exemplo de saída.
```
2025-02-17T20:22:19Z
```
**Para visualizar o atributo da hora de última inicialização de uma AMI**
Use o comando [describe-image-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-attribute.html). Você precisa ser o proprietário da AMI especificada.
```
aws ec2 describe-image-attribute \
--image-id ami-0abcdef1234567890 \
--attribute lastLaunchedTime \
--query LastLaunchedTime.Value \
--output text
```
O seguinte é um exemplo de saída.
```
2025-02-17T20:22:19Z
```
------
#### [ PowerShell ]
**Para visualizar a hora da última inicialização descrevendo a AMI**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html). Se `LastLaunchedTime` não estiver presente na saída, verifique se você é o proprietário da AMI.
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).LastLaunchedTime
```
O seguinte é um exemplo de saída.
```
2025-02-17T20:22:19Z
```
**Para visualizar o atributo da hora de última inicialização de uma AMI**
Use o cmdlet [Get-EC2ImageAttribute](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageAttribute.html). Você precisa ser o proprietário da AMI especificada.
```
(Get-EC2ImageAttribute `
-ImageId ami-0abcdef1234567890 `
-Attribute LastLaunchedTime).LastLaunchedTime
```
O seguinte é um exemplo de saída.
```
2025-02-17T20:22:19Z
```
------
# Identificar seus recursos que referenciam AMIs específicas
É possível identificar seus recursos da AWS que referenciam imagens de máquina da Amazon (AMIs) específicas, independentemente de as AMIs serem públicas ou privadas ou de quem as possui. Essa visibilidade ajuda você a garantir que seus recursos usem as mais recentes AMIs compatíveis.
**Benefícios principais**
A verificação das referências de AMIs ajuda para que você:
+ Audite o uso de AMIs em sua conta.
+ Verifique onde as AMIs específicas estão sendo referenciadas.
+ Mantenha a conformidade atualizando seus recursos para referenciar as AMIs mais recentes.
**Topics**
+ [Recursos compatíveis](#ec2-ami-references-supported-resources)
+ [Como funcionam as verificações de referência de AMIs](#how-ami-references-works)
+ [Permissões obrigatórias do IAM](#ami-references-required-permissions)
+ [Etapas para verificar as referências de AMIs](#ami-reference-procedures)
## Recursos compatíveis
As referências de AMIs podem ser verificadas em:
+ Instâncias do EC2
+ Modelos de execução
+ Parâmetros do SSM
+ Fórmulas de imagens do Image Builder
+ Fórmulas de contêineres do Image Builder
## Como funcionam as verificações de referência de AMIs
**Operação básica**
Ao executar uma verificação de referência de AMIs:
+ Especifique quais AMIs devem ser verificadas.
+ Escolha quais tipos de recursos serão verificados.
+ Receba uma lista de seus recursos que referenciam AMIs específicas.
**Seleção do tipo de recurso**
No console, você seleciona os tipos de recursos a serem verificados.
Na CLI, você especifica os tipos de recursos a serem verificados usando um ou os dois dos seguintes parâmetros da CLI:
+ `IncludeAllResourceTypes`: verifica todos os tipos de recursos compatíveis.
+ `ResourceTypes`: verifica os tipos de recursos especificados.
**Definir o escopo de respostas**
É possível definir o escopo de respostas para instâncias do EC2 e modelos de inicialização personalizando os valores de `ResourceTypeOptions` usando o parâmetro `ResourceTypes`. Tanto o console quanto o parâmetro `IncludeAllResourceTypes` usam valores de opção padrão. Quando `ResourceTypes` e `IncludeAllResourceTypes` são usados juntos, os valores das opções de `ResourceTypes` têm precedência sobre os padrões.
Os seguintes valores padrão são usados:
| Tipo de recurso | Opção de escopo (`OptionName`) | Finalidade | Valores padrão para `OptionValue` e o console |
| --- | --- | --- | --- |
| Instâncias do EC2 | state-name | Filtrar por estado da instância | pending, running, shutting-down, terminated, stopping, stopped (todos os estados) |
| Modelos de execução | version-depth | Especifique o número de versões do modelo de inicialização a serem verificadas (começando pela versão mais recente) | 10 (versões mais recentes) |
## Permissões obrigatórias do IAM
Para usar a API DescribeImageReferences para identificar seus recursos que referenciam AMIs específicas, você precisa das seguintes permissões do IAM para descrever os recursos:
+ `ec2:DescribeInstances`
+ `ec2:DescribeLaunchTemplates`
+ `ec2:DescribeLaunchTemplateVersions`
+ `ssm:DescribeParameters`
+ `ssm:GetParameters`
+ `imagebuilder:ListImageRecipes`
+ `imagebuilder:ListContainerRecipes`
+ `imagebuilder:GetContainerRecipe`
**Exemplo de política do IAM para usar a API DescribeImageReferences**
O exemplo de política a seguir concede a você as permissões para usar a API DescribeImageReferences, que inclui as permissões para descrever instâncias do EC2, modelos de inicialização, parâmetros do Systems Manager, fórmulas de imagens do Image Builder e fórmulas de contêineres do Image Builder.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "ec2:DescribeImageReferences",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"ec2:DescribeInstances",
"ec2:DescribeLaunchTemplates",
"ec2:DescribeLaunchTemplateVersions",
"ssm:DescribeParameters",
"ssm:GetParameters",
"imagebuilder:ListImageRecipes",
"imagebuilder:ListContainerRecipes",
"imagebuilder:GetContainerRecipe"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:CalledVia": [
"ec2-images.amazonaws.com"
]
}
}
}
]
}
```
------
**Importante**
É altamente recomendável usar a política gerenciada [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html) da AWS em vez de criar a política você mesmo. Criar uma política do IAM personalizada que forneça somente as permissões necessárias requer tempo e experiência, e exigirá atualizações à medida que novos tipos de recursos forem disponibilizados.
A política gerenciada `AmazonEC2ImageReferencesAccessPolicy`:
Concede todas as permissões necessárias para usar a API DescribeImageReferences, que inclui as permissões para descrever instâncias do EC2, modelos de inicialização, parâmetros do Systems Manager e fórmulas de imagens e de contêineres do Image Builder.
É automaticamente compatível com novos tipos de recursos à medida que ficam disponíveis (especialmente importante ao usar o parâmetro `IncludeAllResourceTypes`).
É possível anexar a política `AmazonEC2ImageReferencesAccessPolicy` às identidades do IAM (usuários, grupos e perfis).
Para visualizar as permissões incluídas nessa política, consulte [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEC2ImageReferencesAccessPolicy.html) na *Referência de políticas gerenciadas pela AWS*.
## Etapas para verificar as referências de AMIs
Use os procedimentos a seguir para identificar quais dos seus recursos da AWS estão referenciando AMIs específicas.
------
#### [ Console ]
**Para identificar recursos referenciando AMIs específicas**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Selecione uma ou mais AMIs para verificar as referências.
1. Escolha **Ações**, **Uso de AMIs**, **Visualizar recursos referenciados**.
1. Na página **Visualizar recursos referenciando AMIs selecionadas**:
1. Em **Tipos de recursos**, selecione um ou mais tipos de recursos.
1. Escolha **Visualizar recursos**.
1. A seção **Recursos referenciando AMIs selecionadas** é exibida. A lista exibe os recursos que referenciam AMIs específicas. Cada linha fornece as seguintes informações:
+ **ID da AMI**: o ID da AMI referenciada.
+ **Tipo de recurso**: o tipo de recurso do recurso que referencia a AMI.
+ **ID do recurso**: o ID do recurso que referencia a AMI.
------
#### [ AWS CLI ]
**Para verificar as referências de AMIs para tipos de recursos específicos**
Use o comando [describe-image-references](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-references.html) com o parâmetro `--resource-types`. O exemplo a seguir verifica as instâncias do EC2 (definição do escopo por estado da instância), modelos de inicialização (considerando as 20 versões mais recentes de modelos de inicialização) e outros tipos de recursos específicos.
```
aws ec2 describe-image-references \
--image-ids ami-0abcdef1234567890 ami-1234567890abcdef0 \
--resource-types \
'ResourceType=ec2:Instance,ResourceTypeOptions=[{OptionName=state-name,OptionValues=[running,pending]}]' \
'ResourceType=ec2:LaunchTemplate,ResourceTypeOptions=[{OptionName=version-depth,OptionValues=[20]}]' \
'ResourceType=ssm:Parameter' \
'ResourceType=imagebuilder:ImageRecipe' \
'ResourceType=imagebuilder:ContainerRecipe'
```
O seguinte é um exemplo de saída.
```
{
"ImageReferences": [
{
"ImageId": "ami-0abcdef1234567890",
"ResourceType": "ec2:Instance",
"Arn": "arn:aws:ec2:us-east-1:123456789012:instance/i-1234567890abcdef0"
},
{
"ImageId": "ami-1234567890abcdef0",
"ResourceType": "ec2:LaunchTemplate",
"Arn": "arn:aws:ec2:us-east-1:123456789012:launch-template/lt-1234567890abcdef0"
}
]
}
```
**Para verificar as referências de AMIs para todos os tipos de recursos compatíveis**
Use o comando [describe-image-references](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-references.html) com o parâmetro `--include-all-resource-types`.
```
aws ec2 describe-image-references \
--image-ids ami-0abcdef1234567890 ami-1234567890abcdef0 \
--include-all-resource-types
```
**Para verificar as referências de AMIs para todos os tipos de recursos compatíveis e opções específicas**
Use o comando [describe-image-references](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-image-references.html) com os parâmetros `--include-all-resource-types` e `--resource-types`. Este exemplo verifica todos os tipos de recursos ao definir o escopo da resposta das instâncias do EC2 para as instâncias em execução ou pendentes.
```
aws ec2 describe-image-references \
--image-ids ami-0abcdef1234567890 ami-1234567890abcdef0 \
--include-all-resource-types \
--resource-types 'ResourceType=ec2:Instance,ResourceTypeOptions=[{OptionName=state-name,OptionValues=[running,pending]}]'
```
------
#### [ PowerShell ]
**Para verificar as referências de AMIs para tipos de recursos específicos**
Use o cmdlet [Get-EC2ImageReference](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageReference.html) com o parâmetro `-ResourceType`. O exemplo a seguir verifica as instâncias do EC2 (definição do escopo por estado da instância), modelos de inicialização (considerando as 20 versões mais recentes de modelos de inicialização) e outros tipos de recursos específicos.
```
Get-EC2ImageReference `
-ImageId 'ami-0abcdef1234567890', 'ami-1234567890abcdef0' `
-ResourceType @(
@{
ResourceType = 'ec2:Instance'
ResourceTypeOptions = @(
@{
OptionName = 'state-name'
OptionValues = @('running', 'pending')
}
)
},
@{
ResourceType = 'ec2:LaunchTemplate'
ResourceTypeOptions = @(
@{
OptionName = 'version-depth'
OptionValues = @('20')
}
)
},
@{
ResourceType = 'ssm:Parameter'
},
@{
ResourceType = 'imagebuilder:ImageRecipe'
},
@{
ResourceType = 'imagebuilder:ContainerRecipe'
}
)
```
**Para verificar as referências de AMIs para todos os tipos de recursos compatíveis**
Use o cmdlet [Get-EC2ImageReference](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageReference.html) com o parâmetro `-IncludeAllResourceTypes`.
```
Get-EC2ImageReference `
-ImageId 'ami-0abcdef1234567890', 'ami-1234567890abcdef0' `
-IncludeAllResourceTypes
```
**Para verificar as referências de AMIs para todos os tipos de recursos compatíveis e opções específicas**
Use o cmdlet [Get-EC2ImageReference](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2ImageReference.html) com os parâmetros `-IncludeAllResourceTypes` e `-ResourceType`. Este exemplo verifica todos os tipos de recursos ao definir o escopo da resposta das instâncias do EC2 para as instâncias em execução ou pendentes.
```
Get-EC2ImageReference `
-ImageId 'ami-0abcdef1234567890', 'ami-1234567890abcdef0' `
-IncludeAllResourceTypes `
-ResourceType @(
@{
ResourceType = 'ec2:Instance'
ResourceTypeOptions = @(
@{
OptionName = 'state-name'
OptionValues = @('running', 'pending')
}
)
}
)
```
------
# Descontinuar uma AMI do Amazon EC2
É possível defasar uma AMI para indicar que ela está desatualizada e não deve ser usada. Também é possível especificar uma data de defasagem futura para uma AMI, indicando quando a AMI estará desatualizada. Por exemplo, é possível defasar uma AMI cuja manutenção não está mais ativa ou pode defasar uma AMI que foi substituída por uma versão mais recente. Por padrão, as AMIs defasadas não aparecem nas listagens de AMI, impedindo que novos usuários usem AMIs desatualizadas. No entanto, os usuários existentes e os serviços de inicialização, como modelos de inicialização e grupos do Auto Scaling, podem continuar usando uma AMI defasada especificando seu ID. Para excluir a AMI, de modo que usuários e serviços não possam usá-la, é necessário [cancelar o registro](deregister-ami.md) dela.
Depois que uma AMI estiver defasada:
+ Para usuários de AMI, a AMI defasada não aparece nas chamadas de API [DescribeImages](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html), a menos que você especifique o ID dela ou especifique que AMIs defasadas devem ser exibidas. Os proprietários da AMI continuam a ver AMIs defasadas nas chamadas de API [DescribeImages](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html).
+ Para usuários de AMI, a AMI defasada não está disponível para seleção no console do EC2. Por exemplo, uma AMI defasada não é exibida no catálogo da AMI no assistente de inicialização de instância. Os proprietários da AMI continuam a ver AMIs defasadas no console do EC2.
+ Para os usuários da AMI, se você souber o ID de uma AMI defasada, poderá continuar a iniciar instâncias usando a AMI defasada com a API, a CLI ou os SDKs.
+ Os serviços de inicialização, como modelos de inicialização e grupos do Auto Scaling, podem continuar referenciando a AMIs defasadas.
+ As instâncias do EC2 que foram iniciadas usando uma AMI que posteriormente é defasada não são afetadas e podem ser interrompidas, iniciadas e reinicializadas.
É possível defasar AMIs privadas e públicas.
**Topics**
+ [Custos](#ami-deprecate-costs)
+ [Considerações](#ami-deprecate-limitations)
+ [Defasar uma AMI](#deprecate-ami)
+ [Descrever AMIs defasadas](#describe-deprecate-ami)
+ [Cancelar a descontinuação da AMI](#cancel-deprecate-ami)
## Custos
Quando você defasar uma AMI, a AMI não será excluída. O proprietário da AMI continuará pagando pelos snapshots da AMI. Para parar de pagar pelos instantâneos, o proprietário da AMI deve excluir a AMI [cancelando o registro](deregister-ami.md) dela.
## Considerações
+ Para defasar uma AMI, é necessário ser o proprietário da AMI.
+ AMIs que não tenham sido usadas recentemente para iniciar uma instância podem ser boas candidatas para descontinuação ou cancelamento de registro. Para obter mais informações, consulte [Verificar quando uma AMI do Amazon EC2 foi usada pela última vez](ami-last-launched-time.md).
+ É possível criar políticas de AMI apoiadas pelo EBS Amazon Data Lifecycle Manager para automatizar a descontinuação das AMIs apoiadas pelo EBS. Para obter mais informações, consulte [Create AMI lifecycle policies](https://docs.aws.amazon.com/ebs/latest/userguide/ami-policy.html).
+ Por padrão, a data de descontinuação de todas as AMIs públicas é definida como dois anos a partir da data de criação da AMI. É possível definir a data de descontinuação para antes de dois anos. Para cancelar a data de descontinuação ou adiá-la para uma data posterior, você deve tornar a AMI privada [compartilhando-a somente com contas específicas da AWS](sharingamis-explicit.md).
## Defasar uma AMI
É possível defasar uma AMI em uma data e hora específicas. É necessário ser o proprietário da AMI.
O limite superior para a data de descontinuação é daqui a 10 anos, exceto para AMIs públicas, em que o limite superior é de 2 anos após a data de criação. Você não pode especificar uma data no passado.
------
#### [ Console ]
**Para descontinuar uma AMI em uma data específica**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No navegador à esquerda, escolha **AMIs**.
1. Na barra de filtros, escolha **Owned by me** (Sou proprietário).
1. Selecione a AMI e escolha **Actions** (Ações), **Manage AMI Deprecation** (Gerenciar descontinuação da AMI). É possível selecionar várias AMIs para definir a mesma data de descontinuação de várias AMIs de uma só vez.
1. Marque a caixa de seleção **Habilitar** e insira a data e a hora de descontinuação.
1. Escolha **Salvar**.
------
#### [ AWS CLI ]
**Para descontinuar uma AMI em uma data específica**
Usar o comando [disable-image-deprecation](https://docs.aws.amazon.com/cli/latest/reference/ec2/enable-image-deprecation.html). Se você especificar um valor para segundos, o Amazon EC2 arredondará os segundos para o minuto mais próximo.
```
aws ec2 enable-image-deprecation \
--image-id ami-0abcdef1234567890 \
--deprecate-at "2025-04-15T13:17:12.000Z"
```
------
#### [ PowerShell ]
**Para descontinuar uma AMI em uma data específica**
Use o cmdlet [Enable-EC2ImageDeprecation](https://docs.aws.amazon.com/powershell/latest/reference/items/Enable-EC2ImageDeprecation.html). Se você especificar um valor para segundos, o Amazon EC2 arredondará os segundos para o minuto mais próximo.
```
Enable-EC2ImageDeprecation `
-ImageId ami-0abcdef1234567890 `
-DeprecateAt 2025-04-15T13:17:12.000Z
```
------
## Descrever AMIs defasadas
É possível visualizar a data e a hora de descontinuação de uma AMI e filtrar as AMIs por data de substituição.
------
#### [ Console ]
**Para visualizar a data de descontinuação de uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No navegador, escolha **AMIs** e, em seguida, selecione a AMI.
1. Selecione o campo **Hora da descontinuação** (se você marcou a caixa de seleção ao lado da AMI, ele estará localizado na guia **Detalhes**). O campo mostra a data e a hora de descontinuação da AMI. Se o campo estiver vazio, a AMI não estará descontinuada.
**Para filtrar AMIs por data de descontinuação**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No navegador à esquerda, escolha **AMIs**.
1. Na barra de filtros, escolha **Owned by me** (Sou proprietário) ou **Private images** (Imagens privadas) (as imagens privadas incluem AMIs compartilhadas com você e de sua propriedade).
1. Na Search bar (Barra de pesquisa), insira **Deprecation time** (à medida que você insere as letras, o filtro **Deprecation time** (Hora da descontinuação) aparece) e, em seguida, escolha um operador e uma data e hora.
------
#### [ AWS CLI ]
Quando você descreve todas as AMIs, os resultados dependerão se você é usuário da AMI ou proprietário da AMI.
+ **Usuário da AMI**: por padrão, quando você descreve todas as AMIs, as AMIs descontinuadas compartilhadas com você, mas das quais você não é proprietário, são excluídas. Para incluir AMIs descontinuadas nos resultados, especifique a opção `--include-deprecated`.
+ **Proprietário da AMI**: quando você descreve todas as AMIs, todas as AMIs das quais você é proprietário, inclusive AMIs descontinuadas, são incluídas. Você não pode usar a opção `--no-include-deprecated` para excluir as AMIs descontinuadas de sua propriedade.
**Para incluir as AMIs descontinuadas ao descrever todas as AMIs de uma conta**
Use o seguinte comando [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html).
```
aws ec2 describe-images
--owners 123456789012 \
--include-deprecated
```
**Para descrever as AMIs descontinuadas da sua conta**
Use o seguinte comando [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html).
```
aws ec2 describe-images \
--owners self \
--query "Images[?DeprecationTime!=null].ImageId" \
--output text
```
O seguinte é um exemplo de saída.
```
ami-0abcdef1234567890
```
**Para descrever a data de descontinuação de uma AMI**
Use o seguinte comando [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html). Se `DeprecationTime` não estiver presente na saída, a AMI não será descontinuada nem será definida para descontinuação em uma data futura.
```
aws ec2 describe-images \
--image-ids ami-0abcdef1234567890 \
--query Images[].DeprecationTime \
--output text
```
O seguinte é um exemplo de saída.
```
2025-05-01T00:00:00.000Z
```
------
#### [ PowerShell ]
**Para listar as AMIs descontinuadas da sua conta**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
(Get-EC2Image -Owner self | Where-Object {$_.DeprecationTime -ne $null}).ImageId
```
O seguinte é um exemplo de saída.
```
ami-0abcdef1234567890
```
**Para descrever a data de descontinuação de uma AMI**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html). Se `DeprecationTime` não estiver presente na saída, a AMI não será descontinuada nem será definida para descontinuação em uma data futura.
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).DeprecationTime
```
O seguinte é um exemplo de saída.
```
2025-05-01T00:00:00.000Z
```
------
## Cancelar a descontinuação da AMI
É possível cancelar a descontinuação de uma AMI, o que remove a data e a hora de descontinuação. É necessário ser o proprietário da AMI para executar esse procedimento.
------
#### [ Console ]
**Para cancelar a descontinuação de uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No navegador à esquerda, escolha **AMIs**.
1. Na barra de filtros, escolha **Owned by me** (Sou proprietário).
1. Selecione a AMI e escolha **Actions** (Ações), **Manage AMI Deprecation** (Gerenciar descontinuação da AMI). É possível selecionar várias AMIs para cancelar a descontinuação de várias AMIs de uma só vez.
1. Desmarque a caixa de seleção **Habilitar** e escolha **Salvar**.
------
#### [ AWS CLI ]
**Para cancelar a descontinuação de uma AMI**
Use o seguinte comando [disnable-image-deprecation](https://docs.aws.amazon.com/cli/latest/reference/ec2/disable-image-deprecation.html).
```
aws ec2 disable-image-deprecation --image-id ami-0abcdef1234567890
```
------
#### [ PowerShell ]
**Para cancelar a descontinuação de uma AMI**
Use o cmdlet [Disable-EC2ImageDeprecation](https://docs.aws.amazon.com/powershell/latest/reference/items/Disable-EC2ImageDeprecation.html).
```
Disable-EC2ImageDeprecation -ImageId ami-0abcdef1234567890
```
------
# Desabilitar uma AMI do Amazon EC2
Você pode desabilitar uma AMI para evitar que ela seja usada em execuções de instâncias. Não é possível executar novas instâncias por meio de uma AMI desabilitada. Você pode reabilitar uma AMI desabilitada para que ela possa ser usada novamente em execuções de instâncias.
É possível desabilitar AMIs privadas e públicas.
Para reduzir os custos de armazenamento de AMIs baseadas no EBS desabilitadas, que são usadas raramente, mas que precisam ser retidas a longo prazo, você pode arquivar os snapshots a elas associados. Para obter mais informações, consulte [Arquivar snapshots do Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EC2*.
**Topics**
+ [Como funciona a desabilitação de AMI](#how-disable-ami-works)
+ [Custos](#ami-disable-costs)
+ [Pré-requisitos](#ami-disable-prerequisites)
+ [Permissões obrigatórias do IAM](#ami-disable-iam-permissions)
+ [Desabilitar uma AMI](#disable-ami)
+ [Descrever AMIs desabilitadas](#describe-disabled-ami)
+ [Reabilitar uma AMI desabilitada](#re-enable-a-disabled-ami)
## Como funciona a desabilitação de AMI
**Atenção**
Ao desabilitar uma AMI, todas as permissões de execução são removidas.
**Quando uma AMI é desabilitada:**
+ O estado da AMI muda para `disabled`.
+ Uma AMI desabilitada não pode ser compartilhada. Se uma AMI era pública ou compartilhada, ela se tornará privada. Se uma AMI era compartilhada com uma Conta da AWS, organização ou unidade organizacional, elas perderão o acesso à AMI desabilitada.
+ Por padrão, uma AMI desabilitada não é exibida nas chamadas da API [https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html).
+ Uma AMI desabilitada não é exibida no filtro **De minha propriedade** do console. Para encontrar AMIs desabilitadas, use o filtro **Imagens desabilitadas** do console.
+ Não é possível selecionar uma AMI desabilitada para execuções de instâncias no console do EC2. Por exemplo, uma AMI desabilitada não é exibida no catálogo de AMIs do assistente de execução da instância nem ao criar um modelo de execução.
+ Os serviços de execução, como modelos de execução e grupos do Auto Scaling, podem continuar fazendo referência a AMIs desabilitadas. As execuções subsequentes de instâncias com base em uma AMI desabilitada vão falhar. Por isso, recomendamos atualizar os modelos de execução e os grupos do Auto Scaling para fazer referência somente às AMIs disponíveis.
+ As instâncias do EC2 que eram executadas usando uma AMI que mais tarde foi desabilitada não serão afetadas e poderão ser interrompidas, iniciadas e reinicializadas.
+ Não é possível excluir snapshots associados a AMIs desabilitadas. Tentar excluir um snapshot associado resulta no erro `snapshot is currently in use`.
**Quando uma AMI é reabilitada:**
+ O estado da AMI muda para `available`, e ela pode ser usada para executar instâncias.
+ A AMI pode ser compartilhada.
+ Contas da AWS, organizações e unidades organizacionais que perderam o acesso à AMI quando ela foi desabilitada não recuperam o acesso automaticamente, mas a AMI pode ser compartilhada com elas de novo.
## Custos
Quando você desabilita uma AMI, ela não é excluída. Se a AMI for uma AMI baseada no EBS, você continua pagando pelos snapshots do EBS da AMI. Se você quiser manter a AMI, talvez consiga reduzir os custos de armazenamento arquivando os snapshots. Para obter mais informações, consulte [Arquivar snapshots do Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/snapshot-archive.html) no *Guia do usuário do Amazon EC2*. Se não quiser manter a AMI e seus snapshots, é preciso cancelar o registro da AMI e excluir os snapshots. Para obter mais informações, consulte [Cancelar o registro de uma AMI](deregister-ami.md).
## Pré-requisitos
Para desabilitar ou reabilitar uma AMI, é preciso ser o proprietário da AMI.
## Permissões obrigatórias do IAM
Para desabilitar e reabilitar uma AMI, é necessário ter as seguintes permissões do IAM:
+ `ec2:DisableImage`
+ `ec2:EnableImage`
## Desabilitar uma AMI
Você pode desabilitar uma AMI usando o console do EC2 ou a AWS Command Line Interface (AWS CLI). É necessário ser o proprietário da AMI para executar esse procedimento.
------
#### [ Console ]
**Desabilitar uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação à esquerda, selecione **AMIs**.
1. Na barra de filtros, escolha **Owned by me** (Sou proprietário).
1. Selecione a AMI e escolha **Ações**, **Desativar a AMI**. É possível selecionar várias AMIs para serem desabilitadas de uma vez.
1. Na janela **Desativar AMI**, escolha **Desativar AMI**.
------
#### [ AWS CLI ]
**Desabilitar uma AMI**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/disable-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/disable-image.html):
```
aws ec2 disable-image --image-id ami-0abcdef1234567890
```
------
#### [ PowerShell ]
**Desabilitar uma AMI**
Use o cmdlet [Disable-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Disable-EC2Image.html).
```
Disable-EC2Image -ImageId ami-0abcdef1234567890
```
------
## Descrever AMIs desabilitadas
É possível visualizar as AMIs desabilitadas no console do EC2 usando a AWS CLI.
Você precisa ser o proprietário da AMI para ver as AMIs desabilitadas. Como as AMIs desabilitadas se tornam privadas, você não poderá ver as AMIs desabilitadas se não for o proprietário.
------
#### [ Console ]
**Visualizar AMIs desabilitadas**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação à esquerda, selecione **AMIs**.
1. Na barra de filtro, escolha **Imagens desabilitadas**.
![\[O filtro de imagens desabilitado.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/ami-filter-by-disabled-images.png)
------
#### [ AWS CLI ]
Por padrão, quando você descreve todas as AMIs, as AMIs desabilitadas não são incluídas nos resultados. Para incluir AMIs desabilitadas nos resultados, especifique a opção `--include-disabled`. O campo `State` para uma AMI será `disabled` se a AMI estiver desabilitada.
**Para incluir as AMIs desabilitadas ao descrever todas as AMIs de uma conta**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html):
```
aws ec2 describe-images \
--owners 123456789012 \
--include-disabled
```
**Para listar as AMIs desabilitadas da sua conta**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html):
```
aws ec2 describe-images \
--owners self \
--include-disabled \
--filters Name=state,Values=disabled \
--query Images[].ImageId \
--output text
```
O seguinte é um exemplo de saída.
```
ami-0abcdef1234567890
```
**Para descrever o status de uma AMI**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html): Se `DeprecationTime` não estiver presente na saída, a AMI não será descontinuada nem será definida para descontinuação em uma data futura.
```
aws ec2 describe-images \
--image-ids ami-0abcdef1234567890 \
--query Images[].State \
--output text
```
O seguinte é um exemplo de saída.
```
disabled
```
------
#### [ PowerShell ]
Por padrão, quando você descreve todas as AMIs, as AMIs desabilitadas não são incluídas nos resultados. Para incluir AMIs desabilitadas nos resultados, é necessário especificar o parâmetro `-IncludeDisabled`. O campo `State` para uma AMI será `disabled` se a AMI estiver desabilitada.
**Para listar as AMIs desabilitadas da sua conta**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
(Get-EC2Image `
-Owner self `
-IncludeDisabled $true | Where-Object {$_.State -eq "disabled"}).ImageId
```
O seguinte é um exemplo de saída.
```
ami-0abcdef1234567890
```
**Para descrever o status de uma AMI**
Use o cmdlet [Get-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2Image.html).
```
(Get-EC2Image -ImageId ami-0abcdef1234567890).State.Value
```
O seguinte é um exemplo de saída.
```
disabled
```
------
## Reabilitar uma AMI desabilitada
Você pode reabilitar uma AMI desabilitada. É necessário ser o proprietário da AMI para executar esse procedimento.
------
#### [ Console ]
**Reabilitar uma AMI desabilitada**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação à esquerda, selecione **AMIs**.
1. Na barra de filtro, escolha **Imagens desabilitadas**.
1. Selecione a AMI e escolha **Ações**, **Habilitar a AMI**. É possível selecionar várias AMIs para reabilitá-las ao mesmo tempo.
1. Na janela **Habilitar AMI**, escolha **Habilitar**.
------
#### [ AWS CLI ]
**Reabilitar uma AMI desabilitada**
Use o seguinte comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/enable-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/enable-image.html):
```
aws ec2 enable-image --image-id ami-0abcdef1234567890
```
------
#### [ PowerShell ]
**Reabilitar uma AMI desabilitada**
Use o cmdlet [Enable-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Enable-EC2Image.html).
```
Enable-EC2Image -ImageId ami-0abcdef1234567890
```
------
# Cancelar o registro de uma AMI do Amazon EC2
Quando você cancela o registro de uma AMI, o Amazon EC2 a exclui permanentemente. Depois de cancelar o registro de uma AMI, você não poderá usá-la para executar novas instâncias. Considere cancelar o registro de uma AMI quando não pretender mais usá-la.
Para se proteger contra o cancelamento acidental ou mal-intencionado de uma AMI, é possível ativar a [proteção contra cancelamento de registro](ami-deregistration-protection.md). Se você cancelar acidentalmente o registro de uma AMI baseada no EBS, poderá usar a [Lixeira](https://docs.aws.amazon.com/ebs/latest/userguide/recycle-bin.html) para restaurá-la somente se o fizer dentro do período de tempo permitido antes que ela seja excluída permanentemente.
Ao cancelar o registro de uma AMI, é possível excluir ao mesmo tempo os snapshots associados. No entanto, se um snapshot estiver associado a várias AMIs, ele não será excluído, mesmo se especificado para exclusão, mas o registro da AMI ainda será cancelado. Qualquer snapshot não excluído continuará a gerar custos de armazenamento.
O cancelamento do registro de uma AMI não afetará nenhuma instância que já tenha sido iniciada pela AMI. Essas instâncias poderão continuar sendo usadas. Por padrão, o cancelamento do registro de uma AMI também não afeta os snapshots criados durante o processo de criação da AMI. Você continuará incorrendo em custos de uso para essas instâncias e em custos de armazenamento para os snapshots. Assim, para evitar incorrer em custos extras, recomendamos encerrar quaisquer instâncias e excluir quaisquer snapshots desnecessários. É possível excluir os snapshots automaticamente durante o cancelamento do registro ou manualmente após o cancelamento do registro. Para obter mais informações, consulte [Evite custos com recursos não utilizados](#delete-unneeded-resources-to-avoid-unnecessary-costs).
Para instâncias iniciadas a partir de uma AMI cujo registro é posteriormente cancelado, você ainda pode visualizar algumas informações de alto nível sobre a AMI usando o comando `describe-instance-image-metadata` AWS CLI. Para obter mais informações, consulte [describe-instance-image-metadata](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-image-metadata.html).
**Topics**
+ [Considerações](#deregister-ami-considerations)
+ [Cancelar o registro de uma AMI](#deregister-an-ami)
+ [Evite custos com recursos não utilizados](#delete-unneeded-resources-to-avoid-unnecessary-costs)
+ [Proteger uma AMI do Amazon EC2 de cancelamento de registro](ami-deregistration-protection.md)
## Considerações
+ Você não pode cancelar o registro de uma AMI que não pertença à sua conta.
+ Você não pode cancelar o registro de uma AMI gerenciada pelo serviço AWS Backup usando o Amazon EC2. Em vez disso, use o AWS Backup para excluir os pontos de recuperação correspondentes no cofre de backup. Para obter mais informações, consulte [Exclusão de namespaces](https://docs.aws.amazon.com/aws-backup/latest/devguide/deleting-backups.html) no *Guia do desenvolvedor do AWS Backup*.
## Cancelar o registro de uma AMI
É possível cancelar o registro de AMIs baseadas no EBS e de AMIs baseadas no Amazon S3. Para AMIs baseadas em EBS, é possível excluir ao mesmo tempo os snapshots associados. No entanto, se um snapshot estiver associado a outras AMIs, ele não será excluído, mesmo se especificado para exclusão.
------
#### [ Console ]
**Para cancelar o registro de uma AMI**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Na barra de filtros, escolha **Pertencentes a mim** para listar suas AMIs disponíveis ou escolha **Imagens desabilitadas** para listar suas AMIs desabilitadas.
1. Selecione a AMI para cancelar o registro.
1. Escolha **Actions** (Ações) e **Deregister AMI** (Cancelar registro da AMI).
1. (Opcional) Para excluir os snapshots associados durante o cancelamento do registro, marque a caixa de seleção **Excluir snapshots associados**.
**nota**
Se um snapshot estiver associado a outras AMIs, ele não será excluído mesmo se a caixa de seleção estiver marcada.
1. Escolha **Cancelar registro da AMI**.
A remoção da AMI da lista pelo console pode demorar alguns minutos. Escolha **Refresh (Atualizar)** para atualizar o status.
------
#### [ AWS CLI ]
**Para cancelar o registro de uma AMI**
Use o seguinte comando [deregister-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/deregister-image.html).
```
aws ec2 deregister-image --image-id ami-0abcdef1234567890
```
**Para cancelar o registro de uma AMI e excluir seus snapshots associados**
Use o comando [deregister-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/deregister-image.html) a seguir e especifique o parâmetro `--delete-associated-snapshots`. Observe que, se um snapshot estiver associado a outras AMIs, ele não será excluído, mesmo que você especifique esse parâmetro.
```
aws ec2 deregister-image \
--image-id ami-0abcdef1234567890 \
--delete-associated-snapshots
```
------
#### [ PowerShell ]
**Para cancelar o registro de uma AMI**
Use o cmdlet [Unregister-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Unregister-EC2Image.html).
```
Unregister-EC2Image -ImageId ami-0abcdef1234567890
```
**Para cancelar o registro de uma AMI e excluir seus snapshots associados**
Use o cmdlet [Unregister-EC2Image](https://docs.aws.amazon.com/powershell/latest/reference/items/Unregister-EC2Image.html) e especifique o parâmetro `-DeleteAssociatedSnapshots`. Observe que, se um snapshot estiver associado a outras AMIs, ele não será excluído, mesmo que você especifique esse parâmetro.
```
Unregister-EC2Image `
-ImageId ami-0abcdef1234567890 `
-DeleteAssociatedSnapshots
```
------
## Evite custos com recursos não utilizados
O cancelamento do registro de uma AMI não exclui, por padrão, todos os recursos associados a ela. Esses recursos incluem os snapshots das AMIs baseadas no EBS e os arquivos armazenados no Amazon S3 das AMIs baseadas no Amazon S3. Quando o registro de uma AMI for cancelado, isso não encerrará nem interromperá nenhuma instância já iniciada via AMI.
Você continuará incorrendo em custos para armazenar os snapshots e os arquivos, e incorrerá em custos para qualquer instância em execução.
Para evitar incorrer nestes tipos de custos extras, recomendamos excluir quaisquer recursos desnecessários.
**AMIs apoiadas pelo EBS**
+ Exclua os snapshots associados ao mesmo tempo que cancela o registro da AMI. Para obter mais informações, consulte [Cancelar o registro de uma AMI](#deregister-an-ami).
+ Se você cancelar o registro de uma AMI sem excluir seus snapshots associados, você poderá [excluir os snapshots](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-deleting-snapshot.html#ebs-delete-snapshot) manualmente. O snapshot do volume raiz da instância criado durante a criação da AMI tem o seguinte formato de descrição:
```
Created by CreateImage(i-1234567890abcdef0) for ami-0abcdef1234567890
```
+ Se você não precisar mais das instâncias que foram inicializadas pela AMI, poderá [interrompê-las](Stop_Start.md#starting-stopping-instances) ou [encerrá-las](terminating-instances.md#terminating-instances-console). Para listar as instâncias, filtre pelo ID da AMI.
**AMIs baseadas no Amazon S3**
+ Exclua o pacote no Amazon S3 usando o comando [ec2-delete-bundle](ami-tools-commands.md#ami-delete-bundle) (ferramentas de AMI).
+ Se o bucket do Amazon S3 estiver vazio após a exclusão do pacote e você não tiver mais finalidade para esse bucket, você poderá [excluir](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) o bucket.
+ Se você não precisar mais das instâncias que foram inicializadas pela AMI, poderá [encerrá-las](terminating-instances.md#terminating-instances-console). Para listar as instâncias, filtre pelo ID da AMI.
# Proteger uma AMI do Amazon EC2 de cancelamento de registro
É possível ativar a *proteção contra cancelamento de registro* em uma AMI para evitar exclusão acidental ou mal-intencionada. Quando a proteção contra cancelamento do registro estiver ativada, o registro da AMI não poderá ser cancelado por nenhum usuário, independente das permissões do IAM de cada um. Para cancelar o registro da AMI, desative primeiro a proteção contra cancelamento de registro na AMI.
Ao ativar a proteção contra cancelamento de registro em uma AMI, você terá a opção de incluir um período de espera de 24 horas. Esse período de espera é o tempo durante o qual a proteção contra cancelamento de registro permanece em vigor após você desativá-la. Durante esse período de espera, o registro da AMI não poderá ser cancelado. Quando o período de espera terminar, o registro da AMI poderá ser cancelado.
A proteção contra cancelamento de registro é desativada por padrão em todas as AMI novas e existentes.
## Ativar a proteção contra cancelamento do registro
Use os procedimentos a seguir para ativar a proteção contra cancelamento de registro.
------
#### [ Console ]
**Para ativar a proteção contra cancelamento do registro**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Na barra de filtros, escolha **Pertencentes a mim** para listar suas AMIs disponíveis ou escolha **Imagens desabilitadas** para listar suas AMIs desabilitadas.
1. Selecione a AMI na qual você deseja ativar a proteção contra cancelamento de registro e, em seguida, escolha **Ações**, **Gerenciar proteção contra cancelamento de registro da AMI**.
1. Na caixa de diálogo **Gerenciar proteção contra cancelamento de registro da AMI**, é possível ativar a proteção contra cancelamento de registro com ou sem um período de espera. Escolha uma das seguintes opções:
+ **Habilitar com período de espera de 24 horas**: com um período de espera, o registro da AMI não poderá ser cancelado por 24 horas quando a proteção de cancelamento de registro estiver desativada.
+ **Habilitar sem período de espera**: sem um período de espera, o registro da AMI poderá ser cancelado imediatamente quando a proteção contra cancelamento de registro estiver desativada.
1. Selecione **Salvar**.
------
#### [ AWS CLI ]
**Para ativar a proteção contra cancelamento do registro**
Use o comando [enable-image-deregistration-protection](https://docs.aws.amazon.com/cli/latest/reference/ec2/enable-image-deregistration-protection.html). Para habilitar o período de espera opcional, inclua a opção `--with-cooldown`.
```
aws ec2 enable-image-deregistration-protection \
--image-id ami-0abcdef1234567890 \
--with-cooldown
```
------
#### [ PowerShell ]
**Para ativar a proteção contra cancelamento do registro**
Use o cmdlet [Enable-EC2ImageDeregistrationProtection](https://docs.aws.amazon.com/powershell/latest/reference/items/Enable-EC2ImageDeregistrationProtection.html). Para habilitar o período de espera opcional, defina o parâmetro `-WithCooldown` como `true`.
```
Enable-EC2ImageDeregistrationProtection `
-ImageId ami-0abcdef1234567890 `
-WithCooldown $true
```
------
## Desativar a proteção contra cancelamento do registro
Use os procedimentos a seguir para desativar a proteção contra cancelamento de registro.
Se você optou por incluir um período de espera de 24 horas ao ativar a proteção contra cancelamento de registro para a AMI, quando a proteção contra cancelamento de registro for desativada, o registro da AMI não poderá ser cancelado imediatamente. Esse período de espera é o período de 24 horas durante o qual a proteção contra cancelamento de registro permanece em vigor após você desativá-la. Durante esse período de espera, o registro da AMI não poderá ser cancelado. Quando o período de espera terminar, o registro da AMI poderá ser cancelado.
------
#### [ Console ]
**Para desativar a proteção contra cancelamento do registro**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **AMIs**.
1. Na barra de filtros, escolha **Pertencentes a mim** para listar suas AMIs disponíveis ou escolha **Imagens desabilitadas** para listar suas AMIs desabilitadas.
1. Selecione a AMI na qual você deseja desativar a proteção contra cancelamento de registro e, em seguida, escolha **Ações**, **Gerenciar proteção contra cancelamento de registro da AMI**.
1. Na caixa de diálogo **Gerenciar proteção contra cancelamento de registro da AMI**, escolha **Desabilitar**.
1. Escolha **Salvar**.
------
#### [ AWS CLI ]
**Para desativar a proteção contra cancelamento do registro**
Use o comando [disnable-image-deregistration-protection](https://docs.aws.amazon.com/cli/latest/reference/ec2/disable-image-deregistration-protection.html).
```
aws ec2 disable-image-deregistration-protection --image-id ami-0abcdef1234567890
```
------
#### [ PowerShell ]
**Para desativar a proteção contra cancelamento do registro**
Use o cmdlet [Disable-EC2ImageDeregistrationProtection](https://docs.aws.amazon.com/powershell/latest/reference/items/Disable-EC2ImageDeregistrationProtection.html).
```
Disable-EC2ImageDeregistrationProtection -ImageId ami-0abcdef1234567890
```
------