As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usando instâncias de computação EC2 compatíveis com a Amazon no Snowball Edge
Você pode executar instâncias computacionais EC2 compatíveis com a Amazon hospedadas em um Snowball Edge com os tipos de instância `sbe1``sbe-c`, e. `sbe-g` O tipo de instância `sbe1` funciona em dispositivos com a opção Snowball Edge otimizado para armazenamento. O tipo de instância `sbe-c` funciona em dispositivos com a opção Snowball Edge otimizado para computação. Para obter uma lista dos tipos de instâncias compatíveis, consulte [Cotas para instâncias de computação em um dispositivo Snowball Edge](ec2-edge-limits.md).
Todos os três tipos de instância de computação compatíveis para uso em um dispositivo Snowball Edge são exclusivos para dispositivos Snowball Edge. Como suas contrapartes baseadas em nuvem, essas instâncias exigem que o Amazon Machine Images (AMIs) seja iniciado. Selecione a AMI para ser a imagem base para uma instância na nuvem, antes de criar o trabalho do Snowball Edge.
Para usar uma instância de computação em um Snowball Edge, crie um trabalho para solicitar um dispositivo Snowball Edge e especifique seu. AMIs Você pode fazer isso usando o [Console de Gerenciamento da família AWS Snow](https://console.aws.amazon.com/snowfamily/home) AWS CLI, o ou um dos AWS SDKs. Normalmente, há alguns pré-requisitos de manutenção que devem ser executados antes da criação do trabalho para usar as instâncias.
Depois que seu dispositivo chegar, você poderá começar a gerenciar suas instâncias AMIs e. Você pode gerenciar suas instâncias computacionais em um Snowball Edge por meio de um endpoint compatível com a EC2 Amazon. Esse tipo de endpoint suporta muitos dos comandos e ações da EC2 CLI compatíveis com a Amazon para o. AWS SDKs Você não pode usar o Console de gerenciamento da AWS on the Snowball Edge para gerenciar suas instâncias AMIs e de computação.
Quando terminar de usar seu dispositivo, devolva-o para AWS. Se o dispositivo tiver sido usado em um trabalho de importação, os dados transferidos usando o adaptador do Amazon S3 ou a interface NFS serão importados para o Amazon S3. Caso contrário, apagaremos completamente o dispositivo quando ele for devolvido. AWS Esse apagamento segue os padrões 800-88 do Instituto Nacional de Padrões e Tecnologia (NIST).
**Importante**
Não há suporte para o uso de criptografia AMIs em dispositivos Snowball Edge Edge.
Os dados em instâncias computacionais executadas em um Snowball Edge não são importados para o. AWS
**Topics**
+ [Diferença entre a Amazon EC2 e as instâncias EC2 compatíveis com a Amazon no Snowball Edge](#ec2-compatible-sbe)
+ [Preços de instâncias de computação no Snowball Edge](#pricing-for-ec2-edge)
+ [Usando uma AMI EC2 compatível com a Amazon no Snowball Edge](using-ami.md)
+ [Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge](ec2-ami-import-cli.md)
+ [Usando as operações de API AWS CLI e no dispositivo Snowball Edge](using-ec2-cli-specify-region.md)
+ [Configurações de rede para instâncias de computação no Snowball Edge](network-config-ec2.md)
+ [Usando SSH para se conectar a instâncias de computação em um Snowball Edge](ssh-ec2-edge.md)
+ [Transferência de dados de instâncias computacionais EC2 compatíveis para buckets do S3 no mesmo Snowball Edge](data-transfer-ec2-s3-edge.md)
+ [Iniciando instâncias EC2 compatíveis automaticamente](using-ec2-edge-client.md)
+ [Usando o endpoint EC2 compatível com a Amazon em um Snowball Edge](using-ec2-endpoint.md)
+ [Instâncias EC2 compatíveis com inicialização automática com modelos de execução em um Snowball Edge](ec2-autostart.md)
+ [Usando o Instance Metadata Service for Snow com instâncias EC2 compatíveis com a Amazon em um Snowball Edge](imds.md)
+ [Usando o armazenamento em bloco com instâncias EC2 compatíveis com a Amazon no Snowball Edge](edge-ebs.md)
+ [Controle do tráfego de rede com grupos de segurança no Snowball Edge](edge-security-groups.md)
+ [Metadados EC2 de instância e dados do usuário compatíveis com suporte no Snowball Edge](edge-compute-instance-metadata.md)
+ [EC2Interrompendo a execução de instâncias compatíveis no Snowball Edge](#managing-ec2-instances)
## Diferença entre a Amazon EC2 e as instâncias EC2 compatíveis com a Amazon no Snowball Edge
AWS As instâncias EC2 compatíveis com o Snowball Edge permitem que os clientes usem e gerenciem instâncias EC2 compatíveis com a Amazon usando um subconjunto e um subconjunto de EC2 APIs . AMIs
## Preços de instâncias de computação no Snowball Edge
Existem custos adicionais associados ao uso de instâncias de computação. Para obter mais informações, consulte [AWS Snowball Edge Preço](https://aws.amazon.com/snowball-edge/pricing).
# Usando uma AMI EC2 compatível com a Amazon no Snowball Edge
Para usar uma Amazon Machine Image (AMI) em seu dispositivo AWS Snowball Edge, você deve primeiro adicioná-la ao dispositivo. É possível adicionar uma AMI das seguintes maneiras:
+ Faça upload da AMI ao fazer o pedido do dispositivo.
+ Adicione a AMI quando o dispositivo chegar ao local.
As instâncias de EC2 computação da Amazon que vêm com o Snowball Edge são lançadas com base na EC2 AMIs Amazon que você adiciona ao seu dispositivo. EC2Compatível com a Amazon, AMIs suporta os sistemas operacionais Linux e Microsoft Windows.
**Linux**
Os seguintes sistemas operacionais Linux são compatíveis:
+ [Amazon Linux 2 para Snowball Edge](https://aws.amazon.com/marketplace/pp/B08Q76DLTM/ )
**nota**
A versão mais recente dessa AMI será fornecida no momento em que seu Snowball Edge estiver sendo preparado para ser enviado. AWS Para determinar a versão dessa AMI no dispositivo no recebimento, consulte [Determinando a versão do Amazon Linux 2 AMI para Snowball Edge](#snow-al-version).
+ [CentOS 7 (x86\$164): com atualizações HVM](https://aws.amazon.com/marketplace/pp/B00O7WM7QW)
+ Ubuntu 16.04 LTS: Xenial (HVM)
**nota**
Ubuntu 16.04 LTS - As imagens Xenial (HVM) não são mais suportadas no AWS Marketplace, mas ainda são suportadas para uso em dispositivos Snowball Edge por meio da Amazon VM e executadas localmente em. EC2 Import/Export AMIs
+ [Ubuntu 20.04 LTS: Focal](https://aws.amazon.com/marketplace/pp/prodview-iftkyuwv2sjxi)
+ [Ubuntu 22.04 LTS: Jammy](https://aws.amazon.com/marketplace/pp/prodview-f2if34z3a4e3i)
Como melhor prática de segurança, mantenha seu Amazon Linux 2 AMIs up-to-date no Snowball Edge à medida que novos Amazon Linux AMIs 2 forem lançados. Consulte [Atualizando seu Amazon Linux 2 AMIs no Snowball Edge](update-ami.md).
**Windows**
Os seguintes sistemas operacionais Windows são compatíveis:
+ Windows Server 2012 R2
+ Windows Server 2016
+ Windows Server 2019
Você pode adicionar o Windows AMIs ao seu dispositivo importando a imagem da máquina virtual (VM) do Windows para AWS usar o VM Import/Export. Também é possível importar a imagem para o dispositivo logo após a implantação dele no local. Para obter mais informações, consulte [Adicionando uma AMI do Microsoft Windows a um Snowball Edge](#windows-ami).
**nota**
O Windows AMIs originado em não AWS pode ser adicionado ao seu dispositivo.
AMIs importado localmente deve estar no modo de inicialização do BIOS, pois o UEFI não é suportado.
O Snowball Edge é compatível com o modelo Bring Your Own License (BYOL). Para obter mais informações, consulte [Adicionando uma AMI do Microsoft Windows a um Snowball Edge](#windows-ami).
**nota**
AWS As instâncias EC2 compatíveis com o Snowball Edge permitem que os clientes usem e gerenciem instâncias EC2 compatíveis com a Amazon usando um subconjunto e um subconjunto de EC2 APIs . AMIs
**Topics**
+ [Adicionar uma AMI ao criar um trabalho para solicitar um Snowball Edge](#add-ami-order)
+ [Adicionando uma AMI de AWS Marketplace a um Snowball Edge](#add-marketplace-ami)
+ [Adicionar uma AMI a um Snowball Edge depois de receber o dispositivo](#add-ami-locally)
+ [Adicionando uma AMI do Microsoft Windows a um Snowball Edge](#windows-ami)
+ [Importação de uma imagem de VM para um Snowball Edge](#import-vm-image)
+ [Exportação da AMI mais recente do Amazon Linux 2 para um Snowball Edge](#export-latest-al2-ami)
## Adicionar uma AMI ao criar um trabalho para solicitar um Snowball Edge
Ao fazer o pedido do dispositivo, você pode adicioná-lo AMIs ao dispositivo escolhendo-os na seção **Computar usando EC2 instâncias - opcional** no Console de Gerenciamento da família AWS Snow. O **recurso Compute using EC2 instances - opcional** lista tudo o AMIs que pode ser carregado em seu dispositivo. Eles AMIs se enquadram nas seguintes categorias:
+ **AMIs do AWS Marketplace** — Eles são AMIs criados a partir da lista de compatíveis AMIs. Para obter informações sobre a criação de uma AMI a partir AMIs do suporte do AWS Marketplace, consulte[Adicionando uma AMI de AWS Marketplace a um Snowball Edge](#add-marketplace-ami).
+ **AMIs carregado usando o VM Import/Export** — Quando você faz o pedido do seu dispositivo, os AMIs que foram carregados usando a VM Import/Export são listados no console. *Para obter mais informações, consulte [Importando uma VM como imagem usando o VM Import/Export no Guia do usuário da VM](https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html). Import/Export * Para obter informações sobre ambientes de virtualização compatíveis, consulte [VM Import/Export Requirements](https://docs.aws.amazon.com/vm-import/latest/userguide/vmie_prereqs.html).
## Adicionando uma AMI de AWS Marketplace a um Snowball Edge
Você pode adicionar vários AMIs AWS Marketplace ao seu dispositivo Snowball Edge iniciando a AWS Marketplace instância, criando uma AMI a partir dela e configurando a AMI na mesma região na qual você solicitará o dispositivo Snow. Depois, é possível optar por incluir a AMI no dispositivo na criação de um trabalho para solicitar o dispositivo. Ao escolher uma AMI no Marketplace, assegure-se de que ela tenha um código de produto e uma plataforma compatíveis.
**Topics**
+ [Verificando códigos de produto e detalhes da plataforma do AWS Marketplace AMIs Snowball Edge](#check-marketplace-ami-codes-snb)
+ [Determinando a versão do Amazon Linux 2 AMI para Snowball Edge](#snow-al-version)
+ [Configurar a AMI para o dispositivo Snowball Edge](#configure-ami-snow-device)
### Verificando códigos de produto e detalhes da plataforma do AWS Marketplace AMIs Snowball Edge
Antes de começar o processo de adição de uma AMI AWS Marketplace ao seu dispositivo Snowball Edge, certifique-se de que o código do produto e os detalhes da plataforma da AMI sejam compatíveis com seu. Região da AWS
1. Abra o EC2 console da Amazon em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na barra de navegação, selecione a região na qual iniciar suas instâncias e a partir da qual você criará o trabalho para solicitar o dispositivo Snowball Edge. Selecione qualquer região que estiver disponível para você, independentemente do local.
1. No painel de navegação, escolha **AMIs**.
1. Use as opções de filtro e pesquisa para definir o escopo da lista exibida e AMIs ver somente as AMIs que correspondem aos seus critérios. Por exemplo, AMIs fornecido pelo AWS Marketplace, escolha **Imagens públicas**. Em seguida, use as opções de pesquisa para ampliar ainda mais a lista de exibidas AMIs:
+ (Novo console) Escolha a barra **Pesquisar** e, no menu, escolha **Alias do proprietário**, depois o operador = e o valor **amazon**.
+ (Console antigo) Escolha a barra **Search** (Pesquisar) e, no menu, escolha **Owner** (Proprietário) e o valor **Amazon images** (Imagens da Amazon).
**nota**
AMIs de AWS Marketplace incluir **aws-marketplace** na coluna **Fonte**.
1. Na coluna **ID da AMI**, escolha o ID da AMI.
1. No **Resumo da imagem** da AMI, verifique se os **Códigos de produtos** são aceitos na região. Para ter mais informações, consulte a tabela a seguir.
**Códigos de produto AWS Marketplace AMI compatíveis**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/snowball/latest/developer-guide/using-ami.html)
1. Depois, assegure-se também de que **Detalhes da plataforma** contenha uma das entradas da lista abaixo.
+ Amazon Linux, Ubuntu ou Debian
+ Red Hat Linux bring-your-own-license
+ Amazon RDS for Oracle bring-your-own-license
+ Janelas bring-your-own-license
### Determinando a versão do Amazon Linux 2 AMI para Snowball Edge
Use o procedimento a seguir para determinar a versão do Amazon Linux 2 AMI para o Snowball Edge no Snowball Edge. Instale a versão mais recente do AWS CLI antes de continuar. Para obter mais informações, consulte [Instalar ou atualizar para a versão mais recente do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) no Guia AWS Command Line Interface do Usuário.
+ Use o `describe-images` AWS CLI comando para ver a descrição da AMI. A versão está contida na descrição. Forneça o certificado de chave pública da etapa anterior. Para obter mais informações, consulte [describe-images](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-images.html) na Referência de Comandos. AWS CLI
```
aws ec2 describe-images --endpoint http://snow-device-ip:8008 --region snow
```
**Example da saída do comando `describe-images`**
```
{
"Images": [
{
"CreationDate": "2024-02-12T23:24:45.705Z",
"ImageId": "s.ami-02ba84cb87224e16e",
"Public": false,
"ProductCodes": [
{
"ProductCodeId": "avyfzznywektkgl5qv5f57ska",
"ProductCodeType": "marketplace"
}
],
"State": "AVAILABLE",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/xvda",
"Ebs": {
"DeleteOnTermination": true,
"Iops": 0,
"SnapshotId": "s.snap-0efb49f2f726fde63",
"VolumeSize": 8,
"VolumeType": "sbp1"
}
}
],
"Description": "Snow Family Amazon Linux 2 AMI 2.0.20240131.0 x86_64 HVM gp2",
"EnaSupport": false,
"Name": "amzn2-ami-snow-family-hvm-2.0.20240131.0-x86_64-gp2-b7e7f8d2-1b9e-4774-a374-120e0cd85d5a",
"RootDeviceName": "/dev/xvda"
}
]
}
```
Neste exemplo, a versão do Amazon Linux 2 AMI para Snowball Edge é. `2.0.20240131.0` Ela é encontrada no valor do nome `Description`.
### Configurar a AMI para o dispositivo Snowball Edge
1. Abra o EC2 console da Amazon em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Execute uma nova instância de uma AMI compatível em AWS Marketplace.
**nota**
Ao iniciar a instância, verifique se o tamanho do armazenamento atribuído à instância é adequado para o caso de uso. No EC2 console da Amazon, você faz isso na etapa **Adicionar armazenamento**.
1. Instale e configure as aplicações que deseja executar no Snowball Edge e teste para verificar se funcionam conforme o esperado.
**Importante**
Somente um único volume AMIs é suportado.
O volume do EBS na AMI deve ter 10 TB ou menos. Recomendamos que você provisione o tamanho do volume do EBS necessário para os dados na AMI. Isso ajudará a diminuir o tempo necessário para exportar a AMI e carregá-la no dispositivo. É possível redimensionar ou adicionar mais volumes à instância após a implantação do dispositivo.
O snapshot do EBS na AMI não deve ser criptografado.
1. Faça uma cópia do arquivo PEM ou PPK utilizado para o par de chaves SSH quando você criou essa instância. Salve esse arquivo no servidor que você planeja usar para se comunicar com o dispositivo Snowball Edge. Anote o caminho para esse arquivo, pois você precisará dele ao usar o SSH para se conectar à instância EC2 compatível com o dispositivo.
**Importante**
Se você não seguir esse procedimento, não poderá se conectar às instâncias com SSH ao receber o dispositivo Snowball Edge.
1. Salve a instância como uma AMI. Para obter mais informações, consulte o [Guia EC2 do usuário da Amazon para instâncias Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) no *Guia EC2 do usuário da Amazon.*
1. Repita as etapas 1 a 4 para cada uma das instâncias às quais você deseja se conectar usando SSH. Certifique-se de fazer cópias de cada um dos pares de chaves SSH e acompanhar aqueles aos AMIs quais eles estão associados.
1. Agora, quando você faz o pedido do seu dispositivo, eles AMIs estão disponíveis para serem adicionados ao seu dispositivo.
## Adicionar uma AMI a um Snowball Edge depois de receber o dispositivo
Quando o dispositivo chegar ao seu site, você poderá adicionar um novo dispositivo AMIs a ele. Para instruções, consulte [Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge](ec2-ami-import-cli.md). Lembre-se de que, embora todos VMs sejam compatíveis, somente os compatíveis AMIs foram testados quanto à funcionalidade completa.
**nota**
Ao usar a VM Import/Export para adicionar AMIs ao seu dispositivo ou importar uma VM após a implantação do dispositivo, você pode adicioná-la usando qualquer VMs sistema operacional. No entanto, somente os sistemas operacionais compatíveis foram testados e validados no Snowball Edge. Você é responsável por cumprir os termos e condições de qualquer sistema operacional ou software que esteja na imagem virtual importada para o dispositivo.
Para que AWS os serviços funcionem adequadamente em um Snowball Edge, você deve permitir as portas dos serviços. Para obter detalhes, consulte [Requisitos de porta para AWS serviços em um Snowball Edge](port-requirements.md).
## Adicionando uma AMI do Microsoft Windows a um Snowball Edge
Para máquinas virtuais (VMs) que usam um sistema operacional Windows compatível, você pode adicionar a AMI importando sua imagem de VM do Windows para AWS usar o VM Import/Export ou importando-a para seu dispositivo diretamente após a implantação em seu site.
**Traga a sua própria licença (BYOL)**
O Snowball Edge oferece suporte à importação do Microsoft AMIs Windows para o seu dispositivo com sua própria licença. Traga sua própria licença (BYOL) é o processo de trazer uma AMI que você possui com sua licença local. AWS AWS fornece opções de implantação compartilhadas e dedicadas para a opção BYOL.
Você pode adicionar sua imagem de VM do Windows ao seu dispositivo importando-a para AWS o VM usando Import/Export ou importando-a para o seu dispositivo diretamente após a implantação no seu site. Você não pode adicionar o Windows AMIs que se originou em AWS. Portanto, você deve criar e importar sua própria imagem de VM do Windows e trazer sua própria licença se quiser usar a AMI em seu dispositivo Snowball Edge. Para obter mais informações sobre o licenciamento do Windows e a opção BYOL, consulte [Amazon Web Services e Microsoft: Perguntas frequentes](https://aws.amazon.com/windows/faq/).
### Criação de uma imagem de VM do Windows para importar para um Snowball Edge
Para criar uma imagem de VM do Windows, você precisa de um ambiente de virtualização, como VirtualBox, que seja compatível com os sistemas operacionais Windows e macOS. Ao criar uma VM para dispositivos Snow, recomendamos alocar pelo menos dois núcleos com 4 GB de RAM, no mínimo. Quando a VM estiver em execução, você deverá instalar o sistema operacional (Windows Server 2012, 2016 ou 2019). Para instalar os drivers necessários para o dispositivo Snowball Edge, siga as instruções nesta seção.
Para que uma AMI do Windows seja executada em um dispositivo Snow, você deve adicionar o VirtIO, o FLR, o NetVCM, o Vioinput, o Viorng, o Vioscsi, o Vioserial e os drivers. VioStor Você pode [baixar um Microsoft Software Installer (virtio-win-guest-tools-installer)](https://github.com/virtio-win/virtio-win-pkg-scripts) para instalar esses drivers em imagens do Windows a partir do virtio-win-pkg-scripts repositório em. GitHub
**nota**
Se você planeja importar a imagem da VM diretamente para o dispositivo Snow implantado, o arquivo de imagem da VM deve estar no formato RAW.
**Como criar uma imagem do Windows**
1. No computador com Microsoft Windows, selecione **Iniciar** e insira **devmgmt.msc** para abrir o **Gerenciador de Dispositivos**.
1. No menu principal, selecione **Ações** e, depois, **Adicionar hardware herdado**.
**nota**
Para o Windows 11, primeiro selecione qualquer dispositivo no painel abaixo antes que a opção **Adicionar hardware antigo** apareça no menu **Ações**.
1. No assistente, selecione **Próximo**.
1. Selecione **Instalar o hardware que eu seleciono manualmente em uma lista (avançado)** e escolha **Próximo**.
1. Selecione **Mostrar todos os dispositivos** e **Próximo**.
1. Selecione **Tenho disco**, abra a lista **Copiar arquivos do fabricante de** e navegue até o arquivo ISO.
1. No arquivo ISO, acesse o diretório `Driver\W2K8R2\amd64` e localize o arquivo `.INF`.
1. Selecione o arquivo **.INF**, selecione **Abrir** e, depois, **OK**.
1. Ao ver o nome do driver, selecione **Próximo** e, depois, **Próximo** mais duas vezes. Em seguida, escolha **Finish (Concluir)**.
Um dispositivo será instalado usando o novo driver. O hardware real não existe, então você verá um ponto de exclamação amarelo que indica um problema no dispositivo. É necessário corrigir esse problema.
**Como corrigir o problema de hardware**
1. Abra o menu de contexto (com botão direito do mouse) do dispositivo que tem o ponto de exclamação.
1. Selecione **Desinstalar**, desmarque **Excluir o software do driver para este dispositivo** e selecione **OK**.
O driver é instalado e estará tudo pronto para iniciar a AMI no dispositivo.
## Importação de uma imagem de VM para um Snowball Edge
Depois de preparar a imagem da VM, é possível usar uma das opções para importar a imagem para o dispositivo.
+ **Na nuvem usando o VM Import/Export** — Quando você importa sua imagem de VM AWS e a registra como uma AMI, você pode adicioná-la ao seu dispositivo ao fazer um pedido no. Console de Gerenciamento da família AWS Snow*Para obter mais informações, consulte [Importando uma VM como imagem usando o VM Import/Export no Guia do usuário da VM](https://docs.aws.amazon.com/vm-import/latest/userguide/vmimport-image-import.html). Import/Export *
+ **Localmente em seu dispositivo que está implantado em seu site** — Você pode importar sua imagem de VM diretamente para o seu dispositivo usando AWS OpsHub ou o AWS Command Line Interface ()AWS CLI.
Para obter informações sobre o uso AWS OpsHub, consulte Como [usar localmente instâncias EC2 de computação compatíveis com a Amazon](https://docs.aws.amazon.com/snowball/latest/developer-guide/manage-ec2.html).
Para obter informações sobre como usar o AWS CLI, consulte[Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge](ec2-ami-import-cli.md).
## Exportação da AMI mais recente do Amazon Linux 2 para um Snowball Edge
Para atualizar seu Amazon Linux 2 AMIs para a versão mais recente, primeiro exporte a imagem de VM mais recente do Amazon Linux 2 e, em seguida AWS Marketplace, importe essa imagem de VM para o dispositivo Snow.
1. Use o `ssm get-parameters` AWS CLI comando para encontrar o ID de imagem mais recente do Amazon Linux 2 AMI no AWS Marketplace.
```
aws ssm get-parameters --names /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2 --query 'Parameters[0].[Value]' --region your-region
```
O comando retorna a ID de imagem mais recente da AMI. Por exemplo, .`ami-0ccb473bada910e74`
1. Exporte a imagem mais recente do Amazon Linux 2. Consulte [Exportação de uma VM diretamente de uma imagem de máquina da Amazon (AMI) no Guia](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html) EC2 do usuário da Amazon. Use o ID de imagem mais recente da AMI do Amazon Linux 2 como o valor do parâmetro `image-id` do comando `ec2 export-image`.
1. Importe a imagem da VM para o dispositivo Snow usando o AWS CLI ou AWS OpsHub.
+ Para obter informações sobre o uso AWS CLI, consulte[Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge](ec2-ami-import-cli.md).
+ Para obter informações sobre o uso AWS OpsHub, consulte[Importar uma imagem como uma EC2 AMI compatível com a Amazon com AWS OpsHub](ec2-ami-import.md).
# Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge
Você pode usar o AWS CLI e o Import/Export serviço de VM para importar uma imagem de máquina virtual (VM) para o dispositivo Snowball Edge como uma Amazon Machine Image (AMI). Depois de importar uma imagem de VM, registre a imagem como uma AMI e inicie-a como uma instância compatível com a Amazon EC2.
Você pode adicionar AMIs da Amazon EC2 ao dispositivo ao criar um trabalho para solicitar um dispositivo Snowball Edge. Use esse procedimento depois de receber o dispositivo Snowball Edge. Para obter mais informações, consulte [Escolher opções de computação e de armazenamento](create-job-common.md#compute-storage).
Você também pode usar AWS OpsHub para carregar o arquivo de imagem da VM. Para obter mais informações, consulte [Importar uma imagem para o seu dispositivo como uma EC2 AMI compatível com a Amazon](https://docs.aws.amazon.com/snowball/latest/developer-guide/manage-ec2.html#ec2-ami-import) neste guia.
**Topics**
+ [Etapa 1: Preparar a imagem da VM e enviá-la para o dispositivo Snowball Edge](#prepare-image-cli)
+ [Etapa 2: Configurar as permissões necessárias no Snowball Edge](#setup-permission-cli)
+ [Etapa 3: importar a imagem da VM como um instantâneo no Snowball Edge](#import-snapshot-cli)
+ [Etapa 4: registrar o snapshot como uma AMI no Snowball Edge](#register-snapshot-cli)
+ [Etapa 5: Executar uma instância da AMI no Snowball Edge](#launch-ami-cli)
+ [Ações adicionais da AMI para um Snowball Edge](#additional-ami-actions)
## Etapa 1: Preparar a imagem da VM e enviá-la para o dispositivo Snowball Edge
Prepare a imagem da VM exportando uma imagem da VM de uma EC2 AMI ou instância da Amazon na VM Nuvem AWS usando ou gerando a imagem da VM Import/Export localmente usando a plataforma de virtualização de sua escolha.
Para exportar uma EC2 instância da Amazon como uma imagem de VM usando o VM Import/Export, consulte [Exportar uma instância como uma VM usando o VM Import/Export no Guia do usuário da VM](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport.html). Import/Export Para exportar uma Amazon EC2 AMI como uma imagem de VM usando o VM Import/Export, consulte [Exportar uma VM diretamente de uma Amazon Machine Image (AMI](https://docs.aws.amazon.com/vm-import/latest/userguide/vmexport_image.html)) no Guia do usuário da VM. Import/Export
Se estiver gerando uma imagem de VM do seu ambiente local, certifique-se de que a imagem esteja configurada para uso como AMI no dispositivo Snowball Edge. Talvez seja necessário configurar os itens a seguir, dependendo do ambiente.
+ Configure e atualize o sistema operacional.
+ Defina um nome do host.
+ O NTP (Network Time Protocol) deverá estar configurado.
+ Inclua chaves públicas SSH, se necessário. Faça cópias locais dos pares de chaves. Para ter mais informações, consulte [Using SSH to Connect to Your Compute Instances on a Snowball Edge](https://docs.aws.amazon.com/snowball/latest/developer-guide/ssh-ec2-edge.html).
+ Instale e configure qualquer software que você usará no dispositivo Snowball Edge.
**nota**
Esteja ciente das seguintes limitações ao preparar um instantâneo de disco para um dispositivo Snowball Edge.
No momento, o Snowball Edge suporta somente a importação de instantâneos que estejam no formato de imagem RAW.
Atualmente, o Snowball Edge só oferece suporte à importação de instantâneos com tamanhos de 1 GB a 1 TB.
### Fazer upload de uma imagem de VM para um bucket do Amazon S3 no dispositivo Snowball Edge
Depois de preparar uma imagem de VM, carregue-a em um bucket do S3 no dispositivo ou cluster Snowball Edge. Você pode usar o adaptador S3 ou o armazenamento compatível com Amazon S3 no Snowball Edge para fazer o upload do snapshot.
**Como fazer upload da imagem de máquina virtual usando o adaptador do S3**
+ Use o comando `cp` para copiar o arquivo da imagem de VM em um bucket no dispositivo.
```
aws s3 cp image-path s3://S3-bucket-name --endpoint http://S3-object-API-endpoint:443 --profile profile-name
```
Para obter mais informações, consulte [AWS CLI Comandos compatíveis](https://docs.aws.amazon.com/snowball/latest/developer-guide/using-adapter-cli.html) neste guia.
**Para fazer o upload da imagem da VM usando armazenamento compatível com Amazon S3 no Snowball Edge**
+ Use o comando `put-object` para copiar o arquivo de snapshot em um bucket no dispositivo.
```
aws s3api put-object --bucket bucket-name --key path-to-snapshot-file --body snapshot-file --endpoint-url s3api-endpoint-ip --profile your-profile
```
Para ter mais informações, consulte [Working with S3 objects on a Snowball Edge device](https://docs.aws.amazon.com/snowball/latest/developer-guide/objects-s3-snow.html).
## Etapa 2: Configurar as permissões necessárias no Snowball Edge
Para que a importação seja bem-sucedida, você deve configurar permissões para a VM Import/Export no dispositivo Snowball Edge, na EC2 Amazon e no usuário.
**nota**
As funções e políticas de serviço que fornecem essas permissões estão localizadas no dispositivo Snowball Edge.
### Permissões necessárias para a VM Import/Export em um Snowball Edge
Antes de iniciar o processo de importação, você deve criar uma função do IAM com uma política de confiança que permita que a VM Import/Export no dispositivo Snowball Edge assuma a função. Permissões adicionais são concedidas à função para permitir que a VM Import/Export no dispositivo acesse a imagem armazenada no bucket do S3 no dispositivo.
**Criar um arquivo json de política de confiança**
Veja a seguir um exemplo de política de confiança que deve ser anexada à função para que a VM Import/Export possa acessar o snapshot que precisa ser importado do bucket do S3.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Principal":{
"Service":"vmie.amazonaws.com"
},
"Action":"sts:AssumeRole"
}
]
}
```
------
**Criar um perfil com o arquivo json da política de confiança**
O nome do perfil pode ser vmimport. É possível alterá-lo usando a opção --role-name no comando:
```
aws iam create-role --role-name role-name --assume-role-policy-document file:///trust-policy-json-path --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
Veja um exemplo de saída do comando `create-role`.
```
{
"Role":{
"AssumeRolePolicyDocument":{
"Version":"2012-10-17",
"Statement":[
{
"Action":"sts:AssumeRole",
"Effect":"Allow",
"Principal":{
"Service":"vmie.amazonaws.com"
}
}
]
},
"MaxSessionDuration":3600,
"RoleId":"AROACEMGEZDGNBVGY3TQOJQGEZAAAABQBB6NSGNAAAABPSVLTREPY3FPAFOLKJ3",
"CreateDate":"2022-04-19T22:17:19.823Z",
"RoleName":"vmimport",
"Path":"/",
"Arn":"arn:aws:iam::123456789012:role/vmimport"
}
}
```
**Criar uma política para a função**
O exemplo de política a seguir tem as permissões mínimas necessárias para acessar o Amazon S3. Altere o nome do bucket do Amazon S3 para aquele que tem as imagens. Para um dispositivo Snowball Edge independente, *snow-id* mude para sua ID de trabalho. Para um cluster de dispositivos, altere *snow-id* para o ID do cluster. Você também pode usar prefixos para restringir ainda mais o local de onde a VM Import/Export pode importar instantâneos. Crie um arquivo json de política como este.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"s3:GetBucketLocation",
"s3:GetObject",
"s3:ListBucket",
"s3:GetMetadata"
],
"Resource":[
"arn:aws:s3:snow:account-id:snow/snow-id/bucket/import-snapshot-bucket-name",
"arn:aws:s3:snow:account-id:snow/snow-id/bucket/import-snapshot-bucket-name/*"
]
}
]
}
```
------
**Crie uma política com o arquivo de política:**
```
aws iam create-policy --policy-name policy-name --policy-document file:///policy-json-file-path --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
Veja a seguir um exemplo de saída do comando create-policy.
```
{
"Policy":{
"PolicyName":"vmimport-resource-policy",
"PolicyId":"ANPACEMGEZDGNBVGY3TQOJQGEZAAAABOOEE3IIHAAAABWZJPI2VW4UUTFEDBC2R",
"Arn":"arn:aws:iam::123456789012:policy/vmimport-resource-policy",
"Path":"/",
"DefaultVersionId":"v1",
"AttachmentCount":0,
"IsAttachable":true,
"CreateDate":"2020-07-25T23:27:35.690000+00:00",
"UpdateDate":"2020-07-25T23:27:35.690000+00:00"
}
}
```
****Anexar a política ao perfil****
Anexe uma política ao perfil anterior e conceda permissões para acessar os recursos necessários. Isso permite que o Import/Export serviço de VM local baixe o snapshot do Amazon S3 no dispositivo.
```
aws iam attach-role-policy --role-name role-name --policy-arn arn:aws:iam::123456789012:policy/policy-name --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
### Permissões exigidas pelo chamador em um Snowball Edge
Além da função que a VM do Snowball Edge deve Import/Export assumir, você também deve garantir que o usuário tenha as permissões que lhe permitam passar a função para o VMIE. Se você usar o usuário raiz padrão para realizar a importação, o qual já tem todas as permissões necessárias, poderá ignorar esta etapa e ir para a 3.
Anexe as duas permissões do IAM a seguir ao usuário que está fazendo a importação.
+ `pass-role`
+ `get-role`
**Criar uma política para a função**
Veja um exemplo de política que permite ao usuário realizar as ações `get-role` e `pass-role` para o perfil do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action": "iam:GetRole",
"Resource":"*"
},
{
"Sid": "iamPassRole",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::*:role/snowball*",
"Condition": {
"StringEquals": {
"iam:PassedToService": "importexport.amazonaws.com"
}
}
}
]
}
```
------
****Crie uma política com o arquivo de política:****
```
aws iam create-policy --policy-name policy-name --policy-document file:///policy-json-file-path --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
Veja a seguir um exemplo de saída do comando create-policy.
```
{
"Policy":{
"PolicyName":"caller-policy",
"PolicyId":"ANPACEMGEZDGNBVGY3TQOJQGEZAAAABOOOTUOE3AAAAAAPPBEUM7Q7ARPUE53C6R",
"Arn":"arn:aws:iam::123456789012:policy/caller-policy",
"Path":"/",
"DefaultVersionId":"v1",
"AttachmentCount":0,
"IsAttachable":true,
"CreateDate":"2020-07-30T00:58:25.309000+00:00",
"UpdateDate":"2020-07-30T00:58:25.309000+00:00"
}
}
```
Depois que a política for gerada, anexe a política aos usuários do IAM que chamarão a operação de EC2 API ou CLI da Amazon para importar o snapshot.
```
aws iam attach-user-policy --user-name your-user-name --policy-arn arn:aws:iam::123456789012:policy/policy-name --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
### Permissões necessárias para ligar para a Amazon EC2 APIs em um Snowball Edge
Para importar um snapshot, o usuário do IAM precisa ter as permissões `ec2:ImportSnapshot`. Se não for necessário restringir o acesso ao usuário, você pode usar as `ec2:*` permissões para conceder EC2 acesso total à Amazon. A seguir estão as permissões que podem ser concedidas ou restringidas para a Amazon EC2 em seu dispositivo. Crie um arquivo de política com o conteúdo mostrado:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ec2:ImportSnapshot",
"ec2:DescribeImportSnapshotTasks",
"ec2:CancelImportTask",
"ec2:DescribeSnapshots",
"ec2:DeleteSnapshot",
"ec2:RegisterImage",
"ec2:DescribeImages",
"ec2:DeregisterImage"
],
"Resource":"*"
}
]
}
```
------
**Crie uma política com o arquivo de política:**
```
aws iam create-policy --policy-name policy-name --policy-document file:///policy-json-file-path --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
Veja a seguir um exemplo de saída do comando create-policy.
```
{
"Policy":
{
"PolicyName": "ec2-import.json",
"PolicyId": "ANPACEMGEZDGNBVGY3TQOJQGEZAAAABQBGPDQC5AAAAATYN62UNBFYTF5WVCSCZS",
"Arn": "arn:aws:iam::123456789012:policy/ec2-import.json",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"IsAttachable": true,
"CreateDate": "2022-04-21T16:25:53.504000+00:00",
"UpdateDate": "2022-04-21T16:25:53.504000+00:00"
}
}
```
Depois que a política for gerada, anexe a política aos usuários do IAM que chamarão a operação de EC2 API ou CLI da Amazon para importar o snapshot.
```
aws iam attach-user-policy --user-name your-user-name --policy-arn arn:aws:iam::123456789012:policy/policy-name --endpoint http://snowball-ip:6078 --region snow --profile profile-name
```
## Etapa 3: importar a imagem da VM como um instantâneo no Snowball Edge
A próxima etapa é importar a imagem de VM como um snapshot no dispositivo. O valor do parâmetro `S3Bucket` é o nome do bucket que contém a imagem de VM. O valor do parâmetro `S3Key` é o caminho para o arquivo da imagem de VM nesse bucket.
```
aws ec2 import-snapshot --disk-container "Format=RAW,UserBucket={S3Bucket=bucket-name,S3Key=image-file}" --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
Para obter mais informações, consulte [import-snapshot](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/import-snapshot.html) na Referência de Comandos. AWS CLI
Esse comando não é compatível com as opções a seguir.
+ [--client-data `value`]
+ [--client-token `value`]
+ [--dry-run]
+ [--no-dry-run]
+ [--encrypted]
+ [--no-encrypted]
+ [--kms-key-id `value`]
+ [--tag-specifications `value`]
**Example saída do comando `import-snapshot`**
```
{
"ImportTaskId":"s.import-snap-1234567890abc",
"SnapshotTaskDetail":{
"DiskImageSize":2.0,
"Encrypted":false,
"Format":"RAW",
"Progress":"3",
"Status":"active",
"StatusMessage":"pending",
"UserBucket":{
"S3Bucket":"bucket",
"S3Key":"vmimport/image01"
}
}
}
```
Atualmente, o Snowball Edge permite que apenas uma tarefa de importação ativa seja executada por vez, por dispositivo. Para iniciar uma nova tarefa de importação, aguarde a conclusão da tarefa atual ou selecione outro nó disponível em um cluster. Também é possível optar por cancelar a importação atual, se desejar. Para evitar atrasos, não reinicie o dispositivo Snowball Edge enquanto a importação estiver em andamento. Se você reinicializar o dispositivo, a importação falhará e o andamento será excluído quando o dispositivo estiver acessível. Para conferir o status de importação do snapshot, use o seguinte comando:
```
aws ec2 describe-import-snapshot-tasks --import-task-ids id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
## Etapa 4: registrar o snapshot como uma AMI no Snowball Edge
Quando a importação do snapshot para o dispositivo for bem-sucedida, você poderá registrá-lo com o comando `register-image`.
**nota**
Será possível registrar uma AMI apenas quando todos os snapshots estiverem disponíveis.
Para obter mais informações, consulte [register-image na Referência](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-image.html) de AWS CLI Comandos.
**Example do comando `register-image`**
```
aws ec2 register-image \
--name ami-01 \
--description my-ami-01 \
--block-device-mappings "[{\"DeviceName\": \"/dev/sda1\",\"Ebs\":{\"Encrypted\":false,\"DeleteOnTermination\":true,\"SnapshotId\":\"snapshot-id\",\"VolumeSize\":30}}]" \
--root-device-name /dev/sda1 \
--endpoint http://snowball-ip:8008 \
--region snow \
--profile profile-name
```
Veja a seguir um exemplo de mapeamento de dispositivos de blocos JSON. Para obter mais informações, consulte o [block-device-mapping parâmetro de register-image na Referência](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/register-image.html) de AWS CLI Comandos.
```
[
{
"DeviceName": "/dev/sda",
"Ebs":
{
"Encrypted": false,
"DeleteOnTermination": true,
"SnapshotId": "snapshot-id",
"VolumeSize": 30
}
}
]
```
**Example do comando `register-image`**
```
{
"ImageId": "s.ami-8de47d2e397937318"
}
```
## Etapa 5: Executar uma instância da AMI no Snowball Edge
Para iniciar uma instância, consulte [run-instances na Referência](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/run-instances.html) de AWS CLI comandos.
O valor do parâmetro `image-id` é o valor do nome `ImageId` como saída do comando `register-image`.
```
aws ec2 run-instances --image-id image-id --instance-type instance-type --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
```
{
"Instances":[
{
"SourceDestCheck":false,
"CpuOptions":{
"CoreCount":1,
"ThreadsPerCore":2
},
"InstanceId":"s.i-12345a73123456d1",
"EnaSupport":false,
"ImageId":"s.ami-1234567890abcdefg",
"State":{
"Code":0,
"Name":"pending"
},
"EbsOptimized":false,
"SecurityGroups":[
{
"GroupName":"default",
"GroupId":"s.sg-1234567890abc"
}
],
"RootDeviceName":"/dev/sda1",
"AmiLaunchIndex":0,
"InstanceType":"sbe-c.large"
}
],
"ReservationId":"s.r-1234567890abc"
}
```
**nota**
Você também pode usar AWS OpsHub para iniciar a instância. Para obter mais informações, consulte [Lançamento de uma instância EC2 compatível com a Amazon](https://docs.aws.amazon.com/snowball/latest/developer-guide/manage-ec2.html#launch-instance) neste guia.
## Ações adicionais da AMI para um Snowball Edge
Você pode usar AWS CLI comandos adicionais para monitorar o status de importação de instantâneos, obter detalhes sobre instantâneos que foram importados, cancelar a importação de um instantâneo e excluir ou cancelar o registro de instantâneos após a importação.
### Monitorando o status de importação de instantâneos em um Snowball Edge
Para ver o estado atual do progresso da importação, você pode executar o EC2 `describe-import-snapshot-tasks` comando Amazon. Esse comando é compatível com a paginação e a filtragem no `task-state`.
**Example do comando `describe-import-snapshot-tasks`**
```
aws ec2 describe-import-snapshot-tasks --import-task-ids id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
**Example da saída do comando `describe-import-snapshot-tasks`**
```
{
"ImportSnapshotTasks": [
{
"ImportTaskId": "s.import-snap-8f6bfd7fc9ead9aca",
"SnapshotTaskDetail": {
"Description": "Created by AWS-Snowball-VMImport service for s.import-snap-8f6bfd7fc9ead9aca",
"DiskImageSize": 8.0,
"Encrypted": false,
"Format": "RAW",
"Progress": "3",
"SnapshotId": "s.snap-848a22d7518ad442b",
"Status": "active",
"StatusMessage": "pending",
"UserBucket": {
"S3Bucket": "bucket1",
"S3Key": "image1"
}
}
}
]
}
```
**nota**
Esse comando mostra apenas a saída de tarefas que foram concluídas com êxito ou marcadas como excluídas nos últimos sete dias. A filtragem é compatível apenas com `Name=task-state` e `Values=active | deleting | deleted | completed`.
Esse comando não é compatível com os parâmetros a seguir.
+ [--dry-run]
+ [--no-dry-run]
### Cancelamento de uma tarefa de importação em um Snowball Edge
Para cancelar uma tarefa de importação, execute o comando `cancel-import-task`.
**Example do comando `cancel-import-task`**
```
aws ec2 cancel-import-task --import-task-id import-task-id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
**Example da saída do comando `cancel-import-task`**
```
{
"ImportTaskId": "s.import-snap-8234ef2a01cc3b0c6",
"PreviousState": "active",
"State": "deleting"
}
```
Somente tarefas não concluídas podem ser canceladas.
Esse comando não é compatível com os parâmetros a seguir.
+ [--dry-run]
+ [--no-dry-run]
### Descrevendo instantâneos em um Snowball Edge
Após a importação de um snapshot, é possível usar esse comando para descrevê-lo. Para filtrar os snapshots, é possível transmiti-los em `snapshot-ids` com o ID do snapshot da resposta da tarefa de importação anterior. Esse comando é compatível com a paginação e a filtragem em `volume-id`, `status` e `start-time`.
**Example do comando `describe-snapshots`**
```
aws ec2 describe-snapshots --snapshot-ids snapshot-id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
**Example da saída do comando `describe-snapshots`**
```
{
"Snapshots": [
{
"Description": "Created by AWS-Snowball-VMImport service for s.import-snap-8f6bfd7fc9ead9aca",
"Encrypted": false,
"OwnerId": "123456789012",
"SnapshotId": "s.snap-848a22d7518ad442b",
"StartTime": "2020-07-30T04:31:05.032000+00:00",
"State": "completed",
"VolumeSize": 8
}
]
}
```
Esse comando não é compatível com os parâmetros a seguir.
+ [--restorable-by-user-ids `value`]
+ [--dry-run]
+ [--no-dry-run]
### Excluindo um snapshot de um dispositivo Snowball Edge
Para remover snapshots desnecessários, é possível usar o comando `delete-snapshot`.
**Example do comando `delete-snapshot`**
```
aws ec2 delete-snapshot --snapshot-id snapshot-id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
**nota**
O Snowball Edge não é compatível com a exclusão de snapshots que estejam em estado **PENDENTE** ou que tenham sido designados como dispositivo raiz para uma AMI.
Esse comando não é compatível com os parâmetros a seguir.
+ [--dry-run]
+ [--no-dry-run]
### Cancelando o registro de uma AMI em um Snowball Edge
Para cancelar o registro AMIs que você não precisa mais, execute o `deregister-image` comando. O cancelamento do registro de uma AMI no estado **Pendente** não é aceito no momento.
**Example do comando `deregister-image`**
```
aws ec2 deregister-image --image-id image-id --endpoint http://snowball-ip:8008 --region snow --profile profile-name
```
Esse comando não é compatível com os parâmetros a seguir.
+ [--dry-run]
+ [--no-dry-run]
# Usando as operações de API AWS CLI e no dispositivo Snowball Edge
Ao usar as operações AWS Command Line Interface (AWS CLI) ou de API para emitir EC2 comandos do IAM, Amazon S3 e Amazon no Snowball Edge, você deve especificar o `region` como "”. `snow` Você pode fazer isso usando `AWS configure` ou dentro do próprio comando, como nos exemplos a seguir.
```
aws configure --profile ProfileName
AWS Access Key ID [None]: defgh
AWS Secret Access Key [None]: 1234567
Default region name [None]: snow
Default output format [None]: json
```
Ou
```
aws s3 ls --endpoint http://192.0.2.0:8080 --region snow --profile ProfileName
```
# Configurações de rede para instâncias de computação no Snowball Edge
Depois de iniciar sua instância de computação em um Snowball Edge, você deve fornecer a ela um endereço IP criando uma interface de rede. O Snowball Edges oferece suporte a dois tipos de interfaces de rede, uma interface de rede virtual e uma interface de rede direta.
**Interface de rede virtual (VNI)** — Uma interface de rede virtual é a interface de rede padrão para se conectar a uma instância EC2 compatível em seu Snowball Edge. Você deve criar uma VNI para cada uma EC2 de suas instâncias compatíveis, independentemente de você também usar uma interface de rede direta ou não. O tráfego que passa por uma VNI é protegido pelos grupos de segurança configurados. Você só pode se VNIs associar à porta de rede física usada para controlar o Snowball Edge.
**nota**
O VNI usará a mesma interface física (RJ45, SFP\$1 ou QSFP) usada para gerenciar o Snowball Edge. Criar uma VNI em uma interface física diferente daquela usada para gerenciamento de dispositivos pode gerar resultados inesperados.
**Interface de rede direta (DNI)**: uma interface de rede direta (DNI) é um recurso de rede avançado que permite casos de uso, como fluxos multicast, roteamento transitivo e balanceador de carga. Ao fornecer às instâncias acesso à rede de camada 2 sem qualquer tradução ou filtragem intermediária, você pode obter maior flexibilidade na configuração de rede do Snowball Edge e melhorar o desempenho da rede. DNIs suporta tags de VLAN e personaliza o endereço MAC. O tráfego ligado não DNIs é protegido por grupos de segurança.
Nos dispositivos Snowball Edge, ela DNIs pode ser associada às portas SFP ou QSFP. RJ45 Cada porta física suporta no máximo 63 DNIs. DNIs não precisam estar associados à mesma porta de rede física que você usa para gerenciar o Snowball Edge.
**nota**
Os dispositivos de armazenamento otimizado (com funcionalidade de EC2 computação) do Snowball Edge não são compatíveis. DNIs
**Topics**
+ [Pré-requisitos para ou DNIs no VNIs Snowball Edge](#snowcone-configuration-prerequisites)
+ [Configurando uma interface de rede virtual (VNI) em um Snowball Edge](#setup-vni)
+ [Configurando uma interface de rede direta (DNI) em um Snowball Edge](#snowcone-setup-dni)
## Pré-requisitos para ou DNIs no VNIs Snowball Edge
Antes de configurar uma VNI ou uma DNI, verifique se você cumpriu os pré-requisitos a seguir.
****
1. Verifique se o dispositivo está ligado e se uma das interfaces físicas de rede, como a RJ45 porta, está conectada a um endereço IP.
1. Obtenha o endereço IP associado à interface de rede física que você está usando no Snowball Edge.
1. Configure o Snowball Edge Client. Para obter mais informações, consulte [Configurar um perfil para o Snowball Edge Client](using-client-commands.md#client-configuration).
1. Configure o AWS CLI. Para obter mais informações, consulte [Introdução ao AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) no Guia do AWS Command Line Interface usuário.
1. Desbloqueie o dispositivo.
+ Use AWS OpsHub para desbloquear o dispositivo. Para obter mais informações, consulte [Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/connect-unlock-device.html) Edge com. AWS OpsHub
+ Use o Snowball Edge Client para desbloquear o dispositivo. Para obter mais informações, consulte [Desbloquear o Snowball Edge](unlockdevice.md).
1. Execute uma instância EC2 compatível no dispositivo. Você associará a VNI a essa instância.
1. Use o Snowball Edge Client para executar o comando `describe-device`. A saída do comando fornecerá uma lista da interface de rede física IDs. Para obter mais informações, consulte [Visualizando o status de um Snowball Edge](using-client-commands.md#client-status).
1. Identifique o ID da interface de rede física que deseja usar e anote-o.
## Configurando uma interface de rede virtual (VNI) em um Snowball Edge
Depois de identificar o ID da interface de rede física, é possível configurar uma interface de rede virtual (VNI) com essa interface física. Utilize o procedimento a seguir para configurar uma VNI. Assegure-se de realizar as tarefas de pré-requisito antes de criar uma VNI.
**Criar uma VNI e associar um endereço IP**
1. Use o Snowball Edge Client para executar o comando `create-virtual-network-interface`. Os exemplos a seguir mostram a execução desse comando com os dois diferentes métodos de atribuição de endereço IP, `DHCP` ou `STATIC`. O método `DHCP` usa Dynamic Host Configuration Protocol (DHCP — Protocolo de configuração de host dinâmico).
```
snowballEdge create-virtual-network-interface \
--physical-network-interface-id s.ni-abcd1234 \
--ip-address-assignment DHCP \
--profile profile-name
//OR//
snowballEdge create-virtual-network-interface \
--physical-network-interface-id s.ni-abcd1234 \
--ip-address-assignment STATIC \
--static-ip-address-configuration IpAddress=192.0.2.0,Netmask=255.255.255.0 \
--profile profile-name
```
O comando retorna uma estrutura JSON que inclui o endereço IP. Anote esse endereço IP para usar com o `ec2 associate-address` AWS CLI comando posteriormente no processo.
Sempre que precisar desse endereço IP, você pode usar o comando do cliente do Snowball Edge, o comando do cliente do `describe-virtual-network-interfaces` Snowball Edge ou AWS CLI o `aws ec2 describe-addresses` comando para obtê-lo.
1. Use o AWS CLI para associar o endereço IP à instância EC2 compatível com -, substituindo o texto em vermelho pelos seus valores:
```
aws ec2 associate-address --public-ip 192.0.2.0 --instance-id s.i-01234567890123456 --endpoint http://Snowball Edge physical IP address:8008
```
## Configurando uma interface de rede direta (DNI) em um Snowball Edge
**nota**
O recurso de interface de rede direta está disponível a partir de 12 de janeiro de 2021 e está disponível em todos os Regiões da AWS lugares onde o Snowball Edges está disponível.
### Pré-requisitos para um DNI em um Snowball Edge
Antes de configurar uma interface de rede direta (DNI), é necessário realizar as tarefas na seção de pré-requisitos.
1. Realize as tarefas de pré-requisito antes de configurar a DNI. Para instruções, consulte [Pré-requisitos para ou DNIs no VNIs Snowball Edge](#snowcone-configuration-prerequisites).
1. Além disso, é necessário iniciar uma instância no dispositivo, criar uma VNI e associá-la à instância. Para instruções, consulte [Configurando uma interface de rede virtual (VNI) em um Snowball Edge](#setup-vni).
**nota**
Se você adicionou rede direta ao seu dispositivo existente executando uma atualização de in-the-field software, deverá reiniciar o dispositivo duas vezes para ativar totalmente o recurso.
**Criar uma DNI e associar o endereço IP**
1. Crie uma interface de rede direta e conecte-a à instância EC2 compatível com a Amazon executando o comando a seguir. Você precisará do endereço MAC do dispositivo para a próxima etapa.
```
create-direct-network-interface [--endpoint endpoint] [--instance-id instanceId] [--mac macAddress]
[--physical-network-interface-id physicalNetworkInterfaceId]
[--unlock-code unlockCode] [--vlan vlanId]
```
OPTIONS
** --endpoint ** O endpoint para o qual enviar essa solicitação. O endpoint dos dispositivos será um URL que use o esquema `https` seguido por um endereço IP. Por exemplo, se o endereço IP do dispositivo for 123.0.1.2, o endpoint do dispositivo será https://123.0.1.2.
** --instance-id **O ID da instância EC2 compatível ao qual anexar a interface (opcional).
** --mac **: define o endereço MAC da interface de rede (opcional).
**--physical-network-interface-id ** O ID da interface de rede física na qual criar uma interface de rede virtual. Você pode determinar as interfaces de rede física disponíveis no Snowball Edge usando o comando `describe-device`.
**--vlan **: defina a VLAN atribuída para a interface (opcional). Quando especificado, todo o tráfego enviado da interface é marcado com o ID de VLAN especificado. O tráfego de entrada é filtrado pelo ID de VLAN especificado e todas as tags de VLAN são removidas antes de serem transmitidas para a instância.
1. Depois de criar um DNI e associá-lo à sua instância EC2 compatível, você deve fazer duas alterações na configuração dentro da sua instância compatível com a Amazon EC2.
+ A primeira é garantir que os pacotes destinados ao VNI associado à instância EC2 compatível sejam enviados por meio de eth0.
+ A segunda alteração configura a interface de rede direta para usar DCHP ou IP estático durante a inicialização.
Veja a seguir exemplos de script de shell para Amazon Linux 2 e CentOS Linux que fazem essas alterações na configuração.
------
#### [ Amazon Linux 2 ]
```
# Mac address of the direct network interface.
# You got this when you created the direct network interface.
DNI_MAC=[MAC ADDRESS FROM CREATED DNI]
# Configure routing so that packets meant for the VNI always are sent through eth0.
PRIVATE_IP=$(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)
PRIVATE_GATEWAY=$(ip route show to match 0/0 dev eth0 | awk '{print $3}')
ROUTE_TABLE=10001
echo "from $PRIVATE_IP table $ROUTE_TABLE" > /etc/sysconfig/network-scripts/rule-eth0
echo "default via $PRIVATE_GATEWAY dev eth0 table $ROUTE_TABLE" > /etc/sysconfig/network-scripts/route-eth0
echo "169.254.169.254 dev eth0" >> /etc/sysconfig/network-scripts/route-eth0
# Query the persistent DNI name, assigned by udev via ec2net helper.
# changable in /etc/udev/rules.d/70-persistent-net.rules
DNI=$(ip --oneline link | grep -i $DNI_MAC | awk -F ': ' '{ print $2 }')
# Configure DNI to use DHCP on boot.
cat << EOF > /etc/sysconfig/network-scripts/ifcfg-$DNI
DEVICE="$DNI"
NAME="$DNI"
HWADDR=$DNI_MAC
ONBOOT=yes
NOZEROCONF=yes
BOOTPROTO=dhcp
TYPE=Ethernet
MAINROUTETABLE=no
EOF
# Make all changes live.
systemctl restart network
```
------
#### [ CentOS Linux ]
```
# Mac address of the direct network interface. You got this when you created the direct network interface.
DNI_MAC=[MAC ADDRESS FROM CREATED DNI]
# The name to use for the direct network interface. You can pick any name that isn't already in use.
DNI=eth1
# Configure routing so that packets meant for the VNIC always are sent through eth0
PRIVATE_IP=$(curl -s http://169.254.169.254/latest/meta-data/local-ipv4)
PRIVATE_GATEWAY=$(ip route show to match 0/0 dev eth0 | awk '{print $3}')
ROUTE_TABLE=10001
echo from $PRIVATE_IP table $ROUTE_TABLE > /etc/sysconfig/network-scripts/rule-eth0
echo default via $PRIVATE_GATEWAY dev eth0 table $ROUTE_TABLE > /etc/sysconfig/network-scripts/route-eth0
# Configure your direct network interface to use DHCP on boot.
cat << EOF > /etc/sysconfig/network-scripts/ifcfg-$DNI
DEVICE="$DNI"
NAME="$DNI"
HWADDR="$DNI_MAC"
ONBOOT=yes
NOZEROCONF=yes
BOOTPROTO=dhcp
TYPE=Ethernet
EOF
# Rename DNI device if needed.
CURRENT_DEVICE_NAME=$(LANG=C ip -o link | awk -F ': ' -vIGNORECASE=1 '!/link\/ieee802\.11/ && /'"$DNI_MAC"'/ { print $2 }')
ip link set $CURRENT_DEVICE_NAME name $DNI
# Make all changes live.
systemctl restart network
```
------
# Usando SSH para se conectar a instâncias de computação em um Snowball Edge
Para usar o Secure Shell (SSH) para se conectar a instâncias de computação em um Snowball Edge, você tem as seguintes opções para fornecer ou criar uma chave SSH.
+ É possível fornecer a chave SSH para a imagem de máquina da Amazon (AMI) na criação de um trabalho para solicitar um dispositivo. Para obter mais informações, consulte [Criação de um trabalho para solicitar um Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/create-job-common.html) Edge.
+ Você pode fornecer a chave SSH para a AMI ao criar uma imagem de máquina virtual para importar para um Snowball Edge. Para obter mais informações, consulte [Importação de uma imagem de máquina virtual para um dispositivo Snowball Edge](ec2-ami-import-cli.md).
+ Você pode criar um par de chaves no Snowball Edge e optar por iniciar uma instância com essa chave pública gerada localmente. Para obter mais informações, consulte [Criar um par de chaves usando a Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-key-pairs.html#having-ec2-create-your-key-pair) no Guia EC2 do usuário da Amazon.
**Como se conectar a uma instância por meio de SSH.**
1. Verifique se o dispositivo está ligado, conectado à rede e desbloqueado. Para obter mais informações, consulte [Conectando um Snowball Edge à sua rede local](getting-started.md#getting-started-connect).
1. Verifique se as configurações de rede estão configuradas para as instâncias de computação. Para obter mais informações, consulte [Configurações de rede para instâncias de computação no Snowball Edge](network-config-ec2.md).
1. Verifique as notas para localizar o par de chaves PEM ou PPK que você usou para essa instância específica. Faça uma cópia desses arquivos em algum lugar em seu computador. Anote o caminho para o arquivo PEM.
1. Conecte-se à instância com SSH, conforme o exemplo de comando a seguir. O endereço IP é o endereço IP da interface de rede virtual (VNIC) configurada em [Configurações de rede para instâncias de computação no Snowball Edge](network-config-ec2.md).
```
ssh -i path/to/PEM/key/file instance-user-name@192.0.2.0
```
Para obter mais informações, consulte [Conectando-se à sua instância Linux usando SSH](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html) no *Guia do EC2 usuário da Amazon*.
# Transferência de dados de instâncias computacionais EC2 compatíveis para buckets do S3 no mesmo Snowball Edge
É possível transferir dados entre instâncias de computação e buckets do Amazon S3 no mesmo dispositivo Snowball Edge. Você faz isso usando os AWS CLI comandos suportados e os endpoints apropriados. Por exemplo, suponha que deseja mover dados de um diretório na minha instância `sbe1.xlarge` para o bucket do Amazon S3, `amzn-s3-demo-bucket` no mesmo dispositivo. Suponha que você esteja usando o armazenamento compatível com Amazon S3 no endpoint Snowball Edge. `https://S3-object-API-endpoint:443` Use o procedimento a seguir:
**Como transferir dados entre uma instância de computação e um bucket no mesmo Snowball Edge**
1. Use SSH para se conectar à instância de computação.
1. Baixe e instale AWS CLI o. Se a instância ainda não tiver a AWS CLI, faça download e instale-a. Para obter mais informações, consulte [Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Configure o AWS CLI em sua instância computacional para funcionar com o endpoint Amazon S3 no Snowball Edge. Para obter mais informações, consulte [Obter e usar credenciais locais do Amazon S3 no Snowball Edge](using-adapter.md#adapter-credentials).
1. Use o armazenamento compatível com o Amazon S3 compatível com os comandos do Snowball Edge para transferir dados. Por exemplo:
```
aws s3 cp ~/june2018/results s3://amzn-s3-demo-bucket/june2018/results --recursive --endpoint https://S3-object-API-endpoint:443
```
# Iniciando instâncias EC2 compatíveis automaticamente
O Snowball Edge Client é uma aplicação independente de interface de linha de comandos (CLI) que você pode executar no ambiente. É possível usá-lo para realizar algumas tarefas administrativas no dispositivo Snowball Edge ou um cluster de dispositivos. Para obter mais informações sobre como usar o cliente do Snowball Edge, incluindo como iniciar e interromper serviços com ele, consulte [Configurar e usar o Snowball Edge Client](using-client-commands.md).
Veja a seguir informações sobre os comandos do cliente do Snowball Edge específicos de instâncias de computação, incluindo exemplos de uso.
Para obter uma lista dos comandos EC2 compatíveis com a Amazon que você pode usar em seu AWS Snowball Edge dispositivo, consulte[EC2 AWS CLI Comandos compatíveis com a Amazon suportados em um Snowball Edge](using-ec2-endpoint.md#cli-support-ec2-edge).
## Criação de uma configuração EC2 de lançamento compatível em um Snowball Edge
Para iniciar automaticamente instâncias computacionais EC2 compatíveis com a Amazon em seu AWS Snowball Edge dispositivo depois que ele for desbloqueado, você pode criar uma configuração de inicialização. Para isso, use o comando `snowballEdge create-autostart-configuration`, conforme mostrado a seguir.
**Uso**
```
snowballEdge create-autostart-configuration --physical-connector-type [SFP_PLUS or RJ45 or QSFP] --ip-address-assignment [DHCP or STATIC] [--static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]] --launch-template-id [--launch-template-version]
```
## Atualização de uma configuração EC2 de lançamento compatível em um Snowball Edge
Para atualizar uma configuração de inicialização existente no Snowball Edge, use o comando `snowballEdge update-autostart-configuration`. Veja o seu uso a seguir. Para ativar ou desativar uma configuração de execução, especifique o parâmetro `--enabled`.
**Uso**
```
snowballEdge update-autostart-configuration --autostart-configuration-arn [--physical-connector-type [SFP_PLUS or RJ45 or QSFP]] [--ip-address-assignment [DHCP or STATIC]] [--static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]][--launch-template-id] [--launch-template-version] [--enabled]
```
## Excluindo uma configuração EC2 de lançamento compatível em um Snowball Edge
Para excluir uma configuração de inicialização que não esteja mais em uso, utilize o comando `snowballEdge delete-autostart-configuration` da forma a seguir.
**Uso**
```
snowballEdge delete-autostart-configuration --autostart-configuration-arn
```
## Listando configurações EC2 de lançamento compatíveis em um Snowball Edge
Para listar as configurações de inicialização criadas no Snowball Edge, use o comando `describe-autostart-configurations` da forma a seguir.
**Uso**
```
snowballEdge describe-autostart-configurations
```
## Criando uma interface de rede virtual em um Snowball Edge
Para executar uma instância de computação ou iniciar a interface NFS em um Snowball Edge, primeiro crie uma interface de rede virtual (VNI). Cada Snowball Edge tem três interfaces de rede (NICs), os controladores físicos da interface de rede do dispositivo. Essas são as RJ45 portas SFP e QSFP na parte traseira do dispositivo.
Cada VNI se baseia em uma das físicas e é possível ter qualquer número de VNIs associadas a cada NIC. Para criar uma interface de rede virtual, use o comando `snowballEdge create-virtual-network-interface`.
**nota**
O parâmetro `--static-ip-address-configuration` é válido apenas ao usar a opção `STATIC` para o parâmetro `--ip-address-assignment`.
**Uso**
É possível usar esse comando de duas formas: com o cliente do Snowball Edge configurado ou sem ele. O exemplo de uso a seguir mostra o método com o cliente do Snowball Edge configurado.
```
snowballEdge create-virtual-network-interface --ip-address-assignment [DHCP or STATIC] --physical-network-interface-id [physical network interface id] --static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]
```
O exemplo de uso a seguir mostra o método sem o Snowball Edge configurado.
```
snowballEdge create-virtual-network-interface --endpoint https://[ip address] --manifest-file /path/to/manifest --unlock-code [unlock code] --ip-address-assignment [DHCP or STATIC] --physical-network-interface-id [physical network interface id] --static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]
```
**Example Exemplo: Criando VNICs (usando DHCP)**
```
snowballEdge create-virtual-network-interface --ip-address-assignment dhcp --physical-network-interface-id s.ni-8EXAMPLEaEXAMPLEd
{
"VirtualNetworkInterface" : {
"VirtualNetworkInterfaceArn" : "arn:aws:snowball-device:::interface/s.ni-8EXAMPLE8EXAMPLEf",
"PhysicalNetworkInterfaceId" : "s.ni-8EXAMPLEaEXAMPLEd",
"IpAddressAssignment" : "DHCP",
"IpAddress" : "192.0.2.0",
"Netmask" : "255.255.255.0",
"DefaultGateway" : "192.0.2.1",
"MacAddress" : "EX:AM:PL:E1:23:45",
"MtuSize" : "1500"
}
}
```
## Descrição das interfaces de rede virtuais
Para descrever o VNICs que você criou anteriormente em seu dispositivo, use o `snowballEdge describe-virtual-network-interfaces` comando. Veja o seu uso a seguir.
**Uso**
É possível usar esse comando de duas formas: com o cliente do Snowball Edge configurado ou sem ele. O exemplo de uso a seguir mostra o método com o cliente do Snowball Edge configurado.
```
snowballEdge describe-virtual-network-interfaces
```
O exemplo de uso a seguir mostra o método sem o Snowball Edge configurado.
```
snowballEdge describe-virtual-network-interfaces --endpoint https://[ip address] --manifest-file /path/to/manifest --unlock-code [unlock code]
```
**Example Exemplo: Descrevendo VNICs**
```
snowballEdge describe-virtual-network-interfaces
[
{
"VirtualNetworkInterfaceArn" : "arn:aws:snowball-device:::interface/s.ni-8EXAMPLE8EXAMPLE8",
"PhysicalNetworkInterfaceId" : "s.ni-8EXAMPLEaEXAMPLEd",
"IpAddressAssignment" : "DHCP",
"IpAddress" : "192.0.2.0",
"Netmask" : "255.255.255.0",
"DefaultGateway" : "192.0.2.1",
"MacAddress" : "EX:AM:PL:E1:23:45",
"MtuSize" : "1500"
},{
"VirtualNetworkInterfaceArn" : "arn:aws:snowball-device:::interface/s.ni-1EXAMPLE1EXAMPLE1",
"PhysicalNetworkInterfaceId" : "s.ni-8EXAMPLEaEXAMPLEd",
"IpAddressAssignment" : "DHCP",
"IpAddress" : "192.0.2.2",
"Netmask" : "255.255.255.0",
"DefaultGateway" : "192.0.2.1",
"MacAddress" : "12:34:5E:XA:MP:LE",
"MtuSize" : "1500"
}
]
```
## Atualizando uma interface de rede virtual em um Snowball Edge
Depois que você criar uma interface de rede virtual (VNI), atualize a configuração usando o comando `snowballEdge update-virtual-network-interface`. Depois que você fornecer o nome do recurso da Amazon (ARN) para uma VNI específica, forneça valores somente para os elementos que estiver atualizando.
**Uso**
É possível usar esse comando de duas formas: com o cliente do Snowball Edge configurado ou sem ele. O exemplo de uso a seguir mostra o método com o cliente do Snowball Edge configurado.
```
snowballEdge update-virtual-network-interface --virtual-network-interface-arn [virtual network-interface-arn] --ip-address-assignment [DHCP or STATIC] --physical-network-interface-id [physical network interface id] --static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]
```
O exemplo de uso a seguir mostra o método sem o Snowball Edge configurado.
```
snowballEdge update-virtual-network-interface --endpoint https://[ip address] --manifest-file /path/to/manifest --unlock-code [unlock code] --virtual-network-interface-arn [virtual network-interface-arn] --ip-address-assignment [DHCP or STATIC] --physical-network-interface-id [physical network interface id] --static-ip-address-configuration IpAddress=[IP address],NetMask=[Netmask]
```
**Example Exemplo: atualização de uma VNIC (usando DHCP)**
```
snowballEdge update-virtual-network-interface --virtual-network-interface-arn arn:aws:snowball-device:::interface/s.ni-8EXAMPLEbEXAMPLEd --ip-address-assignment dhcp
```
## Excluindo uma interface de rede virtual em um Snowball Edge
Para excluir uma interface de rede virtual (VNI), use o comando ` snowballEdge delete-virtual-network-interface`.
**Uso**
É possível usar esse comando de duas formas: com o cliente do Snowball Edge configurado ou sem ele. O exemplo de uso a seguir mostra o método com o cliente do Snowball Edge configurado.
```
snowballEdge delete-virtual-network-interface --virtual-network-interface-arn [virtual network-interface-arn]
```
O exemplo de uso a seguir mostra o método sem o Snowball Edge configurado.
```
snowballEdge delete-virtual-network-interface --endpoint https://[ip address] --manifest-file /path/to/manifest --unlock-code [unlock code] --virtual-network-interface-arn [virtual network-interface-arn]
```
**Example Exemplo: exclusão de uma VNIC**
```
snowballEdge delete-virtual-network-interface --virtual-network-interface-arn arn:aws:snowball-device:::interface/s.ni-8EXAMPLEbEXAMPLEd
```
# Usando o endpoint EC2 compatível com a Amazon em um Snowball Edge
A seguir, você encontrará uma visão geral do endpoint EC2 compatível com a Amazon. Usando esse endpoint, você pode gerenciar suas Amazon Machine Images (AMIs) e computar instâncias de forma programática usando operações de API compatíveis com a EC2 Amazon.
## Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge
Ao usar o AWS CLI para emitir um comando para o AWS Snowball Edge dispositivo, você pode especificar que o endpoint é EC2 compatível com a Amazon. Você tem a opção de usar o endpoint HTTPS ou um endpoint HTTP desprotegido, como mostrado a seguir.
**Endpoint HTTPS protegido**
```
aws ec2 describe-instances --endpoint https://192.0.2.0:8243 --ca-bundle path/to/certificate
```
**Endpoint HTTP desprotegido**
```
aws ec2 describe-instances --endpoint http://192.0.2.0:8008
```
Se você usar o endpoint HTTPS de `8243`, os dados em trânsito são criptografados. Essa criptografia é garantida com um certificado gerado pelo Snowball Edge quando é desbloqueado. Depois de receber o certificado, você poderá salvá-lo em um arquivo local `ca-bundle.pem`. Então você poderá configurar sua AWS CLI para incluir o caminho do seu certificado, conforme descrito a seguir.
**Para associar seu certificado ao endpoint EC2 compatível com a Amazon**
1. Conecte o Snowball Edge à alimentação e à rede e, depois, ative-o.
1. Depois que o dispositivo terminar de desbloquear, anote o endereço IP dele na sua rede local.
1. Em um terminal na rede, verifique se é possível fazer ping no Snowball Edge.
1. Execute o comando `snowballEdge get-certificate` no seu terminal. Para obter mais informações sobre este comando, consulte [Gerenciando certificados de chave pública no Snowball Edge](snowball-edge-certificates-cli.md).
1. Salve a saída do comando `snowballEdge get-certificate` em um arquivo, por exemplo, `ca-bundle.pem`.
1. Execute o seguinte comando no seu terminal.
```
aws configure set profile.snowballEdge.ca_bundle /path/to/ca-bundle.pem
```
Depois de concluir o procedimento, execute comandos da CLI com essas credenciais locais, com o certificado e com o endpoint especificado.
## EC2 AWS CLI Comandos compatíveis com a Amazon suportados em um Snowball Edge
Você pode gerenciar suas instâncias computacionais em um dispositivo Snowball Edge por meio de um endpoint compatível com a EC2 Amazon. Esse tipo de endpoint suporta muitos dos comandos e ações da Amazon EC2 CLI do. AWS SDKs Para obter informações sobre como instalar e configurar o AWS CLI, incluindo especificar para quem Regiões da AWS você deseja fazer AWS CLI chamadas, consulte o [Guia do AWS Command Line Interface usuário](https://docs.aws.amazon.com/cli/latest/userguide/).
### Lista de AWS CLI comandos EC2 compatíveis com suporte em um Snowball Edge
A seguir, você encontrará uma descrição do subconjunto de AWS CLI comandos e opções da Amazon EC2 que são compatíveis com dispositivos Snowball Edge. Se um comando ou opção não estiver listado abaixo, não é compatível. É possível declarar algumas opções não compatíveis junto com um comando. No entanto, elas são ignoradas.
+ [associate-address](https://docs.aws.amazon.com/cli/latest/reference/ec2/associate-address.html) – associa um endereço IP virtual a uma instância para o uso em uma das três interfaces de rede físicas no dispositivo:
+ --instance-id – o ID de uma única instância `sbe`.
+ --public-ip – o endereço IP virtual que deseja usar para acessar a instância.
+ [attach-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/attach-volume.html): anexa um volume do Amazon EBS a uma instância em execução ou interrompida no dispositivo e o expõe para a instância com o nome de dispositivo especificado.
+ --device `value`: o nome do dispositivo.
+ --instance-id — O ID de uma instância de destino compatível com a Amazon. EC2
+ --volume-id `value`: o ID do volume do EBS.
+ [authorize-security-group-egress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-egress.html)— Adiciona uma ou mais regras de saída a um grupo de segurança para uso com um dispositivo Snowball Edge. Especificamente, essa ação permite que as instâncias enviem tráfego para um ou mais intervalos de endereços IPv4 CIDR de destino. Para obter mais informações, consulte [Controle do tráfego de rede com grupos de segurança no Snowball Edge](edge-security-groups.md).
+ --group-id `value`: o ID do grupo de segurança
+ [--ip-permissions `value`]: um ou mais conjuntos de permissões de IP.
+ [authorize-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/authorize-security-group-ingress.html)— Adiciona uma ou mais regras de entrada a um grupo de segurança. Ao chamar `authorize-security-group-ingress`, você deve especificar um valor para `group-name` ou para `group-id`.
+ [--group-name `value`]: o nome do grupo de segurança.
+ [--group-id `value`]: o ID do grupo de segurança
+ [--ip-permissions `value`]: um ou mais conjuntos de permissões de IP.
+ [--protocol `value`] o protocolo IP. Os valores possíveis são `tcp`, `udp` e `icmp`. O argumento `--port` é obrigatório, a menos que o valor "all protocols (todos os protocolos)" seja especificado (-1).
+ [--port `value`]: para TCP ou UDP, o intervalo de portas a ser permitido. Esse valor pode ser um único número inteiro ou um intervalo (mínimo - máximo).
Para ICMP, um único número inteiro ou um intervalo (`type`-`code`) em que `type` representa o número do tipo ICMP e `code` representa o número do código ICMP. Um valor de -1 indica todos os códigos ICMP para todos os tipos ICMP. Um valor de -1 para `type` indica todos os códigos ICMP para o tipo ICMP especificado.
+ [--cidr `value`]: o intervalo de IPs CIDR.
+ [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html)— Cria um modelo de lançamento. Um *modelo de execução *contém os parâmetros para executar uma instância. Ao executar uma instância usando `RunInstances`, é possível especificar um modelo de execução em vez de fornecer os parâmetros de execução na solicitação. É possível criar até cem modelos por dispositivo.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ -- launch-template-data `structure` — As informações do modelo de lançamento. Há suporte para os seguintes atributos:
+ `ImageId`
+ `InstanceType`
+ `SecurityGroupIds`
+ `TagSpecifications`
+ `UserData`
Sintaxe do JSON:
```
{
"ImageId":"string",
"InstanceType":"sbe-c.large",
"SecurityGroupIds":["string", ...],
"TagSpecifications":[{"ResourceType":"instance","Tags":[{"Key":"Name","Value":"Test"},
{"Key":"Stack","Value":"Gamma"}]}],
"UserData":"this is my user data"
}
```
+ [--version-description `string`]: uma descrição para a primeira versão do modelo de inicialização.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [create-launch-template-version](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template-version.html)— Cria uma nova versão para um modelo de lançamento. Você pode especificar uma versão existente de um modelo de execução para servir como base para a nova versão. As versões de modelo de execução são numeradas na ordem em que são criadas. Não é possível especificar, alterar ou substituir a numeração das versões do modelo de execução. Você pode criar até 100 versões de cada modelo de execução.
Especifique na solicitação o ID ou o nome do modelo de execução.
+ -- launch-template-id `string` — O ID do modelo de lançamento.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ -- launch-template-data `structure` — As informações do modelo de lançamento. Há suporte para os seguintes atributos:
+ `ImageId`
+ `InstanceType`
+ `SecurityGroupIds`
+ `TagSpecifications`
+ `UserData`
Sintaxe do JSON:
```
{
"ImageId":"string",
"InstanceType":"sbe-c.large",
"SecurityGroupIds":["string", ...],
"TagSpecifications":[{"ResourceType":"instance","Tags":[{"Key":"Name","Value":"Test"},
{"Key":"Stack","Value":"Gamma"}]}],
"UserData":"this is my user data"
}
```
+ [--source-version `string`]: o número de versão do modelo de execução que servirá como base para a nova versão. A nova versão herda os mesmos parâmetros de execução da versão de origem, exceto os parâmetros especificados em `launch-template-data`.
+ [--version-description `string`]: uma descrição para a primeira versão do modelo de inicialização.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [create-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-tags.html) – adiciona ou substitui uma ou mais tags do atributo especificado. Cada recurso pode ter um máximo de 50 tags. Cada tag consiste em uma chave e um valor opcional. As chaves de tag devem ser exclusivas para um recurso. Há suporte para os seguintes atributos:
+ AMI
+ Instância
+ Modelo de execução
+ Grupo de segurança
+ Par de chaves
+ [create-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-security-group.html)— Cria um grupo de segurança no seu Snowball Edge. Você pode criar até 50 grupos de segurança. Ao criar um grupo de segurança, você especifica um nome amigável de sua escolha:
+ --group-name `value`: o nome do grupo de segurança.
+ --description `value`: uma descrição do grupo de segurança. Isso é apenas informativo. Esse valor pode ter até 255 caracteres.
+ [create-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-volume.html): cria um volume do EBS que pode ser anexado a uma instância no dispositivo.
+ [--size`value`] — O tamanho do volume de entrada GiBs, que pode ser de 1 GiB a 1 TB ( GiBs1000).
+ [--snapshot-id `value`]: o ID do snapshot a partir do qual criar o volume.
+ [--volume-type `value`]: o tipo de volume. Se nenhum valor for especificado, o padrão será `sbg1`. Os valores possíveis incluem o seguinte:
+ `sbg1` para volumes magnéticos
+ `sbp1` para volumes SSD
+ [--tag-specification `value`]: uma lista de tags a serem aplicadas ao volume durante a criação.
+ [delete-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-launch-template.html)— Exclui um modelo de lançamento. A exclusão de um modelo de execução excluirá todas as suas versões.
Especifique na solicitação o ID ou o nome do modelo de execução.
+ -- launch-template-id `string` — O ID do modelo de lançamento.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [delete-launch-template-version](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-launch-template-version.html)— Exclui uma ou mais versões de um modelo de lançamento. Não é possível excluir a versão padrão de um modelo de execução; primeiro é necessário atribuir outra versão como padrão. Se a versão padrão for a única versão para o modelo de execução, exclua todo o modelo de execução usando o comando `delete-launch-template`.
Especifique na solicitação o ID ou o nome do modelo de execução.
+ -- launch-template-id `string` — O ID do modelo de lançamento.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ --versions (list) `"string" "string"`: os números de versão de uma ou mais versões do modelo de inicialização a serem excluídas.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [delete-security-group](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-security-group.html)— Exclui um grupo de segurança.
Se você tentar excluir um grupo de segurança associado a uma instância ou referenciado por outro grupo de segurança, ocorrerá uma falha na operação com `DependencyViolation`.
+ --group-name `value`: o nome do grupo de segurança.
+ --description `value`: uma descrição do grupo de segurança. Isso é apenas informativo. Esse valor pode ter até 255 caracteres.
+ [delete-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-tags.html): exclui o conjunto de tags especificado do atributo especificado (AMI, instância de computação, modelo de execução ou grupo de segurança).
+ [delete-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-volume.html): exclui o volume do Amazon EBS especificado. O volume deve estar no estado `available` (não anexado a uma instância).
+ --volume-id `value`: o ID do volume.
+ [describe-address](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-addresses.html): descreve um ou mais endereços IP virtuais associados ao mesmo número de instâncias `sbe` no dispositivo.
+ --public-ips – um ou mais endereços IP virtuais associados às instâncias.
+ [describe-images](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-images.html) — Descreve uma ou mais das imagens (AMIs) disponíveis para você. As imagens disponíveis são adicionadas ao dispositivo Snowball Edge durante a criação do trabalho.
+ --image-id: o ID do Snowball da AMI.
+ [describe-instance-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-attribute.html)— Descreve o atributo especificado da instância especificada. Você só pode pesquisar um atributo de cada vez. Há suporte para os seguintes atributos:
+ `instanceInitiatedShutdownBehavior`
+ `instanceType`
+ `userData`
+ [describe-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instances.html) – descreve uma ou mais instâncias. A resposta retorna todos os grupos de segurança atribuídos às instâncias.
+ --instance-ids — A IDs de uma ou mais `sbe` instâncias que foram interrompidas no dispositivo.
+ --page-size: o tamanho de cada página para obtenção na chamada. Esse valor não afeta o número de itens retornados na saída do comando. Definir um tamanho de página menor resulta em mais chamadas para o dispositivo, recuperando menos itens em cada chamada. Fazer isso pode ajudar a evitar que as chamadas atinjam o tempo limite.
+ --max-items: o número total de itens para retornar na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente.
+ --starting-token: um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente.
+ [describe-instance-status](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-instance-status.html)— Descreve o status das instâncias especificadas ou de todas as suas instâncias. Por padrão, somente as instâncias em execução são descritas, a menos que você indique especificamente para exibir o status de todas as instâncias. O status da instância inclui os seguintes componentes:
+ **Verificações de status** — O dispositivo Snow realiza verificações de status na execução EC2 de instâncias compatíveis com a Amazon para identificar problemas de hardware e software.
+ **Estado da instância**: é possível gerenciar as instâncias desde o momento em que as inicia até o encerramento.
Com esse comando, os filtros a seguir são compatíveis.
+ `[--filters]` (lista)
Os filtros.
+ `instance-state-code`: o código do estado da instância, como um valor inteiro não assinado de 16 bits. O byte alto é usado para fins de geração de relatórios de serviços internos e deve ser ignorado. O byte baixo é definido com base no estado representado. Os valores válidos são 0 (pendente), 16 (em execução), 32 (desligando), 48 (encerrado), 64 (interrompendo) e 80 (interrompido).
+ `instance-state-name`: o estado da instância (`pending` \$1 `running` \$1 `shutting-down` \$1 `terminated` \$1 `stopping` \$1 `stopped`).
+ `instance-status.reachability`: filtra o status da instância em que o nome é `reachability` (`passed` \$1 `failed` \$1 `initializing` \$1 `insufficient-data`).
+ `instance-status.status`: o status da instância (`ok` \$1 `impaired` \$1 `initializing` \$1 `insufficient-data` \$1 `not-applicable`).
+ `system-status.reachability`: filtra o status do sistema em que o nome é acessibilidade (`passed` \$1 `failed` \$1 `initializing` \$1 `insufficient-data`).
+ `system-status.status`: o status do sistema da instância (`ok` \$1 `impaired` \$1 `initializing` \$1 `insufficient-data` \$1 `not-applicable`).
+ Sintaxe do JSON:
```
[
{
"Name": "string",
"Values": ["string", ...]
}
...
]
```
+ `[--instance-ids]` (lista)
A instância IDs.
Padrão: descreve todas as instâncias.
+ `[--dry-run|--no-dry-run]` (booliano)
Confere se você tem as permissões necessárias para a ação, sem realmente fazer a solicitação, e fornece uma resposta de erro. Se você tiver as permissões necessárias, a resposta do erro será`DryRunOperation`.
Caso contrário, ele será `UnauthorizedOperation`.
+ `[--include-all-instances | --no-include-all-instances]` (booliano)
Quando `true`, inclui o status de integridade de todas as instâncias. Quando `false`, inclui o status de integridade somente das instâncias em execução.
Padrão: `false`
+ `[--page-size]` (valor inteiro): o tamanho de cada página a ser obtida na chamada. Esse valor não afeta o número de itens retornados na saída do comando. Definir um tamanho de página menor resulta em mais chamadas para o dispositivo, recuperando menos itens em cada chamada. Fazer isso pode ajudar a evitar que as chamadas atinjam o tempo limite.
+ `[--max-items]` (valor inteiro): o número total de itens a serem gerados na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente.
+ `[--starting-token]` (string): um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente.
+ [describe-launch-templates](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-templates.html)— Descreve um ou mais modelos de lançamento. O comando `describe-launch-templates` é uma operação paginada. Você pode realizar várias chamadas para recuperar todo o conjunto de dados de resultados.
Especifique o modelo de lançamento IDs ou os nomes do modelo de lançamento na solicitação.
+ -- launch-template-ids (lista) `"string" "string"` — Uma lista IDs dos modelos de lançamento.
+ -- launch-template-names (list) `"string" "string"` — Uma lista de nomes para os modelos de lançamento.
+ --page-size: o tamanho de cada página para obtenção na chamada. Esse valor não afeta o número de itens retornados na saída do comando. Definir um tamanho de página menor resulta em mais chamadas para o dispositivo, recuperando menos itens em cada chamada. Fazer isso pode ajudar a evitar que as chamadas atinjam o tempo limite.
+ --max-items: o número total de itens para retornar na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente.
+ --starting-token: um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [describe-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-template-versions.html)— Descreve uma ou mais versões de um modelo de lançamento especificado. Você pode descrever todas as versões, versões individuais ou um intervalo de versões. O comando `describe-launch-template-versions` é uma operação paginada. Você pode realizar várias chamadas para recuperar todo o conjunto de dados de resultados.
Especifique o modelo de lançamento IDs ou os nomes do modelo de lançamento na solicitação.
+ -- launch-template-id `string` — O ID do modelo de lançamento.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ [--versions (list) `"string" "string"`]: os números de versão de uma ou mais versões do modelo de inicialização a serem excluídas.
+ [--min-version `string`]: o número da versão a partir da qual serão descritas versões do modelo de inicialização.
+ [--max-version `string`: o número da versão até a qual serão descritas versões do modelo de inicialização.
+ --page-size: o tamanho de cada página para obtenção na chamada. Esse valor não afeta o número de itens retornados na saída do comando. Definir um tamanho de página menor resulta em mais chamadas para o dispositivo, recuperando menos itens em cada chamada. Fazer isso pode ajudar a evitar que as chamadas atinjam o tempo limite.
+ --max-items: o número total de itens para retornar na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente.
+ --starting-token: um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [describe-security-groups](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-security-groups.html)— Descreve um ou mais dos seus grupos de segurança.
O comando `describe-security-groups` é uma operação paginada. É possível emitir várias chamadas da API para recuperar todo o conjunto de dados de resultados.
+ [--group-name `value`]: o nome do grupo de segurança.
+ [--group-id `value`]: o ID do grupo de segurança.
+ [--page-size`value`] — O tamanho de cada página para entrar na chamada de serviço. AWS Esse tamanho não afeta o número de itens retornados na saída do comando. A configuração de um tamanho menor de página ocasiona mais chamadas ao serviço da AWS recuperando menos itens em cada chamada. Essa abordagem pode ajudar a evitar que as chamadas AWS de serviço atinjam o tempo limite. Para obter exemplos de uso, consulte [Pagination](https://docs.aws.amazon.com/cli/latest/userguide/pagination.html) no *Guia do usuário da AWS Command Line Interface *.
+ [--max-items `value`]: o número total de itens a serem exibidos na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente. Não use o elemento de resposta `NextToken` diretamente fora da AWS CLI. Para obter exemplos de uso, consulte [Pagination](https://docs.aws.amazon.com/cli/latest/userguide/pagination.html) no *Guia do usuário da AWS Command Line Interface *.
+ [--starting-token `value`]: um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente. Para obter exemplos de uso, consulte [Pagination](https://docs.aws.amazon.com/cli/latest/userguide/pagination.html) no *Guia do usuário da AWS Command Line Interface *.
+ [describe-tags](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-tags.html): descreve uma ou mais das tags para o atributo especificado (`image`, `instance` ou grupo de segurança). Com esse comando, há suporte para os seguintes filtros:
+ launch-template
+ resource-id
+ resource-type – `image` ou `instance`
+ key
+ valor
+ [describe-volumes](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-volumes.html): descreve os volumes do Amazon EBS especificados.
+ [--max-items `value`]: o número total de itens a serem exibidos na saída do comando. Se o número total de itens disponíveis for maior que o valor especificado, um `NextToken` será fornecido na saída do comando. Para retomar a paginação, forneça o valor `NextToken` no argumento `starting-token` de um comando subsequente.
+ [--starting-token `value`]: um token para especificar onde iniciar a paginação. Esse token é o valor `NextToken` de uma resposta truncada anteriormente.
+ [--volume-ids`value`] — Um ou mais volumes. IDs
+ [detach-volume](https://docs.aws.amazon.com/cli/latest/reference/ec2/detach-volume.html): desanexa um volume do Amazon EBS de uma instância interrompida ou em execução.
+ [--device `value`]: o nome do dispositivo.
+ [--instance-id] — O ID de uma instância de destino da Amazon. EC2
+ --volume-id `value`: o ID do volume.
+ [disassociate-address](https://docs.aws.amazon.com/cli/latest/reference/ec2/disassociate-address.html) – desassocia um endereço IP virtual da instância com a qual está associado.
+ --public-ip: o endereço IP virtual que você deseja dissociar da instância.
+ [get-launch-template-data](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-launch-template-data.html)— Recupera os dados de configuração da instância especificada. Use esses dados para criar um modelo de execução.
+ --instance-id – o ID de uma única instância `sbe`.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [modify-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-launch-template.html)— Modifica um modelo de lançamento. Você pode especificar qual versão do modelo de execução será definida como versão padrão. Ao executar uma instância sem especificar uma versão do modelo de execução, a versão padrão do modelo de execução será aplicada.
Especifique na solicitação o ID ou o nome do modelo de execução.
+ -- launch-template-id `string` — O ID do modelo de lançamento.
+ -- launch-template-name `string` — Um nome para o modelo de lançamento.
+ --default-version `string`: o número da versão do modelo de inicialização a ser definida como versão padrão.
+ --endpoint `snowballEndpoint` — Um valor que permite gerenciar suas instâncias computacionais programaticamente usando operações de API compatíveis com a Amazon EC2. Para obter mais informações, consulte [Especificando o endpoint EC2 compatível como o endpoint AWS CLI em um Snowball Edge](#using-ec2-adapter-cli-endpoint).
+ [modify-instance-attribute](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-instance-attribute.html)— Modifica um atributo da instância especificada. Há suporte para os seguintes atributos:
+ `instanceInitiatedShutdownBehavior`
+ `userData`
+ [revoke-security-group-egress](https://docs.aws.amazon.com/cli/latest/reference/ec2/revoke-security-group-egress.html)— Remove uma ou mais regras de saída de um grupo de segurança:
+ [--group-id `value`]: o ID do grupo de segurança
+ [--ip-permissions `value`]: um ou mais conjuntos de permissões de IP.
+ [revoke-security-group-ingress](https://docs.aws.amazon.com/cli/latest/reference/ec2/revoke-security-group-ingress.html)— Revoga uma ou mais regras de entrada em um grupo de segurança. Ao chamar `revoke-security-group-ingress`, você deve especificar um valor para `group-name` ou para`group-id`.
+ [--group-name `value`]: o nome do grupo de segurança.
+ [--group-id `value`]: o ID do grupo de segurança.
+ [--ip-permissions `value`]: um ou mais conjuntos de permissões de IP.
+ [--protocol `value`] o protocolo IP. Os valores possíveis são `tcp`, `udp` e `icmp`. O argumento `--port` é obrigatório, a menos que o valor "all protocols (todos os protocolos)" seja especificado (-1).
+ [--port `value`]: para TCP ou UDP, o intervalo de portas a ser permitido. Um único número inteiro ou um intervalo (mínimo - máximo).
Para ICMP, um único número inteiro ou um intervalo (`type`-`code`) em que `type` representa o número do tipo ICMP e `code` representa o número do código ICMP. Um valor de -1 indica todos os códigos ICMP para todos os tipos ICMP. Um valor de -1 para `type` indica todos os códigos ICMP para o tipo ICMP especificado.
+ [--cidr `value`: o intervalo de IPs CIDR.
+ [run-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/run-instances.html): inicia várias instâncias de computação usando um ID do Snowball de uma AMI.
**nota**
Pode levar até uma hora e meia para iniciar uma instância de computação em um Snowball Edge, dependendo do tamanho e do tipo de instância.
+ [-- block-device-mappings `(list)]` — As entradas de mapeamento do dispositivo de bloqueio. Os parâmetros `DeleteOnTermination`, `VolumeSize`, e `VolumeType` têm suporte. Os volumes de devem ser do tipo `sbg1`.
A sintaxe JSON para esse comando é conforme a seguir.
```
{
"DeviceName": "/dev/sdh",
"Ebs":
{
"DeleteOnTermination": true|false,
"VolumeSize": 100,
"VolumeType": "sbp1"|"sbg1"
}
}
```
+ --count: número de instâncias a serem iniciadas. Se um único número for fornecido, é considerado como mínimo para iniciar (o padrão é 1). Se um intervalo for fornecido na forma `min:max`, o primeiro número será interpretado como o número mínimo de instâncias a serem iniciadas e o segundo será interpretado como o número máximo de instâncias a serem iniciadas.
+ --image-id: o ID do Snowball da AMI, que pode ser obtido chamando `describe-images`. É necessária uma AMI para executar uma instância.
+ -- InstanceInitiatedShutdownBehavior — Por padrão, quando você inicia um desligamento da sua instância (usando um comando como shutdown ou poweroff), a instância é interrompida. É possível alterar esse comportamento para que, em vez disso, seja encerrada. Os parâmetros `stop` e `terminate` são compatíveis. O padrão é `stop`. Para obter mais informações, consulte [Alteração do comportamento de desligamento iniciado pela instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior) no *Guia do EC2 usuário da Amazon para instâncias Linux*.
+ --instance-type – o tipo de instância `sbe`.
+ --launch-template `structure`: o modelo de inicialização a ser usado para iniciar as instâncias. Os parâmetros especificados no comando `run-instances` substituem os mesmos parâmetros no modelo de execução. Você pode especificar o nome ou o ID de um modelo de execução, mas não ambos.
```
{
"LaunchTemplateId": "string",
"LaunchTemplateName": "string",
"Version": "string"
}
```
+ -- security-group-ids — Um ou mais grupos de segurança IDs. Você pode criar um grupo de segurança usando [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)o. Se nenhum valor for fornecido, o ID do grupo de segurança padrão será atribuído às instâncias criadas.
+ --tag-specifications: as tags a serem aplicadas aos recursos durante a execução. Só é possível marcar instâncias na execução. As tags especificadas são aplicadas a todas as instâncias que são criadas durante a execução. Para marcar um recurso após sua criação, use `create-tags`.
+ --user-data: os dados de usuário que são disponibilizados para a instância. Se você estiver usando o AWS CLI, a codificação base64 será executada para você e você poderá carregar o texto de um arquivo. Caso contrário, você deve fornecer o texto codificado em base64.
+ --key-name (string): o nome do par de chaves. É possível criar um par de chaves usando `CreateKeyPair` ou `ImportKeyPair`.
**Atenção**
Se você não especificar um par de chaves, não conseguirá se conectar à instância a menos que selecione uma AMI configurada para permitir aos usuários uma maneira de fazer login.
+ [start-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/start-instances.html): inicia uma instância `sbe` interrompida anteriormente. Todos os recursos anexados à instância persistem durante inícios e interrupções, mas são apagados se a instância for encerrada.
+ --instance-ids — A IDs de uma ou mais `sbe` instâncias que foram interrompidas no dispositivo.
+ [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html): interrompe uma instância `sbe` em execução. Todos os recursos anexados à instância persistem durante inícios e interrupções, mas são apagados se a instância for encerrada.
+ --instance-ids — A IDs de uma ou mais `sbe` instâncias a serem interrompidas no dispositivo.
+ [terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html): desliga uma ou mais instâncias. Essa operação é idempotente. Se você encerrar uma instância mais de uma vez, cada chamada será bem-sucedida. Todos os atributos anexados à instância persistem aos inícios e interrupções, mas os dados são apagados se a instância for encerrada.
**nota**
Por padrão, ao usar um comando como `shutdown` ou `poweroff` para iniciar um desligamento em sua instância, a instância será interrompida. No entanto, é possível usar o atributo `InstanceInitiatedShutdownBehavior` para alterar o comportamento para que esses comandos encerrem a instância. Para obter mais informações, consulte [Alteração do comportamento de desligamento iniciado pela instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#Using_ChangingInstanceInitiatedShutdownBehavior) no *Guia do EC2 usuário da Amazon para instâncias Linux*.
+ --instance-ids — A IDs de uma ou mais `sbe` instâncias a serem encerradas no dispositivo. Todos os dados associados armazenados para essas instâncias serão perdidos.
+ [create-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-key-pair.html)— Cria um par de chaves RSA de 2048 bits com o nome especificado. A Amazon EC2 armazena a chave pública e exibe a chave privada para você salvar em um arquivo. A chave privada é gerada como uma chave privada PKCS\$11 codificada por PEM descriptografada. Se uma chave com o nome especificado já existir, a Amazon EC2 retornará um erro.
+ --key-name (string): um nome exclusivo para o par de chaves.
Restrições: até 255 caracteres ASCII.
+ [--tag-specifications] (list): as tags a serem aplicadas ao novo par de chaves.
```
{
"ResourceType": "image"|"instance"|"key-pair"|"launch-template"|"security-group",
"Tags": [
{
"Key": "string",
"Value": "string"
}
...
]
}
...
```
+ [import-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/import-key-pair.html) –
+ --key-name (string): um nome exclusivo para o par de chaves.
Restrições: até 255 caracteres ASCII.
+ -- public-key-material (blob) — A chave pública. Para chamadas da API, o texto deve ser codificado em base64. Para ferramentas de linha de comando, a codificação base64 é realizada para você.
+ [--tag-specifications] (list): as tags a serem aplicadas ao novo par de chaves.
```
{
"ResourceType": "image"|"instance"|"key-pair"|"launch-template"|"security-group",
"Tags": [
{
"Key": "string",
"Value": "string"
}
...
]
}
```
+ [describe-key-pairs](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-key-pairs.html) –
[--filters] (list): os filtros.
+ key-pair-id — O ID do par de chaves.
+ key-name: o nome do par de chaves.
+ tag-key: a chave de uma tag atribuída ao recurso. Use esse filtro para encontrar todos os recursos atribuídos a uma tag com uma chave específica, independentemente do valor da tag.
+ [--tag-specifications] (list): as tags a serem aplicadas ao novo par de chaves.
+ tag:key — A key/value combinação de uma tag atribuída ao recurso. Use a chave de etiqueta no nome do filtro e o valor da etiqueta como o valor do filtro. Por exemplo, para encontrar todos os recursos que têm uma etiqueta com a chave `Owner` e o valor `Team A`, especifique `tag:Owner` para o nome do filtro e `Team A` no valor do filtro.
```
{
"Name": "string",
"Values": ["string", ...]
}
...
```
+ [--key-names] (list): os nomes dos pares de chaves.
Padrão: descreve todos os pares de chaves.
+ [--key-pair-ids] (lista) — O IDs dos pares de chaves.
+ [delete-key-pair](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-key-pair.html) –
+ [--key-name] (string): o nome do par de chaves.
+ [--key-pair-id] (string) — O ID do par de chaves.
## Operações de API EC2 compatíveis com a Amazon suportadas em um Snowball Edge
A seguir, você encontrará operações EC2 de API compatíveis com a Amazon que podem ser usadas com o Snowball Edge, com links para suas descrições na * EC2 Amazon* API Reference.As chamadas EC2 de API compatíveis com a Amazon exigem a assinatura do Signature Version 4 (SigV4). Se você estiver usando o AWS CLI ou um AWS SDK para fazer essas chamadas de API, a assinatura SigV4 é feita para você. Caso contrário, você precisará implementar sua própria solução de assinatura do SigV4. Para obter mais informações, consulte [Obter e usar credenciais locais do Amazon S3 no Snowball Edge](using-adapter.md#adapter-credentials).
+ [AssociateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AssociateAddress.html)— Associa um endereço IP elástico a uma instância ou interface de rede.
+ [AttachVolume](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AttachVolume.html)— Os seguintes parâmetros de solicitação são suportados:
+ `Device`
+ `InstanceId`
+ `VolumeId`
+ [AuthorizeSecurityGroupEgress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupEgress.html)— Adiciona uma ou mais regras de saída a um grupo de segurança para uso com um dispositivo Snowball Edge. Especificamente, essa ação permite que as instâncias enviem tráfego para um ou mais intervalos de endereços IPv4 CIDR de destino.
+ [AuthorizeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_AuthorizeSecurityGroupIngress.html)— Adiciona uma ou mais regras de entrada a um grupo de segurança. Ao chamar AuthorizeSecurityGroupIngress, você deve especificar um valor para `GroupName` ou`GroupId`.
+ [CreateVolume](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html)— Os seguintes parâmetros de solicitação são suportados:
+ `SnapshotId`
+ `Size`
+ `VolumeType`
+ `TagSpecification.N`
+ [CreateLaunchTemplate](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateLaunchTemplate.html)— Os seguintes parâmetros de solicitação são suportados:
+ `ImageId`
+ `InstanceType`
+ `SecurityGroupIds`
+ `TagSpecifications`
+ `UserData`
+ [CreateLaunchTemplateVersion](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateLaunchTemplateVersion.html)
+ [CreateTags](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateTags.html)— Os seguintes parâmetros de solicitação são suportados:
+ `AMI`
+ `Instance`
+ `Launch template`
+ `Security group`
+ [CreateSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateSecurityGroup.html)— Cria um grupo de segurança no seu Snowball Edge. Você pode criar até 50 grupos de segurança. Ao criar um grupo de segurança, você especifica um nome amigável de sua escolha.
+ [DeleteLaunchTemplate](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteLaunchTemplate.html)
+ [DeleteLaunchTemplateVersions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteLaunchTemplateVersions.html)
+ [DeleteSecurityGroup](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSecurityGroup.html)— Exclui um grupo de segurança. Se você tentar excluir um grupo de segurança associado a uma instância ou referenciado por outro grupo de segurança, ocorrerá uma falha na operação com `DependencyViolation`.
+ [DeleteTags](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteTags.html)— Exclui o conjunto especificado de tags do conjunto especificado de recursos.
+ [DeleteVolume](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteVolume.html)— Os seguintes parâmetros de solicitação são suportados:
+ `VolumeId`
+ [DescribeAddresses](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeAddresses.html)
+ [DescribeImages](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeImages.html)
+ [DescribeInstanceAttribute](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstanceAttribute.html)— Os seguintes atributos são suportados:
+ `instanceType`
+ `userData`
+ [DescribeInstanceStatus](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstanceStatus.html)
+ [DescribeLaunchTemplates](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeLaunchTemplates.html)
+ [DescribeLaunchTemplateVersions](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeLaunchTemplateVersions.html)
+ [DescribeInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeInstances.html)
+ [DescribeSecurityGroups](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeSecurityGroups.html)— Descreve um ou mais dos seus grupos de segurança. `DescribeSecurityGroups`é uma operação paginada. É possível emitir várias chamadas da API para recuperar todo o conjunto de dados de resultados.
+ [DescribeTags](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeTags.html)— Com esse comando, os seguintes filtros são suportados:
+ `resource-id`
+ `resource-type`: apenas AMI ou instância de computação
+ `key`
+ `value`
+ [DescribeVolume](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeVolumes.html)— Os seguintes parâmetros de solicitação são suportados:
+ `MaxResults`
+ `NextToken`
+ `VolumeId.N`
+ [DetachVolume](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DetachVolumes.html)— Os seguintes parâmetros de solicitação são suportados:
+ `Device`
+ `InstanceId`
+ `VolumeId`
+ [DisassociateAddress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DisassociateAddress.html)
+ [GetLaunchTemplateData](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_GetLaunchTemplateData.html)
+ [ModifyLaunchTemplate](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyLaunchTemplate.html)
+ [ModifyInstanceAttribute](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyInstanceAttribute.html)— Somente o `userData` atributo é suportado.
+ [RevokeSecurityGroupEgress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RevokeSecurityGroupEgress.html)— Remove uma ou mais regras de saída de um grupo de segurança.
+ [RevokeSecurityGroupIngress](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RevokeSecurityGroupIngress.html)— Revoga uma ou mais regras de entrada em um grupo de segurança. Ao chamar RevokeSecurityGroupIngress, você deve especificar um valor para `group-name` ou`group-id`.
+ [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html) –
**nota**
Pode levar até uma hora e meia para iniciar uma instância de computação em um Snowball Edge, dependendo do tamanho e do tipo de instância.
+ [StartInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StartInstances.html)
+ [StopInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_StopInstances.html)— Os recursos associados a uma instância parada persistem. Você pode encerrar a instância para liberar esses atributos. No entanto, todos os dados associados serão excluídos.
+ [TerminateInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TerminateInstances.html)
# Instâncias EC2 compatíveis com inicialização automática com modelos de execução em um Snowball Edge
Você pode iniciar automaticamente suas instâncias EC2 compatíveis com a Amazon em seu AWS Snowball Edge dispositivo usando modelos de execução e comandos de configuração de inicialização do cliente Snowball Edge.
Um *modelo de lançamento* contém as informações de configuração necessárias para criar uma instância EC2 compatível com a Amazon em seu Snowball Edge. Você pode usar um modelo de execução para armazenar parâmetros de execução para não precisar especificá-los toda vez que iniciar uma instância EC2 compatível no Snowball Edge.
Ao usar configurações de inicialização automática no Snowball Edge, você configura os parâmetros com os quais deseja que sua instância EC2 compatível com a Amazon comece. Assim que o Snowball Edge estiver configurado, ao reinicializá-lo e desbloqueá-lo, ele usará a configuração de início automático para iniciar uma instância com os parâmetros especificados. Se uma instância executada usando uma configuração de início automático for interrompida, a instância inicia a execução ao desbloquear o dispositivo.
**nota**
Após a primeira definição de uma configuração de início automático, reinicie o dispositivo para executá-la. Todas as inicializações de instâncias subsequentes (após reinicializações planejadas ou não) acontecerão automaticamente após o dispositivo ser desbloqueado.
Um modelo de execução pode especificar o ID da Amazon Machine Image (AMI), o tipo de instância, os dados do usuário, os grupos de segurança e as tags de uma instância EC2 compatível com a Amazon quando você executa essa instância. Para obter uma lista dos tipos de instâncias compatíveis, consulte [Cotas para instâncias de computação em um dispositivo Snowball Edge](ec2-edge-limits.md).
Para iniciar automaticamente instâncias EC2 compatíveis em seu Snowball Edge, siga as seguintes etapas:
1. Ao solicitar seu AWS Snowball Edge dispositivo, crie um trabalho para solicitar um dispositivo Snowball Edge com instâncias computacionais. Para obter mais informações, consulte [Criação de um trabalho para solicitar um Snowball](https://docs.aws.amazon.com/snowball/latest/developer-guide/create-job-common.html) Edge.
1. Depois de receber o Snowball Edge, desbloqueie-o.
1. Use o comando EC2 -compatible da API `aws ec2 create-launch-template` para criar um modelo de lançamento.
1. Use o comando do cliente Snowball Edge `snowballEdge create-autostart-configuration` para vincular seu modelo de execução EC2 de instância compatível à sua configuração de rede. Para obter mais informações, consulte [Criação de uma configuração EC2 de lançamento compatível em um Snowball Edge](using-ec2-edge-client.md#ec2-edge-create-autostart-config).
1. Reinicie e, depois, desbloqueie o dispositivo. Suas instâncias EC2 compatíveis são iniciadas automaticamente usando os atributos especificados no seu modelo de execução e no comando do cliente do Snowball Edge. `create-autostart-configuration`
Para ver o status de suas instâncias em execução, use o comando EC2 `describe-autostart-configurations` -compatible da API.
**nota**
Não há console ou API de gerenciamento de tarefas para AWS Snowball Edge suporte a modelos de lançamento. Você usa os comandos EC2 -compatible e da CLI do cliente Snowball Edge para EC2 iniciar automaticamente instâncias compatíveis em seu dispositivo. AWS Snowball Edge
# Usando o Instance Metadata Service for Snow com instâncias EC2 compatíveis com a Amazon em um Snowball Edge
O IMDS for Snow fornece o Instance Metadata Service (IMDS) para instâncias EC2 compatíveis com a Amazon no Snow. Os metadados da instância são categorias de informações sobre instâncias. Inclui categorias como *nome do host*, *eventos* e *grupos de segurança*. Usando o IMDS for Snow, você pode usar metadados da instância para acessar os dados do usuário que você especificou ao iniciar sua instância compatível com a Amazon EC2. Por exemplo, você pode usar o IMDS para Snow para especificar parâmetros para configurar a instância ou incluir esses parâmetros em um script simples. Você pode criar dados genéricos AMIs e usar dados do usuário para modificar os arquivos de configuração fornecidos no momento da inicialização.
Para saber mais sobre metadados da instância, dados do usuário e instâncias EC2 compatíveis com o Snow, consulte [Metadados de instâncias suportadas e dados do usuário neste guia](https://docs.aws.amazon.com/snowball/latest/developer-guide/edge-compute-instance-metadata.html).
**Importante**
Embora você só possa acessar os metadados de instância e os dados do usuário de dentro da própria instância, os dados não são protegidos por autenticação ou métodos de criptografia. Qualquer usuário que tenha acesso direto à instância e, potencialmente, qualquer software em execução na instância, pode visualizar seus metadados. Portanto, você não deve armazenar dados confidenciais, como senhas ou chaves de criptografia de longa duração, como dados de usuário.
**nota**
Os exemplos nesta seção usam o IPv4 endereço do serviço de metadados da instância: 169.254.169.254. Não oferecemos suporte à recuperação de metadados da instância usando o endereço local do link IPv6 .
**Topics**
+ [Versões do IMDS em um Snowball Edge](imds-versions.md)
+ [Exemplos de recuperação de metadados de instâncias usando IMDSv1 e IMDSv2 em um Snowball Edge](imds-code-examples.md)
# Versões do IMDS em um Snowball Edge
É possível acessar metadados de instância em uma instância em execução usando o IMDS versão 2 ou o IMDS versão 1:
+ Instance Metadata Service versão 2 (IMDSv2), um método orientado a sessões
+ Instance Metadata Service versão 1 (IMDSv1), um método de solicitação-resposta
Dependendo da versão do seu software Snow, você pode usar IMDSv1 IMDSv2, ou ambos. Isso também depende do tipo de AMI em execução na instância EC2 compatível. Alguns AMIs, como aqueles que executam o Ubuntu 20.04, exigem IMDSv2. O serviço de metadados da instância distingue IMDSv1 e IMDSv2 solicita com base na presença de cabeçalhos `PUT` ou `GET` cabeçalhos. IMDSv2usa esses dois cabeçalhos. IMDSv1 usa somente o `GET` cabeçalho.
AWS incentiva o uso de, IMDSv2 em vez de IMDSv1 porque IMDSv2 inclui maior segurança. Para obter mais informações, consulte [Adicionar defesa aprofundada contra firewalls abertos, proxies reversos e vulnerabilidades de SSRF com aprimoramentos](https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/) no Instance Metadata Service. EC2
## IMDSv2 em um Snowball Edge
Quando você usa IMDSv2 para solicitar metadados da instância, a solicitação precisa seguir estas regras:
1. Use uma solicitação `PUT` para solicitar a inicialização de uma sessão para o serviço de metadados da instância. A solicitação `PUT` exibe um token de sessão que deve ser incluído em solicitações `GET` subsequentes para o serviço de metadados da instância. O token de sessão que define a duração da sessão. A duração da sessão pode variar de um segundo, no mínimo, a seis horas, no máximo. Durante o período especificado, é possível usar o mesmo token de sessão para solicitações subsequentes. Depois que a duração especificada expira, crie um novo token de sessão para uso em solicitações futuras. O token é necessário para acessar os metadados usando IMDSv2.
1. Inclua o token em todas as solicitações `GET` para o serviço de metadados da instância.
1. O token é uma chave específica da instância. O token não é válido em outras instâncias EC2 compatíveis e será rejeitado se você tentar usá-lo fora da instância na qual ele foi gerado.
1. A solicitação `PUT` deve incluir um cabeçalho que especifique a vida útil (TTL) do token, em segundos, até um máximo de seis horas (21.600 segundos). O token representa uma sessão lógica. O TTL especifica o período de validade do token e, portanto, a duração da sessão.
1. Depois que o token expira, para continuar a acessar os metadados da instância, crie uma nova sessão usando outra solicitação `PUT`.
1. É possível optar por reutilizar um token ou criar um novo token para cada solicitação. Para um número pequeno de solicitações, pode ser mais fácil gerar e usar imediatamente um token a cada vez que você precisar acessar o serviço de metadados da instância. Mas, para obter eficiência, é possível especificar uma duração maior para o token e reutilizá-lo, em vez de precisar escrever uma solicitação `PUT` toda vez que precisar solicitar metadados da instância. Não há um limite prático para o número de tokens simultâneos, cada um representando sua própria sessão.
HTTP `GET` e `HEAD` métodos são permitidos em solicitações de metadados de IMDSv2 instância. `PUT`as solicitações são rejeitadas se contiverem um `X-Forwarded-For` cabeçalho.
Por padrão, a resposta a solicitações `PUT` tem um limite de saltos de resposta (vida útil) de 1 no nível de protocolo IP. O IMDS for Snow não tem a capacidade de modificar o limite de salto nas respostas `PUT`.
O exemplo a seguir usa um script de shell do Linux IMDSv2 para recuperar os itens de metadados da instância de nível superior. Esse exemplo:
1. Cria um token de sessão que dura seis horas (21.600 segundos) usando a solicitação `PUT`.
1. Armazena o cabeçalho do token da sessão em uma variável chamada `TOKEN`.
1. Solicita os itens de metadados de nível superior usando o token.
Use dois comandos para gerar o token EC2 compatível. É possível executar os comandos separadamente ou como um único comando.
Primeiro, gere um token usando o comando a seguir.
**nota**
`X-aws-ec2-metadata-token-ttl-seconds` é um cabeçalho obrigatório. Se esse cabeçalho não for incluído, você receberá um código de erro **400 - Parâmetros ausentes ou inválidos**.
```
[ec2-user ~]$ TOKEN=curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"
```
Em seguida, use o token para gerar itens de metadados de nível superior usando o comando a seguir.
```
[ec2-user ~]$ curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/
```
**nota**
Se houver um erro na criação do token, em vez de um token válido, uma mensagem de erro será armazenada na variável e o comando não funcionará.
É possível armazenar o token e combinar os comandos. O exemplo a seguir combina os dois comandos acima e armazena o cabeçalho do token de sessão em uma variável chamada `TOKEN`.
**Example de comandos combinados**
```
[ec2-user ~]$ TOKEN=curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" \
&& curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/
```
Depois de criar um token, é possível reutilizá-lo até que ele expire. No comando de exemplo a seguir, que obtém o ID da AMI usada para executar a instância, o token armazenado em `$TOKEN` no exemplo anterior é reutilizado.
**Example de reutilizar um token**
```
[ec2-user ~]$ curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/ami-id
```
## IMDSv1 em um Snowball Edge
IMDSv1 usa o modelo de solicitação-resposta. Para solicitar metadados da instância, envie uma solicitação `GET` para o serviço de metadados da instância.
```
[ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/
```
Os metadados da sua instância estão disponíveis na sua instância em execução, então você não precisa usar o EC2 console da Amazon ou o AWS CLI para acessá-los. Isso pode ser útil quando você for elaborar scripts a serem executados a partir de sua instância. Por exemplo, é possível acessar o endereço IP local de sua instância a partir dos metadados da instância para gerenciar uma conexão com uma aplicação externa. Os metadados da instância são divididos em categorias. Para obter uma descrição de cada categoria de metadados de instância, consulte [metadados de instância compatíveis e dados do usuário](https://docs.aws.amazon.com/snowball/latest/developer-guide/edge-compute-instance-metadata.html) neste guia.
Para visualizar todas as categorias de metadados da instância de dentro de uma instância em execução, use o seguinte IPv4 URI:
```
http://169.254.169.254/latest/meta-data/
```
Os endereços IP são endereços locais de link e são válidos apenas a partir da instância. Para obter mais informações, consulte [Endereço de link local](https://en.wikipedia.org/wiki/Link-local_address) na Wikipedia.
Todos os metadados de instância são retornados como texto (tipo de conteúdo HTTP `text/plain`).
Uma solicitação para um atributo de metadados específico retorna o valor apropriado, ou um código de erro de HTTP **404 - Not Found** se o atributo não estiver disponível.
Uma solicitação de um recurso de metadados geral (o URI termina com `/`) retorna uma lista de atributos disponíveis, ou um código de erro de HTTP **404 - Not Found** se não houver esse atributo. Os itens da lista estão em linhas separadas que são delimitadas por caracteres de alimentação de linha (ASCII 10).
Para solicitações feitas usando IMDSv1, os seguintes códigos de erro HTTP podem ser retornados:
+ **400 ‐ parâmetros ausentes ou inválidos**: a solicitação `PUT` não é válida.
+ **401 ‐ não autorizado**: a solicitação `GET` usa um token inválido. A ação recomendada é gerar um novo token.
+ **403 ‐ proibido**: a solicitação não é permitida ou o serviço de metadados de instância está desativado.
# Exemplos de recuperação de metadados de instâncias usando IMDSv1 e IMDSv2 em um Snowball Edge
Os exemplos a seguir fornecem comandos que é possível usar em uma instância do Linux.
**Example de obter as versões disponíveis dos metadados da instância**
Este exemplo obtém as versões disponíveis dos metadados da instância. Cada versão indica uma compilação de metadados de instância quando novas categorias de metadados de instância foram lançadas. As versões anteriores estarão disponíveis caso você tenha scripts que contam com a estrutura e as informações presentes em uma versão anterior.
IMDSv2
```
[ec2-user ~]$ TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` && curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/
% Total % Received % Xferd Average Speed Time Time Time Current Dload Upload Total Spent Left Speed
100 56 100 56 0 0 3733 0 --:--:-- --:--:-- --:--:-- 3733
* Trying 169.254.169.254...
* TCP_NODELAY set
* Connected to 169.254.169.254 (169.254.169.254) port 80 (#0)
> GET / HTTP/1.1
> Host: 169.254.169.254
> User-Agent: curl/7.61.1
> Accept: */*
> X-aws-ec2-metadata-token: MDAXcxNFLbAwJIYx8KzgNckcHTdxT4Tt69TzpKExlXKTULHIQnjEtXvD
>
* HTTP 1.0, assume close after body
< HTTP/1.0 200 OK
< Date: Mon, 12 Sep 2022 21:58:03 GMT
< Content-Length: 274
< Content-Type: text/plain
< Server: EC2ws
<
1.0
2007-01-19
2007-03-01
2007-08-29
2007-10-10
2007-12-15
2008-02-01
2008-09-01
2009-04-04
2011-01-01
2011-05-01
2012-01-12
2014-02-25
2014-11-05
2015-10-20
2016-04-19
2016-06-30
2016-09-02
2018-03-28
2018-08-17
2018-09-24
2019-10-01
2020-10-27
2021-01-03
2021-03-23
* Closing connection 0
```
IMDSv1
```
[ec2-user ~]$ curl http://169.254.169.254/
1.0
2007-01-19
2007-03-01
2007-08-29
2007-10-10
2007-12-15
2008-02-01
2008-09-01
2009-04-04
2011-01-01
2011-05-01
2012-01-12
2014-02-25
2014-11-05
2015-10-20
2016-04-19
2016-06-30
2016-09-02
2018-03-28
2018-08-17
2018-09-24
2019-10-01
2020-10-27
2021-01-03
2021-03-23
latest
```
**Example de obter itens de metadados de nível superior**
Este exemplo obtém itens de metadados de nível superior. Para obter informações sobre itens de metadados de nível superior, consulte [Metadados de instâncias compatíveis e dados do usuário](https://docs.aws.amazon.com/snowball/latest/developer-guide/edge-compute-instance-metadata.html) neste guia.
IMDSv2
```
[ec2-user ~]$ TOKEN=`curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600"` && curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/
ami-id
hostname
instance-id
instance-type
local-hostname
local-ipv4
mac
network/
reservation-id
security-groups
```
IMDSv1
```
[ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/
ami-id
hostname
instance-id
instance-type
local-hostname
local-ipv4
mac
network/
reservation-id
security-groups
```
**Example de obter valores de metadados de nível superior**
Os exemplos a seguir obtêm os valores de alguns dos itens de metadados de nível superior que foram obtidos no exemplo anterior. As IMDSv2 solicitações usam o token armazenado que foi criado no comando do exemplo anterior, supondo que ele não tenha expirado.
`ami‐id` IMDSv2
```
curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/ami-id ami-0abcdef1234567890
```
`ami-id` IMDSv1
```
curl http://169.254.169.254/latest/meta-data/ami-id ami-0abcdef1234567890
```
`reservation-id` IMDSv2
```
[ec2-user ~]$ curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/reservation-id r-0efghijk987654321
```
`reservation-id` IMDSv1
```
[ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/reservation-id \
r-0efghijk987654321
```
`local-hostname` IMDSv2
```
[ec2-user ~]$ curl -H "X-aws-ec2-metadata-token: $TOKEN" -v http://169.254.169.254/latest/meta-data/local-hostname ip-00-000-00-00
```
`local-hostname` IMDSv1
```
[ec2-user ~]$ curl http://169.254.169.254/latest/meta-data/local-hostname ip-00-000-00-00
```
# Usando o armazenamento em bloco com instâncias EC2 compatíveis com a Amazon no Snowball Edge
Com armazenamento em blocos no Snowball Edge, é possível adicionar ou remover o armazenamento em blocos com base nas necessidades das aplicações. Os volumes anexados a uma instância EC2 compatível com a Amazon são expostos como volumes de armazenamento que persistem independentemente da vida útil da instância. É possível gerenciar o armazenamento em blocos usando a API conhecida do Amazon EBS.
Alguns comandos do Amazon EBS são compatíveis com o uso do endpoint EC2 compatível. Os comandos com com suporte incluem `attach-volume`, `create-volume`, `delete-volume`, `detach-volume`, e `describe-volumes`. Para obter mais informações sobre esses comandos, consulte [Lista de AWS CLI comandos EC2 compatíveis com suporte em um Snowball Edge](using-ec2-endpoint.md#list-cli-commands-ec2-edge).
**Importante**
Desmonte todos os sistemas de arquivos do dispositivo no sistema operacional antes de desanexar o volume. Não fazer isso pode resultar em perda de dados.
Veja a seguir cotas e diferenças entre os volumes do Amazon EBS no dispositivo e na nuvem:
+ Os volumes do Amazon EBS só estão disponíveis para instâncias EC2 compatíveis em execução no dispositivo que hospeda os volumes.
+ Os tipos de volume são limitados a HDD otimizado para capacidade (`sbg1`) ou SSD otimizado para performance (`sbp1`). O tipo de volume padrão é `sbg1`.
+ O Snowball Edge compartilha memória de HDD entre objetos do Amazon S3 e o Amazon EBS. Se você usar o armazenamento em bloco baseado em HDD ativado AWS Snowball Edge, isso reduzirá a quantidade de memória disponível para objetos do Amazon S3. Da mesma forma, os objetos do Amazon S3 reduzem a quantidade de memória disponível para armazenamento em blocos do Amazon EBS em volumes de HDD.
+ Os volumes raiz EC2 compatíveis com a Amazon sempre usam o driver IDE. Os volumes adicionais do Amazon EBS usarão preferencialmente o driver Virtio, se estiver disponível. Se o driver Virtio não estiver disponível, o SBE usará como padrão o driver IDE. O driver Virtio permite melhor desempenho e é recomendado.
+ Durante a criação de volumes do Amazon EBS, o parâmetro `encrypted` não é compatível. No entanto, todos os dados no seu dispositivo são criptografados por padrão.
+ Os volumes podem ter de 1 GB a 10 TB de tamanho.
+ Até 10 volumes do Amazon EBS podem ser anexados a uma única instância EC2 compatível.
+ Não há um limite formal para o número de volumes do Amazon EBS que você pode ter no dispositivo AWS Snowball Edge . No entanto, a capacidade total do volume do Amazon EBS é limitada pelo espaço disponível no dispositivo.
# Controle do tráfego de rede com grupos de segurança no Snowball Edge
Um *grupo de segurança *atua como um firewall virtual que controla o tráfego de uma ou mais instâncias. Ao executar uma instância, você pode associar um ou mais security groups à instância. Você pode adicionar regras a cada grupo de segurança para permitir tráfego de entrada ou de saída das instâncias associadas. Para obter mais informações, consulte [Grupos EC2 de segurança da Amazon para instâncias Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html) no Guia EC2 do usuário da Amazon.
Os grupos de segurança em dispositivos Snowball Edge são semelhantes a grupos de segurança na Nuvem AWS . Nuvens privadas virtuais (VPCs) não são compatíveis com dispositivos Snowball Edge.
A seguir, você pode encontrar as outras diferenças entre os grupos de segurança do Snowball Edge e os grupos de segurança da EC2 VPC:
+ Cada Snowball Edge tem um limite de cinquenta grupos de segurança.
+ O grupo de segurança padrão permite todo o tráfego de entrada e saída.
+ O tráfego entre instâncias locais pode usar o endereço IP da instância privada ou um endereço IP público. Por exemplo, suponha que você deseja se conectar usando SSH na instância A com a instância B. Nesse caso, seu endereço IP de destino pode ser o IP público ou endereço IP privado da instância B, se a regra de grupo de segurança permitir o tráfego.
+ Somente os parâmetros listados para AWS CLI ações e chamadas de API são compatíveis. Normalmente, eles são um subconjunto dos compatíveis com instâncias de EC2 VPC.
Para obter mais informações sobre AWS CLI as ações suportadas, consulte[Lista de AWS CLI comandos EC2 compatíveis com suporte em um Snowball Edge](using-ec2-endpoint.md#list-cli-commands-ec2-edge). Para obter mais informações sobre as operações da API compatíveis, consulte [Operações de API EC2 compatíveis com a Amazon suportadas em um Snowball Edge](using-ec2-endpoint.md#using-ec2-adapter-supported-api).
# Metadados EC2 de instância e dados do usuário compatíveis com suporte no Snowball Edge
Os *metadados da instância* são dados sobre sua instância que é possível usar para configurar ou gerenciar a instância em execução. O Snowball Edge é compatível com um subconjunto de categorias de metadados das instâncias de computação. Para obter mais informações, consulte [Metadados da instância e dados do usuário](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) no Guia do EC2 usuário da Amazon.
As seguintes categorias são compatíveis. O uso de qualquer outra categoria retornará uma mensagem de erro `404`.
**Categorias de metadados de instância aceitas em um Snowball Edge**
| Dados | Descrição |
| --- | --- |
| ami-id | O ID da AMI usada para executar a instância. |
| hostname | O nome do host IPv4 DNS privado da instância. |
| instance-id | O ID dessa instância. |
| instance-type | O tipo da instância. |
| local-hostname | O nome do host IPv4 DNS privado da instância. |
| local-ipv4 | O IPv4 endereço privado da instância. |
| mac | O endereço Media Access Control (MAC) da instância. |
| network/interfaces/macs/mac/local-hostname | O nome do host local da interface. |
| network/interfaces/macs/mac/local-ipv4s | Os IPv4 endereços privados associados à interface. |
| network/interfaces/macs/mac/mac | O endereço MAC da instância. |
| network/interfaces/macs/mac/public-ipv4s | Os endereços IP elásticos associados à interface. |
| public-ipv4 | O IPv4 endereço público. |
| public-keys/0/openssh-key | Chave pública. Disponível somente se fornecido no momento da execução da instância. |
| reservation-id | O ID da reserva. |
| userData | Scripts de shell para enviar instruções para uma instância na execução. |
**Categorias de dados dinâmicos de instância aceitas em um dispositivo Snowball Edge**
| Dados | Descrição |
| --- | --- |
| instance-identity/document | JSON que contém atributos de instância. Somente instanceId, imageId, privateIp, and instanceType têm valores, e os outros atributos retornados são nulos. Para obter mais informações, consulte [Documentos de identidade de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-identity-documents.html) no Guia EC2 do usuário da Amazon. |
## Dados do usuário da instância de computador no Snowball Edge
Use scripts de shell para acessar os dados do usuário da instância de computação em um dispositivo Snowball Edge. Usando os scripts de shell, você pode enviar instruções para uma instância na execução. Você pode alterar os dados do usuário com o `modify-instance-attribute` AWS CLI comando ou a ação `ModifyInstanceAttribute` da API.
**Para alterar dados do usuário**
1. Pare sua instância de computação com o `stop-instances` AWS CLI comando.
1. Usando o `modify-instance-attribute` AWS CLI comando, modifique o `userData` atributo.
1. Reinicie sua instância de computação com o `start-instances` AWS CLI comando.
Somente scripts de shell são aceitos em instâncias de computação. As diretivas de pacote `cloud-init` não são aceitas em instâncias de computação em execução em um dispositivo Snowball Edge. Para obter mais informações sobre como trabalhar com AWS CLI comandos, consulte a *[Referência de AWS CLI comandos](https://docs.aws.amazon.com/cli/latest/reference/).*
## EC2Interrompendo a execução de instâncias compatíveis no Snowball Edge
Para evitar excluir acidentalmente as instâncias EC2 compatíveis com a Amazon que você cria em um dispositivo, não desligue suas instâncias do sistema operacional. Por exemplo, não use os comandos `shutdown` ou `reboot`. Encerrar uma instância a partir do sistema operacional tem o mesmo efeito que chamar o comando [terminate-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/terminate-instances.html).
Em vez disso, use o comando [stop-instances](https://docs.aws.amazon.com/cli/latest/reference/ec2/stop-instances.html) para suspender as instâncias compatíveis com a EC2 Amazon que você deseja preservar.