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á.
# Tutorial: Usar script de dados e metadados de instância para recuperar o estado do ciclo de vida
Uma forma comum de criar ações personalizadas para ganchos de ciclo de vida é usar notificações que o Amazon EC2 Auto Scaling envia para outros serviços, como a Amazon. EventBridge No entanto, usando um script de dados do usuário para mover o código que configura instâncias e conclui a ação do ciclo de vida para as próprias instâncias, você pode evitar a necessidade de criar infraestrutura adicional.
O tutorial a seguir mostra como começar a usar um script de dados do usuário e metadados de instância. Você cria uma configuração básica de grupo do Auto Scaling com um script de dados do usuário que lê o [estado de destino do ciclo de vida](retrieving-target-lifecycle-state-through-imds.md) das instâncias em seu grupo e executa uma ação de retorno de chamada em uma fase específica do ciclo de vida de uma instância para continuar o processo de execução.
A ilustração a seguir resume o fluxo de um evento de aumento a escala horizontalmente quando você usa um script de dados do usuário para executar uma ação personalizada. Depois da execução de uma instância, o ciclo de vida da instância é pausado até que o gancho do ciclo de vida seja concluído, seja por tempo limite ou pelo Amazon EC2 Auto Scaling recebendo um sinal para continuar.
![\[O fluxo de um evento de aumento a escala horizontalmente quando você usa um script de dados do usuário para executar uma ação personalizada.\]](http://docs.aws.amazon.com/pt_br/autoscaling/ec2/userguide/images/lifecycle-hook-user-data-script.png)
**Topics**
+ [Etapa 1: criar um perfil do IAM com permissões para concluir ações do ciclo de vida](#instance-metadata-create-iam-role)
+ [Etapa 2: criar um modelo de execução e incluir o perfil do IAM e um script de dados de usuário](#instance-metadata-create-hello-world-function)
+ [Etapa 3: criar um grupo do Auto Scaling](#instance-metadata-create-auto-scaling-group)
+ [Etapa 4: Adicionar um gancho do ciclo de vida](#instance-metadata-add-lifecycle-hook)
+ [Etapa 5: testar e verificar a funcionalidade](#instance-metadata-testing-hook)
+ [Etapa 6: limpar](#instance-metadata-lifecycle-hooks-tutorial-cleanup)
+ [Recursos relacionados](#instance-metadata-lifecycle-hooks-tutorial-related-resources)
## Etapa 1: criar um perfil do IAM com permissões para concluir ações do ciclo de vida
Ao usar o AWS CLI ou um AWS SDK para enviar um retorno de chamada para concluir as ações do ciclo de vida, você deve usar uma função do IAM com permissões para concluir as ações do ciclo de vida.
**Para criar a política**
1. Abra a página [Policies](https://console.aws.amazon.com/iam/home?#/policies) (Políticas) do console do IAM e escolha **Create policy** (Criar política).
1. Selecione a guia **JSON**.
1. Na caixa **Policy Document** (Documento de política), copie e cole o seguinte documento de política. **sample text**Substitua o pelo número da sua conta e pelo nome do grupo Auto Scaling que você deseja criar ()**TestAutoScalingEvent-group**.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"autoscaling:CompleteLifecycleAction"
],
"Resource": "arn:aws:autoscaling:*:123456789012:autoScalingGroup:*:autoScalingGroupName/TestAutoScalingEvent-group"
}
]
}
```
------
1. Escolha **Próximo**.
1. Em **Nome da política**, insira **TestAutoScalingEvent-policy**. Selecione **Criar política**.
Quando você terminar de criar a política, poderá criar uma função que a utilize.
**Para criar o perfil**
1. No painel de navegação à esquerda, escolha **Roles (Funções)**.
1. Selecione **Criar perfil**.
1. Em **Select trusted entity** (Selecionar entidade confiável), escolha **AWS Service** (Serviço).
1. Para seu caso de uso, escolha **EC2** e escolha **Next** (Próximo).
1. Em **Adicionar permissões**, escolha a política que você criou (**TestAutoScalingEvent-policy**). Em seguida, escolha **Próximo**.
1. Na página **Name, review, and create** (Nomear, revisar e criar), em **Role name** (Nome da função), insira **TestAutoScalingEvent-role** e escolha **Create role** (Criar função).
## Etapa 2: criar um modelo de execução e incluir o perfil do IAM e um script de dados de usuário
Crie um modelo de execução para usar com seu grupo do Auto Scaling. Inclua o perfil do IAM que você criou e a amostra de script de dados do usuário fornecida.
**Para criar um modelo de execução**
1. Abra a página [Launch templates](https://console.aws.amazon.com/ec2/v2/#LaunchTemplates) (Modelos de execução) do console do Amazon EC2.
1. Escolha **Criar modelo de execução**.
1. Para o **Launch template name** (Nome do modelo de execução), insira **TestAutoScalingEvent-template**.
1. Em **Auto Scaling guidance** (Guia do Auto Scaling), marque a caixa de seleção.
1. Para **Imagens de aplicação e SO (Amazon Machine Image)**, escolha Amazon Linux 2 (HVM), SSD Volume Type, 64 bits (x86) na lista **Quick Start** (Início rápido).
1. Em **Instance type** (Tipo de instância), escolha um tipo de instância do Amazon EC2 (p. ex., “t2.micro”).
1. Em **Advanced details** (Detalhes avançados), expanda a seção para visualizar os campos.
1. Para o **perfil da instância do IAM**, escolha o nome do perfil da instância do IAM da sua função do IAM (**TestAutoScalingEvent-role**). Um perfil de instância é um contêiner para um perfil do IAM que permite ao Amazon EC2 passar o perfil do IAM para uma instância quando ela é iniciada.
Se tiver criado um perfil do IAM usando o console do IAM, o console terá criado automaticamente um perfil da instância e dará a esse perfil o mesmo nome da função correspondente.
1. Em **User data** (Dados do usuário), copie e cole a seguinte amostra de script de dados de usuário no campo. Substitua o texto de amostra pelo `group_name` nome do grupo de Auto Scaling que você deseja criar e `region` pelo que Região da AWS você deseja que seu grupo de Auto Scaling use.
```
#!/bin/bash
function token {
echo "X-aws-ec2-metadata-token: $(curl -X PUT 'http://169.254.169.254/latest/api/token' -H 'X-aws-ec2-metadata-token-ttl-seconds: 21600')"
}
function get_target_state {
echo $(curl -H "$(token)" -s http://169.254.169.254/latest/meta-data/autoscaling/target-lifecycle-state)
}
function get_instance_id {
echo $(curl -H "$(token)" -s http://169.254.169.254/latest/meta-data/instance-id)
}
function complete_lifecycle_action {
instance_id=$(get_instance_id)
group_name='TestAutoScalingEvent-group'
region='us-west-2'
echo $instance_id
echo $region
echo $(aws autoscaling complete-lifecycle-action \
--lifecycle-hook-name TestAutoScalingEvent-hook \
--auto-scaling-group-name $group_name \
--lifecycle-action-result CONTINUE \
--instance-id $instance_id \
--region $region)
}
function main {
while true
do
target_state=$(get_target_state)
if [ \"$target_state\" = \"InService\" ]; then
# Change hostname
export new_hostname="${group_name}-$instance_id"
hostname $new_hostname
# Send callback
complete_lifecycle_action
break
fi
echo $target_state
sleep 5
done
}
main
```
Esse script de dados de usuário simples faz o seguinte:
+ Chama os metadados da instância para recuperar o estado de destino do ciclo de vida e o ID da instância nos metadados da instância
+ Recupera o estado de destino do ciclo de vida repetidamente até que ele mude para `InService`
+ Altera o nome de host da instância para o ID da instância tendo como prefixo o nome do grupo do Auto Scaling, se o estado de destino do ciclo de vida for `InService`
+ Envia um retorno de chamada chamando o comando **complete-lifecycle-action** da CLI para sinalizar o Amazon EC2 Auto Scaling a `CONTINUE` o processo de execução do EC2
1. Escolha **Criar modelo de execução**.
1. Na página de confirmação, escolha **Create Auto Scaling group** (Criar grupo do Auto Scaling).
**nota**
Para outros exemplos que você pode usar como referência para desenvolver seu script de dados de usuário, consulte o [GitHub repositório](https://github.com/aws-samples/amazon-ec2-auto-scaling-group-examples) do Amazon EC2 Auto Scaling.
## Etapa 3: criar um grupo do Auto Scaling
Depois de criar seu modelo de execução, crie um grupo do Auto Scaling.
**Para criar um grupo do Auto Scaling**
1. Na página **Choose launch template or configuration** (Escolher o modelo ou a configuração de execução), em **Auto Scaling group name** (Nome do grupo do Auto Scaling), insira um nome para o grupo do Auto Scaling (**TestAutoScalingEvent-group**).
1. Escolha **Next** (Próximo) e acesse a página **Choose instance launch options** (Escolher as opções de execução de instância).
1. Em **Network** (Rede), selecione uma VPC.
1. Em **Availability Zones and subnets** (Zonas de disponibilidade e sub-redes), escolha uma ou mais sub-redes de uma ou mais zonas de disponibilidade.
1. Na seção **Instance type requirements** (Requisitos de tipo de instância), use a configuração padrão para simplificar essa etapa. (Não substitua o modelo de execução.) Neste tutorial, você fará o execução de apenas uma das Instâncias sob demanda usando o tipo de instância especificado no modelo de execução.
1. Selecione **Skip to review** (Pular para a revisão) na parte inferior da tela.
1. Na página **Review** (Revisar), reveja as configurações do grupo do Auto Scaling e escolha **Create Auto Scaling group** (Criar grupo do Auto Scaling).
## Etapa 4: Adicionar um gancho do ciclo de vida
Adicione um gancho do ciclo de vida para manter a instância em um estado de espera até que a ação do ciclo de vida esteja concluída.
**Para adicionar um gancho do ciclo de vida**
1. Abra a página de [grupos do Auto Scaling](https://console.aws.amazon.com/ec2/v2/home?#AutoScalingGroups) do console do Amazon EC2.
1. Marque a caixa de seleção ao lado do seu grupo do Auto Scaling. Um painel dividido é aberto na parte inferior da página.
1. No painel inferior, na guia **Instance management** (Gerenciamento de instâncias), em **Lifecycle ganchos** (Ganchos do ciclo de vida), escolha **Create lifecycle gancho** (Criar gancho do ciclo de vida).
1. Para definir um gancho do ciclo de vida para expansão (execução de instâncias), faça o seguinte:
1. Em **Lifecycle gancho name** (Nome do gancho do ciclo de vida), insira **TestAutoScalingEvent-hook**.
1. Em **Lifecycle transition** (Transição do ciclo de vida), escolha **Instance launch** (Início da instância).
1. Em **Heartbeat timeout** (Tempo limite de pulsação), insira **300** para o número de segundos de espera por um retorno de chamada do seu script de dados de usuário.
1. Em **Default result** (Resultado padrão), escolha **ABANDON** (Abandono). Se o hook expirar sem receber um retorno de chamada do script de dados de usuário, o grupo do Auto Scaling encerrará a nova instância.
1. (Opcional) Mantenha **Notification metadata** (Metadados de notificação) em branco.
1. Escolha **Criar**.
## Etapa 5: testar e verificar a funcionalidade
Para testar a funcionalidade, atualize o grupo do Auto Scaling aumentando em 1 a capacidade desejada do grupo do Auto Scaling. O script de dados de usuário é executado e começa a verificar o estado de destino do ciclo de vida da instância logo após a execução da instância. O script altera o nome do host e envia uma ação de retorno de chamada quando o estado de destino do ciclo de vida for `InService`. Isso geralmente leva apenas alguns segundos para terminar.
**Para aumentar o tamanho de grupo do Auto Scalin**
1. Abra a página de [grupos do Auto Scaling](https://console.aws.amazon.com/ec2/v2/home?#AutoScalingGroups) do console do Amazon EC2.
1. Marque a caixa de seleção ao lado do seu grupo do Auto Scaling. Veja os detalhes em um painel inferior enquanto ainda vê as linhas superiores do painel superior.
1. No painel inferior, na guia **Details** (Detalhes), escolha **Group details** (Detalhes do grupo, **Edit** (Editar).
1. Em **Desired capacity (Capacidade desejada)**, aumente o valor atual em 1.
1. Selecione **Atualizar**. Enquanto a instância está sendo iniciada ou terminada, a coluna **Status** no painel superior exibe um status *Updating capacity* (Atualizando capacidade).
Após aumentar a capacidade desejada, você pode verificar na descrição das ações de escalabilidade se sua instância foi executada com êxito e não foi encerrada.
**Para visualizar as atividades de escalabilidade**
1. Retorne á página **Auto Scaling groups** (Grupos do Auto Scaling) e selecione seu grupo.
1. Na guia **Activity** (Atividade), em **Activity history** (Histórico de atividades), a coluna **Status** exibe se o seu grupo do Auto Scaling iniciou uma instância com êxito.
1. Se o script de dados de usuário falhar, você observará uma ação de escalabilidade com um status de `Canceled` e uma mensagem de status de `Instance failed to complete user's Lifecycle Action: Lifecycle Action with token e85eb647-4fe0-4909-b341-a6c42EXAMPLE was abandoned: Lifecycle Action Completed with ABANDON Result` após o término do período de tempo limite.
## Etapa 6: limpar
Se tiver terminado de trabalhar com os recursos que criou exclusivamente para este tutorial, siga as etapas abaixo para excluí-los.
**Para excluir o gancho do ciclo de vida**
1. Abra a página de [grupos do Auto Scaling](https://console.aws.amazon.com/ec2/v2/home?#AutoScalingGroups) do console do Amazon EC2.
1. Marque a caixa de seleção ao lado do seu grupo do Auto Scaling.
1. Na guia **Instance management** (Gerenciamento de instâncias), em **Lifecycle ganchos** (Ganchos do ciclo de vida), escolha o gancho do ciclo de vida (`TestAutoScalingEvent-hook`).
1. Selecione **Ações**, **Excluir**.
1. Para confirmar, escolha **Delete** (Excluir) novamente.
**Para excluir o modelo de execução**
1. Abra a página [Launch templates](https://console.aws.amazon.com/ec2/v2/#LaunchTemplates) (Modelos de execução) do console do Amazon EC2.
1. Selecione seu modelo de execução (`TestAutoScalingEvent-template`) e escolha **Actions** (Ações), **Delete template** (Excluir modelo).
1. Quando a confirmação for solicitada, digite **Delete** para confirmar a exclusão do modelo de execução especificado e, em seguida, escolha **Excluir**.
Se tiver terminado de trabalhar com o grupo de exemplo do Auto Scaling, exclua-o. Você também pode excluir o perfil do IAM e a política de permissões que criou.
**Para excluir o grupo do Auto Scaling**
1. Abra a página de [grupos do Auto Scaling](https://console.aws.amazon.com/ec2/v2/home?#AutoScalingGroups) do console do Amazon EC2.
1. Marque a caixa de seleção ao lado do seu grupo do Auto Scaling (`TestAutoScalingEvent-group`) e escolha **Delete** (Excluir).
1. Quando a confirmação for solicitada, digite **delete** para confirmar a exclusão do grupo do Auto Scaling especificado e, em seguida, escolha **Excluir**.
Um ícone de carregamento na coluna **Name** (Nome) indica que o grupo do Auto Scaling está sendo excluído. É necessário aguardar alguns minutos para encerrar a instância e excluir o grupo.
**Para excluir o perfil do IAM**
1. Abra a página [Roles](https://console.aws.amazon.com/iam/home?#/roles) (Funções) no console do IAM.
1. Selecione o papel da função (`TestAutoScalingEvent-role`).
1. Escolha **Excluir**.
1. Quando for solicitada confirmação, digite o nome da função e escolha **Excluir**.
**Para excluir a política do IAM**
1. Abra a [página Policies](https://console.aws.amazon.com/iam/home?#/policies) (Políticas) do console do IAM.
1. Selecione a política que você criou (`TestAutoScalingEvent-policy`).
1. Selecione **Ações**, **Excluir**.
1. Quando for solicitada confirmação, digite o nome da política e escolha **Excluir**.
## Recursos relacionados
Os tópicos relacionados a seguir podem ser úteis à medida que você desenvolve um código que invoca ações em instâncias com base nos dados disponíveis nos metadados da instância.
+ [Recuperar o estado de destino do ciclo de vida por meio de metadados de instância](retrieving-target-lifecycle-state-through-imds.md). Esta seção descreve o estado do ciclo de vida de outros casos de uso, como o encerramento da instância.
+ [Adicionar ganchos do ciclo de vida (console)](adding-lifecycle-hooks.md#adding-lifecycle-hooks-console). Este procedimento mostra como adicionar ganchos do ciclo de vida tanto para expansão (execução de instâncias) quanto para redução (instâncias encerrando ou retornando a um pool ativo).
+ [Categorias de metadados de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html#instancedata-data-categories) no *Guia do usuário do Amazon EC2 para instâncias do Linux*. Este tópico lista todas as categorias de metadados de instância que você pode usar para invocar ações em instâncias do EC2.
Para ver um tutorial que mostra como usar a Amazon EventBridge para criar regras que invocam funções Lambda com base em eventos que acontecem com as instâncias em seu grupo de Auto Scaling, consulte. [Tutorial: Configurar um gancho do ciclo de vida que invoca uma função do Lambda](tutorial-lifecycle-hook-lambda.md)