# Armazenar os parâmetros de execução de instâncias nos modelos de execução do Amazon EC2
É possível usar um *modelo de execução* do Amazon EC2 para armazenar parâmetros de execução de instâncias para que não seja necessário especificá-los sempre que executar uma instância do Amazon EC2. Por exemplo, você pode criar um modelo de execução que armazene o ID da AMI, o tipo de instância e as configurações de rede que normalmente usa para executar instâncias. Ao iniciar uma instância usando o console do Amazon EC2, um AWS SDK ou uma ferramenta de linha de comando, é possível especificar o modelo de execução em vez de inserir os parâmetros novamente.
Para cada modelo de execução, é possível criar uma ou mais *versões de modelo de execução* numeradas. Cada versão pode ter diferentes parâmetros de execução. Ao executar uma instância a partir de um modelo de execução, será possível usar qualquer versão do modelo de execução. Se você não especificar a versão, a versão padrão será usada. É possível definir qualquer versão do modelo de execução como a versão padrão — por padrão, ela é a primeira versão do modelo de execução.
O diagrama a seguir mostra um modelo de execução com três versões. A primeira versão especifica o tipo de instância, o ID da AMI, a sub-rede e o par de chaves a ser usado para executar a instância. A segunda versão baseia-se na primeira versão e também especifica um grupo de segurança para a instância. A terceira versão usa valores diferentes para alguns parâmetros. A versão 2 é definida como a versão padrão. Se você tiver executado uma instância a partir desse modelo de execução, os parâmetros de execução da versão 2 serão usados caso nenhuma outra versão tenha sido especificada.
![\[Modelo de inicialização com três versões.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/launch-template-diagram.png)
**Topics**
+ [Restrições para modelos de execução do Amazon EC2](launch-template-restrictions.md)
+ [Permissões do IAM necessárias para modelos de execução do Amazon EC2](permissions-for-launch-templates.md)
+ [Usar modelos de execução do Amazon EC2 para controlar a execução de instâncias do Amazon EC2](use-launch-templates-to-control-launching-instances.md)
+ [Criar um modelo de execução do Amazon EC2](create-launch-template.md)
+ [Modificar um modelo de inicialização (gerenciar versões do modelo de inicialização)](manage-launch-template-versions.md)
+ [Excluir um modelo de execução ou uma versão de modelo de execução](delete-launch-template.md)
# Restrições para modelos de execução do Amazon EC2
As seguintes restrições se aplicam aos modelos de execução e às respectivas versões:
+ **Cotas**: para visualizar as cotas para os modelos de execução e as versões de modelos de execução, abra o console do [Service Quotas](https://console.aws.amazon.com/servicequotas/) ou use o comando da AWS CLI [list-service-quotas](https://docs.aws.amazon.com/cli/latest/reference/service-quotas/list-service-quotas.html). Cada conta da AWS pode ter até 5 mil modelos de execução por região e até 10 mil versões por modelo de execução. Suas contas podem ter cotas diferentes com base na idade e no histórico de uso.
+ **Os parâmetros são opcionais**: os parâmetros do modelo de inicialização são opcionais. No entanto, você precisa garantir que a solicitação de execução de uma instância inclua todos os parâmetros necessários. Por exemplo, se o modelo de execução não incluir um ID de AMI, você deverá especificar um ID de AMI ao executar uma instância com esse modelo de execução.
+ **Parâmetros não validados**: os parâmetros do modelo de inicialização não são totalmente validados quando você cria o modelo. Se você especificar valores incorretos ou usar combinações de parâmetros não compatíveis, as instâncias não serão executadas com esse modelo de execução. Para evitar problemas, certifique-se de especificar os valores corretos e de usar as combinações de parâmetros compatíveis. Por exemplo, para executar uma instância em um grupo de posicionamento, especifique um tipo de instância compatível.
+ **Tags**: você pode marcar um modelo de execução, mas não pode marcar uma versão de modelo de execução.
+ **Imutável**: os modelos de execução são imutáveis. Para modificar um modelo de inicialização, é necessário criar uma nova versão do modelo de inicialização.
+ **Números de versão**: as versões de modelo de inicialização são numeradas na ordem em que são criadas. Ao criar uma versão de modelo de execução, você não pode especificar o número de versão por conta própria.
# Permissões do IAM necessárias para modelos de execução do Amazon EC2
É possível usar permissões do IAM para controlar se os usuários podem listar, visualizar, criar ou excluir modelos de execução ou versões de modelos de execução.
**Importante**
Você não pode usar as permissões em nível de recurso para restringir os recursos que os usuários podem especificar em um modelo de execução ao criar um modelo de execução ou uma versão de modelo de execução. Portanto, certifique-se de conceder permissões para a criação de modelos de execução e versões de modelos de execução somente aos administradores confiáveis.
Você deve conceder as permissões necessárias para a criação e para o acesso aos recursos especificados no modelo de execução a qualquer pessoa que usará um modelo de execução. Por exemplo:
+ Para iniciar uma instância usando uma imagem de máquina da Amazon (AMI) privada compartilhada, o usuário deve ter permissão para iniciar a AMI.
+ Para criar volumes do EBS com etiquetas usando snapshots existentes, o usuário deve ter acesso de leitura aos snapshots e permissões para criar e fazer a marcação dos volumes.
**Topics**
+ [ec2:CreateLaunchTemplate](#permissions-for-launch-templates-create)
+ [ec2:DescribeLaunchTemplates](#permissions-for-launch-templates-view)
+ [ec2:DescribeLaunchTemplateVersions](#permissions-for-launch-template-versions-view)
+ [ec2:DeleteLaunchTemplate](#permissions-for-launch-templates-delete)
+ [Controlar permissões de controle de versão](#permissions-for-launch-template-versions)
+ [Controlar o acesso a tags em modelos de execução](#permissions-for-launch-templates-tags)
## ec2:CreateLaunchTemplate
Para criar um modelo de execução no console ou usando as APIs, a entidade principal deve ter a permissão `ec2:CreateLaunchTemplate` em uma política do IAM. Sempre que possível, use tags para ajudar você a controlar o acesso aos modelos de execução na conta.
Por exemplo, a declaração de política do IAM a seguir concede à entidade principal permissão para criar modelos de execução somente se o modelo usa a tag especificada (*`purpose`*=*`testing`*).
```
{
"Sid": "IAMPolicyForCreatingTaggedLaunchTemplates",
"Action": "ec2:CreateLaunchTemplate",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/purpose": "testing"
}
}
}
```
As entidades principais que criam modelos de execução podem precisar de algumas permissões relacionadas, como:
+ **ec2:CreateTags**: para adicionar tags ao modelo de execução durante a operação `CreateLaunchTemplate`, o chamador de `CreateLaunchTemplate` deve ter a permissão `ec2:CreateTags` em uma política do IAM.
+ **ec2:RunInstances**: para iniciar instâncias do EC2 a partir do modelo de execução que criou, a entidade principal também deve ter a permissão `ec2:RunInstances` em uma política do IAM.
Para ações de criação de recursos que aplicam tags, os usuários devem ter a permissão `ec2:CreateTags`. A declaração de política do IAM a seguir usa a chave de condição `ec2:CreateAction` para permitir que os usuários criem tags somente no contexto de `CreateLaunchTemplate`. Os usuários não podem marcar modelos de execução existentes nem nenhum outro recurso. Para obter mais informações, consulte [Conceder permissão para marcar recursos do Amazon EC2 durante a criação](supported-iam-actions-tagging.md).
```
{
"Sid": "IAMPolicyForTaggingLaunchTemplatesOnCreation",
"Action": "ec2:CreateTags",
"Effect": "Allow",
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/*",
"Condition": {
"StringEquals": {
"ec2:CreateAction": "CreateLaunchTemplate"
}
}
}
```
O usuário do IAM que cria um modelo de execução não recebe automaticamente permissão para usar o modelo de execução que criou. Como qualquer outra entidade principal, o criador do modelo de execução precisa obter permissão por meio de uma política do IAM. Se um usuário do IAM quiser iniciar uma instância do EC2 a partir de um modelo de execução, ele deverá ter a permissão `ec2:RunInstances`. Ao conceder essas permissões, é possível especificar que os usuários só poderão usar modelos de execução com tags ou IDs específicos. Você também pode controlar a AMI e outros recursos aos quais qualquer pessoa que use modelos de execução possa fazer referência e usar ao iniciar instâncias especificando permissões em nível de recurso para a chamada `RunInstances`. Para obter exemplos de políticas, consulte [Modelos de execução](ExamplePolicies_EC2.md#iam-example-runinstances-launch-templates).
## ec2:DescribeLaunchTemplates
Para listar e visualizar modelos de execução na conta, a entidade principal deve ter a permissão `ec2:DescribeLaunchTemplates` em uma política do IAM. Porque as ações `Describe` não oferecem suporte a permissões em nível de recurso, é necessário especificá-las sem condições, e o valor do elemento de recurso na política deve ser `"*"`.
Por exemplo, a instrução de política do IAM a seguir concede à entidade principal permissão para listar e visualizar todos os modelos de execução na conta.
```
{
"Sid": "IAMPolicyForDescribingLaunchTemplates",
"Action": "ec2:DescribeLaunchTemplates",
"Effect": "Allow",
"Resource": "*"
}
```
## ec2:DescribeLaunchTemplateVersions
As entidades principais que listam e visualizam modelos de execução também devem ter a permissão `ec2:DescribeLaunchTemplateVersions` para recuperar todo o conjunto de atributos que compõem os modelos de execução.
Para listar e visualizar versões de modelos de execução na conta, a entidade principal deve ter a permissão `ec2:DescribeLaunchTemplateVersions` em uma política do IAM. Porque as ações `Describe` não oferecem suporte a permissões em nível de recurso, é necessário especificá-las sem condições, e o valor do elemento de recurso na política deve ser `"*"`.
Por exemplo, a instrução de política do IAM a seguir concede à entidade principal permissão para listar e visualizar todas as versões de modelos de execução na conta.
```
{
"Sid": "IAMPolicyForDescribingLaunchTemplateVersions",
"Effect": "Allow",
"Action": "ec2:DescribeLaunchTemplateVersions",
"Resource": "*"
}
```
## ec2:DeleteLaunchTemplate
**Importante**
Tenha cuidado ao conceder permissão às entidades principais para excluir um recurso. A exclusão de um modelo de execução pode causar uma falha em um recurso da AWS que depende desse modelo.
Para excluir um modelo de execução, a entidade principal deve ter a permissão `ec2:DeleteLaunchTemplate` em uma política do IAM. Sempre que possível, use chaves de condição baseadas em tag para limitar as permissões.
Por exemplo, a instrução de política do IAM a seguir concederá à entidade principal permissão para excluir modelos de execução somente se o modelo tiver a tag especificada (*`purpose`*=*`testing`*).
```
{
"Sid": "IAMPolicyForDeletingLaunchTemplates",
"Action": "ec2:DeleteLaunchTemplate",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/purpose": "testing"
}
}
}
```
Como alternativa, é possível usar ARNs para identificar o modelo de execução ao qual a política do IAM se aplica.
Um modelo de execução tem o ARN a seguir.
```
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/lt-09477bcd97b0d310e"
```
É possível especificar vários ARNs colocando-os em uma lista ou especificar um valor de `Resource` igual a `"*"` sem o elemento `Condition` para permitir que a entidade principal exclua qualquer modelo de execução na conta.
## Controlar permissões de controle de versão
Para administradores confiáveis, é possível conceder acesso para criar e excluir versões de um modelo de execução e para alterar a versão padrão de um modelo de execução usando políticas do IAM semelhantes aos exemplos a seguir.
**Importante**
Tenha cuidado ao conceder permissão às entidades principais para criar versões de modelos de execução ou modificar esses modelos.
Ao criar uma versão do modelo de execução, você afetará todos os recursos da AWS que permitem que o Amazon EC2 inicie instâncias em seu nome com a versão `Latest`.
Ao modificar um modelo de execução, você pode alterar qual versão é a `Default` e, consequentemente, afetar quaisquer recursos da AWS permitem que o Amazon EC2 inicie instâncias em seu nome com essa versão modificada.
Além disso, é necessário ter cuidado ao lidar com os recursos da AWS que interagem com a versão do modelo de execução `Latest` ou `Default`, como o EC2 Fleet e o Frota Spot. Quando uma versão diferente do modelo de execução é usada para `Latest` ou `Default`, o Amazon EC2 não verifica novamente as permissões para que as ações sejam concluídas ao iniciar novas instâncias para atender à capacidade desejada da frota porque não há interação do usuário com o recurso da AWS. Ao conceder permissão ao usuário para chamar as APIs `CreateLaunchTemplateVersion` e `ModifyLaunchTemplate`, o usuário receberá efetivamente a permissão `iam:PassRole` se apontar a frota para uma versão do modelo de execução diferente que contenha um perfil de instância (um contêiner para um perfil do IAM). Isso significa que um usuário pode atualizar um modelo de execução para transferir um perfil do IAM para uma instância, mesmo que não tenha a permissão `iam:PassRole`. É possível gerenciar esse risco tomando cuidado ao conceder permissões para quem pode criar e gerenciar versões de modelos de execução.
### ec2:CreateLaunchTemplateVersion
Para criar uma nova versão de um modelo de execução, a entidade principal deve ter a permissão `ec2:CreateLaunchTemplateVersion` para o modelo de execução em uma política do IAM.
Por exemplo, a declaração de política do IAM a seguir concede à entidade principal permissão para criar versões de modelos de execução somente se a versão usa a tag especificada (*`environment`*=*`production`*). Como alternativa, você pode especificar um ou vários ARNs de modelo de execução ou especificar um valor de `Resource` igual a `"*"` sem o elemento `Condition` para permitir que a entidade principal crie versões de qualquer modelo de execução na conta.
```
{
"Sid": "IAMPolicyForCreatingLaunchTemplateVersions",
"Action": "ec2:CreateLaunchTemplateVersion",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
```
### ec2:DeleteLaunchTemplateVersion
**Importante**
Como sempre, tenha cuidado ao conceder permissão às entidades principais para excluir um recurso. A exclusão de uma versão de modelo de execução pode causar uma falha em um recurso da AWS que depende dessa versão.
Para excluir uma versão de modelo de execução, a entidade principal deve ter a permissão `ec2:DeleteLaunchTemplateVersion` para o modelo de execução em uma política do IAM.
Por exemplo, a declaração de política do IAM a seguir concede à entidade principal permissão para excluir versões de modelos de execução somente se a versão usa a tag especificada (*`environment`*=*`production`*). Como alternativa, você pode especificar um ou vários ARNs de modelo de execução ou especificar um valor de `Resource` igual a `"*"` sem o elemento `Condition` para permitir que a entidade principal exclua versões de qualquer modelo de execução na conta.
```
{
"Sid": "IAMPolicyForDeletingLaunchTemplateVersions",
"Action": "ec2:DeleteLaunchTemplateVersion",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
```
### ec2:ModifyLaunchTemplate
Para alterar a versão `Default` associada a um modelo de execução, a entidade principal deve ter a permissão `ec2:ModifyLaunchTemplate` para o modelo de execução em uma política do IAM.
Por exemplo, a declaração de política do IAM a seguir concede à entidade principal permissão para modificar modelos de execução somente se o modelo de execução usa a tag especificada (*`environment`*=*`production`*). Como alternativa, você pode especificar um ou vários ARNs de modelo de execução ou especificar um valor de `Resource` igual a `"*"` sem o elemento `Condition` para permitir que a entidade principal modifique qualquer modelo de execução na conta.
```
{
"Sid": "IAMPolicyForModifyingLaunchTemplates",
"Action": "ec2:ModifyLaunchTemplate",
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/environment": "production"
}
}
}
```
## Controlar o acesso a tags em modelos de execução
É possível usar chaves de condição para limitar permissões de tag quando o recurso é um modelo de execução. Por exemplo, a política do IAM a seguir permite remover somente a tag com a chave `temporary` dos modelos de lançamento na conta e região especificadas.
```
{
"Sid": "IAMPolicyForDeletingTagsOnLaunchTemplates",
"Action": "ec2:DeleteTags",
"Effect": "Allow",
"Resource": "arn:aws:ec2:us-east-1:111122223333:launch-template/*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": ["temporary"]
}
}
}
```
Para obter mais informações sobre as chaves de condições que você pode usar para controlar as chaves e valores de tag que podem ser aplicados aos recursos do Amazon EC2, consulte [Controlar o acesso a tags específicas](supported-iam-actions-tagging.md#control-tagging).
# Usar modelos de execução do Amazon EC2 para controlar a execução de instâncias do Amazon EC2
É possível controlar a configuração das instâncias do Amazon EC2 ao especificar que os usuários só poderão executar instâncias se usarem um modelo de execução, e que só poderão usar um modelo de execução específico. Você também pode controlar quem pode criar, modificar, descrever e excluir modelos de inicialização e versões do modelo de inicialização.
## Uso de modelos de execução para controlar parâmetros de execução
Um modelo de execução pode conter todos ou alguns parâmetros para configurar uma instância na execução. No entanto, ao executar uma instância usando um modelo de execução, será possível substituir os parâmetros especificados nele. Ou pode especificar parâmetros adicionais que não estão no modelo de execução.
**nota**
Você não remover os parâmetros do modelo de execução durante a execução (por exemplo, não é possível especificar um valor nulo para o parâmetro). Para remover um parâmetro, crie uma nova versão do modelo de execução sem o parâmetro e use essa versão para executar a instância.
Para executar instâncias, os usuários devem ter permissão para usar a ação `ec2:RunInstances`. Os usuários também devem ter permissões para criar ou usar os recursos que são criados ou estão associados à instância. É possível usar permissões em nível de recurso para a ação `ec2:RunInstances` para controlar os parâmetros de execução que podem ser especificados pelos usuários. Como alternativa, é possível conceder permissões aos usuários para executar uma instância usando um modelo de execução. Isso permite que você gerencie parâmetros de execução em um modelo de execução, em vez de uma política do IAM, e use um modelo de execução como um veículo de autorização para executar instâncias. Por exemplo, é possível especificar que os usuários só podem executar instâncias usando um modelo de execução e só podem usar um modelo de execução específico. Também é possível controlar os parâmetros de execução que os usuários podem substituir no modelo de execução. Para obter exemplos de políticas do , consulte [Modelos de execução](ExamplePolicies_EC2.md#iam-example-runinstances-launch-templates).
## Controlar o uso dos modelos de execução
Por padrão, os usuários não têm permissões para trabalhar com modelos de execução. É possível criar uma política que concede aos usuários permissões para criar, modificar, descrever e excluir modelos de execução e versões do modelo de execução. Também é possível aplicar permissões no nível do recurso a algumas ações do modelo de execução para controlar a capacidade de um usuário de usar recursos específicos nessas ações. Para obter mais informações, consulte as seguintes políticas de exemplo: [Exemplo: trabalhar com modelos de execução](ExamplePolicies_EC2.md#iam-example-launch-templates).
Tenha cuidado ao conceder aos usuários permissões para usar as ações `ec2:CreateLaunchTemplate` e `ec2:CreateLaunchTemplateVersion`. Você não pode usar permissões em nível de recurso para controlar quais recursos os usuários podem especificar no modelo de execução. Para restringir os recursos usados para executar uma instância, conceda permissões para criar modelos de execução e versões de modelo de execução somente a administradores apropriados.
## Aspectos importantes de segurança ao usar modelos de execução com o EC2 Fleet ou o frota spot
Ao usar modelos de execução, você também deve conceder aos usuários permissões para criar, modificar, descrever e excluir modelos de execução e versões de modelo de execução. É possível controlar quem pode criar modelos de lançamento e iniciar versões de modelos controlando o acesso às ações `ec2:CreateLaunchTemplate` e `ec2:CreateLaunchTemplateVersion`. . Também é possível controlar quem pode modificar os modelos de execução controlando o acesso à ação `ec2:ModifyLaunchTemplate`.
**Importante**
Se uma frota spot ou EC2 Fleet estiver configurada para usar a versão mais recente ou padrão do modelo de execução, a frota não saberá se a mais recente ou a padrão foram alteradas posteriormente para apontar para uma versão diferente do modelo de execução. Quando uma versão diferente do modelo de execução é usada para Mais recente ou Padrão, o Amazon EC2 não verifica novamente as permissões para que as ações sejam concluídas ao iniciar novas instâncias para atender à capacidade desejada da frota. Essa é uma consideração importante ao conceder permissões a quem pode criar e gerenciar versões do modelo de execução, especialmente a ação `ec2:ModifyLaunchTemplate`, que permite ao usuário alterar a versão Padrão do modelo de execução.
Ao conceder permissão ao usuário para usar as ações do EC2 para as APIs do modelo de execução, o usuário também recebe efetivamente a permissão `iam:PassRole` se criar ou atualizar uma frota spot ou EC2 Fleet para apontar para uma versão diferente do modelo de execução que contenha um perfil de instância (um contêiner para um perfil do IAM). Isso significa que um usuário pode atualizar um modelo de execução para transferir um perfil do IAM para uma instância, mesmo que não tenha a permissão `iam:PassRole`. Para obter mais informações e um exemplo de política do IAM, consulte [Uso de um perfil do IAM para conceder permissões a aplicações em execução em instâncias do Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html) no *Guia do usuário do IAM*.
Para obter mais informações, consulte [Controlar o uso dos modelos de execução](#launch-template-permissions) e [Exemplo: trabalhar com modelos de execução](ExamplePolicies_EC2.md#iam-example-launch-templates).
# Criar um modelo de execução do Amazon EC2
É possível criar um modelo de execução do Amazon EC2 especificando seus próprios valores para os parâmetros de configuração da instância ou obtendo os valores de um modelo de execução existente ou de uma instância do Amazon EC2.
Você não precisa especificar um valor para cada parâmetro no modelo de execução; você só precisa especificar um parâmetro de configuração da instância para criar um modelo de execução. Para indicar parâmetros que você opta por não especificar, selecione **Não incluir no modelo de execução** ao usar o console. Ao usar uma ferramenta de linha de comandos, não inclua os parâmetros para indicar que você está optando por não especificá-los no modelo de execução.
Se você quiser especificar uma AMI no modelo de execução, você pode selecionar uma AMI ou especificar um parâmetro do Systems Manager que aponte para uma AMI na execução da instância.
Quando uma instância é executada com um modelo de execução, os valores especificados no modelo de execução são usados para configurar os parâmetros de instância correspondentes. Se um valor não for especificado no modelo de execução, o valor padrão para o parâmetro de instância correspondente será usado.
**Topics**
+ [Criar um modelo de execução especificando parâmetros](#create-launch-template-define-parameters)
+ [Criar um modelo de execução a partir de um modelo de execução existente](#create-launch-template-from-existing-launch-template)
+ [Criar um modelo de execução a partir de uma instância](#create-launch-template-from-instance)
+ [Use um parâmetro de Systems Manager em vez de um ID de AMI](#use-an-ssm-parameter-instead-of-an-ami-id)
## Criar um modelo de execução especificando parâmetros
Para criar um modelo de execução, especifique o nome do modelo de execução e, pelo menos, um parâmetro de configuração de instância.
Para uma descrição de cada parâmetro, consulte [Referência para parâmetros de configuração de instâncias do Amazon EC2](ec2-instance-launch-parameters.md).
------
#### [ Console ]
**Para criar um modelo de execução**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Launch Templates (Modelos de execução)** e **Create launch template (Criar modelo de execução)**.
1. Em **Nome e descrição do modelo de execução**, faça o seguinte:
1. Em **Device template name (Nome do modelo de dispositivo)**, insira um nome descritivo para o modelo.
1. Em **Template version description** (Descrição da versão do modelo), forneça uma descrição breve da versão do modelo de execução.
1. Para [marcar](Using_Tags.md) o modelo de execução na criação, expanda **Tags do modelo**, escolha **Adicionar nova tag** e insira um par de chave e valor de tag. Escolha **Adicionar nova tag** novamente para cada tag adicional a acrescentar.
**nota**
Para marcar os recursos que são criados quando uma instância é executada, você deve especificar as etiquetas em **Resource tags** (Etiquetas de recursos). Para obter mais informações, consulte a Etapa 9 neste procedimento.
1. Em **Imagens de SO e aplicações (Amazon Machine Image)**, você pode manter a opção **Não incluir no modelo de execução** selecionada, ou escolher o sistema operacional (SO) da instância, e então escolher uma AMI. Como alternativa, você pode especificar um parâmetro do Systems Manager em vez de especificar uma AMI. Para obter mais informações, consulte [Use um parâmetro de Systems Manager em vez de um ID de AMI](#use-an-ssm-parameter-instead-of-an-ami-id).
Uma AMI é um modelo que contém o sistema operacional e o software necessários para executar uma instância.
1. Em **Tipo de instância**, você pode manter a opção **Não incluir no modelo de execução** selecionada, pode selecionar um tipo de instância ou pode especificar atributos de instância e deixar que o Amazon EC2 identifique os tipos de instância com esses atributos.
**nota**
A especificação de atributos de instância é compatível somente quando o modelo de execução é usado pelos grupos do Auto Scaling, pelo EC2 Fleet e pela frota spot para executar instâncias. Para obter mais informações, consulte [Create mixed instances group using attribute-based instance type selection](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-mixed-instances-group-attribute-based-instance-type-selection.html) e [Especificar atributos para seleção de tipo de instância para frota do EC2 ou frota spot](ec2-fleet-attribute-based-instance-type-selection.md).
Caso planeje usar o modelo de execução no [assistente de inicialização de instâncias](ec2-launch-instance-wizard.md) ou com a [API RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html), você deve especificar os atributos do tipo de instância.
O tipo de instância determina a configuração de hardware (CPU, memória, armazenamento e capacidade de rede) e o tamanho do computador host usado para uma instância.
Se você não tiver certeza de qual tipo de instância escolher, você pode fazer o seguinte:
+ Escolha **Comparar tipos de instâncias** para comparar diferentes tipos de instâncias pelos seguintes atributos: número de vCPUs, arquitetura, quantidade de memória (GiB), quantidade de armazenamento (GB), tipo de armazenamento e performance de rede.
+ Escolha **Obter conselho** para obter orientações e sugestões de tipos de instância no localizador de tipo de instâncias do EC2. Para obter mais informações, consulte [Obtenha recomendações do localizador de tipo de instância do EC2](get-ec2-instance-type-recommendations.md).
**nota**
Dependendo de quando sua conta foi criada, ela pode ser elegível para usar o Amazon EC2 no nível gratuito.
Caso tenha criado sua Conta da AWS antes de 15 de julho de 2025 e ela tenha menos de 12 meses, você pode usar o Amazon EC2 no nível gratuito selecionando o tipo de instância **t2.micro** ou o tipo de instância **t3.micro** em regiões onde o tipo **t2.micro** está indisponível. Lembre-se de que, quando você executa uma instância **t3.micro**, o padrão é o [modo **Ilimitado**](burstable-performance-instances-unlimited-mode.md), o que pode gerar cobranças adicionais com base no uso da CPU. Se um tipo de instância puder ser usada no nível gratuito, ela terá o rótulo **Elegível para o nível gratuito**.
Se você tiver criado sua Conta da AWS a partir de 15 de julho de 2025, poderá usar os tipos de instância **t3.micro**, **t3.small**, **t4g.micro**, **t4g.small**, **c7i-flex.large** e **m7i-flex.large** durante 6 meses ou até seus créditos acabarem.
Para obter mais informações, consulte [Benefícios do nível gratuito antes e depois de 15 de julho de 2025](ec2-free-tier-usage.md#ec2-free-tier-comparison).
1. Em **Par de chaves (login)**, em **Nome do par de chaves**, mantenha a opção **Não incluir no modelo de execução** selecionada ou escolha um par de chaves existente ou crie um novo.
1. Em **Configurações de rede**, você pode manter a opção **Não incluir no modelo de execução** selecionada ou especificar valores para as várias configurações de rede.
1. Em **Configurar armazenamento**, se você especificar uma AMI no modelo de execução, a AMI incluirá um ou mais volumes de armazenamento, incluindo o volume raiz (**Volume 1 [Raiz da AMI]**). Você opcionalmente especificar volumes adicionais a serem anexados à instância. Para adicionar um novo volume, escolha **Add new volume (Adicionar novo volume)**.
1. Em **Tags de recursos**, para [marcar](Using_Tags.md) os recursos que são criados quando uma instância é executada, escolha **Adicionar tag** e, em seguida, insira um par de chave e valor de tag. Em **Resource types** (Tipos de recursos), especifique os recursos para marcar na criação. É possível especificar a mesma etiqueta para todos os recursos ou especificar etiquetas diferentes para recursos diferentes. Escolha **Add tag** (Adicionar tag) para cada tag adicional a acrescentar.
É possível especificar etiquetas tags para os seguintes recursos que são criados quando um modelo de inicialização é usado:
+ Instâncias
+ Volumes
+ Elastic Graphics
+ Solicitações de instância Spot
+ Interfaces de rede
**nota**
Para marcar o modelo de execução em si, é necessário especificar as tags em **Template tags** (Etiquetas de modelo). Para obter mais informações, consulte a Etapa 3 neste procedimento.
1. Em **Detalhes avançados**, expanda a seção para visualizar os campos e, opcionalmente, especifique quaisquer parâmetros adicionais para a instância.
1. Use o painel **Resumo** para analisar a configuração do modelo de execução. É possível navegar para qualquer seção ao escolher um link e, em seguida, realizar as alterações necessárias.
1. Quando você estiver pronto para criar seu modelo de execução, escolha **Create launch template** (Criar modelo de execução).
------
#### [ AWS CLI ]
**Para criar um modelo de execução**
Use o comando [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html).
```
aws ec2 create-launch-template \
--launch-template-name TemplateForWebServer \
--version-description WebVersion1 \
--tag-specifications 'ResourceType=launch-template,Tags=[{Key=purpose,Value=production}]' \
--launch-template-data file://template-data.json
```
Veja a seguir um exemplo em JSON que especifica os dados do modelo de execução para a configuração da instância. Salve o formato JSON em um arquivo e inclua-o no parâmetro `--launch-template-data`, conforme mostrado no comando de exemplo.
```
{
"NetworkInterfaces": [{
"AssociatePublicIpAddress": true,
"DeviceIndex": 0,
"Ipv6AddressCount": 1,
"SubnetId": "subnet-0abcdef1234567890"
}],
"ImageId": "ami-0abcdef1234567890",
"InstanceType": "r5.4xlarge",
"TagSpecifications": [{
"ResourceType": "instance",
"Tags": [{
"Key":"Name",
"Value":"webserver"
}]
}],
"CpuOptions": {
"CoreCount":4,
"ThreadsPerCore":2
}
}
```
O seguinte é um exemplo de saída.
```
{
"LaunchTemplate": {
"LatestVersionNumber": 1,
"LaunchTemplateId": "lt-01238c059e3466abc",
"LaunchTemplateName": "TemplateForWebServer",
"DefaultVersionNumber": 1,
"CreatedBy": "arn:aws:iam::123456789012:root",
"CreateTime": "2017-11-27T09:13:24.000Z"
}
}
```
------
#### [ PowerShell ]
**Para criar um modelo de execução**
Use o cmdlet [New-EC2LaunchTemplate](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2LaunchTemplate.html).
```
$launchTemplateData = [Amazon.EC2.Model.RequestLaunchTemplateData]@{
ImageId = 'ami-0abcdef1234567890'
InstanceType = 'r5.4xlarge'
NetworkInterfaces = @(
[Amazon.EC2.Model.LaunchTemplateInstanceNetworkInterfaceSpecificationRequest]@{
AssociatePublicIpAddress = $true
DeviceIndex = 0
Ipv6AddressCount = 1
SubnetId = 'subnet-0abcdef1234567890'
}
)
TagSpecifications = @(
[Amazon.EC2.Model.LaunchTemplateTagSpecificationRequest]@{
ResourceType = 'instance'
Tags = [Amazon.EC2.Model.Tag]@{
Key = 'Name'
Value = 'webserver'
}
}
)
CpuOptions = [Amazon.EC2.Model.LaunchTemplateCpuOptionsRequest]@{
CoreCount = 4
ThreadsPerCore = 2
}
}
$tagSpecificationData = [Amazon.EC2.Model.TagSpecification]@{
ResourceType = 'launch-template'
Tags = [Amazon.EC2.Model.Tag]@{
Key = 'purpose'
Value = 'production'
}
}
New-EC2LaunchTemplate -LaunchTemplateName 'TemplateForWebServer' `
-VersionDescription 'WebVersion1' `
-LaunchTemplateData $launchTemplateData `
-TagSpecification $tagSpecificationData
```
O seguinte é um exemplo de saída.
```
CreatedBy : arn:aws:iam::123456789012:root
CreateTime : 9/19/2023 16:57:55
DefaultVersionNumber : 1
LatestVersionNumber : 1
LaunchTemplateId : lt-01238c059eEXAMPLE
LaunchTemplateName : TemplateForWebServer
Tags : {purpose}
```
------
## Criar um modelo de execução a partir de um modelo de execução existente
É possível clonar um modelo de inicialização existente e ajustar os parâmetros para criar um novo modelo de inicialização. No entanto, você só pode fazer isso ao usar o console do Amazon EC2. A AWS CLI não é compatível a clonagem de um modelo. Para uma descrição de cada parâmetro, consulte [Referência para parâmetros de configuração de instâncias do Amazon EC2](ec2-instance-launch-parameters.md).
------
#### [ Console ]
**Para criar um modelo de inicialização a partir de um modelo de inicialização existente**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Launch Templates (Modelos de execução)** e **Create launch template (Criar modelo de execução)**.
1. Em **Device template name (Nome do modelo de dispositivo)**, insira um nome descritivo para o modelo.
1. Em **Template version description** (Descrição da versão do modelo), forneça uma descrição breve da versão do modelo de execução.
1. Para marcar o modelo de execução na criação, expanda **Tags de modelo**, escolha **Adicionar nova tag** e então insira um par de chave e valor de tag.
1. Expanda o **Modelo de origem** e, em **Nome do modelo de execução**, escolha um modelo de execução no qual o novo modelo de execução se baseará.
1. Em **Source template version (Versão do modelo de origem)**, escolha a versão do modelo de execução no qual o novo modelo de execução se baseará.
1. Ajuste todos os parâmetros de execução quando necessário e escolha **Create launch template (Criar modelo de execução)**.
------
## Criar um modelo de execução a partir de uma instância
É possível clonar os parâmetros de uma instância existente do Amazon EC2 e ajustá-los para criar um modelo de execução. Para uma descrição de cada parâmetro, consulte [Referência para parâmetros de configuração de instâncias do Amazon EC2](ec2-instance-launch-parameters.md).
------
#### [ Console ]
**Para criar um modelo de inicialização a partir de uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Selecione a instância e escolha **Ações**, **Imagem e modelos**, **Criar modelo da instância**.
1. Forneça um nome, uma descrição e tags e ajuste os parâmetros de execução conforme necessário.
**nota**
Quando você cria um modelo de execução de uma instância, os IDs da interface de rede da instância e os endereços IP não são incluídos no modelo.
1. Escolha **Create launch template (Criar modelo de execução)**.
------
#### [ AWS CLI ]
É possível usar a AWS CLI para criar um modelo de execução de uma instância existente ao obter os dados do modelo de execução primeiro e depois criar um modelo de execução usando os dados dele.
**Para obter dados de modelo de inicialização de uma instância**
+ Use o comando [get-launch-template-data](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-launch-template-data.html) e especifique o ID da instância. É possível usar o resultado como base para criar um novo modelo de execução ou uma versão de modelo de execução. Por padrão, o resultado inclui um objeto `LaunchTemplateData` de nível superior, que não pode ser especificado nos dados do modelo de execução. Use a opção `--query` para excluir este objeto.
```
aws ec2 get-launch-template-data \
--instance-id i-0123d646e8048babc \
--query "LaunchTemplateData"
```
A seguir está um exemplo de saída.
```
{
"Monitoring": {},
"ImageId": "ami-8c1be5f6",
"BlockDeviceMappings": [
{
"DeviceName": "/dev/xvda",
"Ebs": {
"DeleteOnTermination": true
}
}
],
"EbsOptimized": false,
"Placement": {
"Tenancy": "default",
"GroupName": "",
"AvailabilityZone": "us-east-1a"
},
"InstanceType": "t2.micro",
"NetworkInterfaces": [
{
"Description": "",
"NetworkInterfaceId": "eni-35306abc",
"PrivateIpAddresses": [
{
"Primary": true,
"PrivateIpAddress": "10.0.0.72"
}
],
"SubnetId": "subnet-7b16de0c",
"Groups": [
"sg-7c227019"
],
"Ipv6Addresses": [
{
"Ipv6Address": "2001:db8:1234:1a00::123"
}
],
"PrivateIpAddress": "10.0.0.72"
}
]
}
```
É possível gravar o resultado diretamente em um arquivo, por exemplo:
```
aws ec2 get-launch-template-data \
--instance-id i-0123d646e8048babc \
--query "LaunchTemplateData" >> instance-data.json
```
**Para criar um modelo de execução usando dados do modelo de execução**
+ Use o comando [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html) para criar um modelo de execução usando a saída do procedimento anterior. Para obter mais informações sobre como criar um modelo de execução usando a AWS CLI, consulte [Criar um modelo de execução especificando parâmetros](#create-launch-template-define-parameters).
------
## Use um parâmetro de Systems Manager em vez de um ID de AMI
Em vez de especificar um ID de AMI em seus modelos de inicialização, você pode especificar um parâmetro AWS Systems Manager. Se o ID da AMI for alterado, será possível atualizar o ID da AMI em um único lugar atualizando o parâmetro Systems Manager no Systems Manager Parameter Store. Os parâmetros também podem ser [compartilhados](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html) com outras Contas da AWS. É possível armazenar e gerenciar os parâmetros da AMI de forma centralizada em uma conta e compartilhá-los com todas as outras contas que precisam referenciá-los. Usando um parâmetro do Systems Manager, todos os seus modelos de inicialização podem ser atualizados em uma única ação.
Um parâmetro do Systems Manager é um par chave-valor definido pelo usuário que pode ser criado no [Parameter Store do AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html). O Parameter Store fornece um lugar central para armazenar os valores de configuração da aplicação.
No diagrama a seguir, o parâmetro `golden-ami` é mapeado primeiro para a AMI original `ami-aabbccddeeffgghhi` no Parameter Store. No modelo de inicialização, o valor do ID da AMI é `golden-ami`. Quando uma instância é iniciada usando esse modelo de inicialização, o ID da AMI é resolvido para `ami-aabbccddeeffgghhi`. Posteriormente, a AMI é atualizada, resultando em um novo ID de AMI. No Parameter Store, o parâmetro `golden-ami` é mapeado para o novo `ami-00112233445566778`. *O modelo de inicialização permanece inalterado.* Quando uma instância é iniciada usando esse modelo de inicialização, o ID de AMI é resolvido para `ami-00112233445566778`.
![\[Usando os parâmetros do Systems Manager no Parameter Store para atualizar um modelo de inicialização.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/launch-template-ami-alias.png)
### Formato de parâmetros do Systems Manager para IDs de AMI
Os modelos de inicialização exigem que os parâmetros do Systems Manager definidos pelo usuário sigam o seguinte formato quando usados no lugar de um ID de AMI:
+ Tipo de parâmetro: `String`
+ Tipo de dados do parâmetro: `aws:ec2:image`; garante que o Parameter Store valide que o valor inserido está no formato adequado para um ID de AMI.
Para obter mais informações sobre como criar um parâmetro válido para um ID de AMI, consulte [Crie um parâmetro do Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-su-create.html) no *Guia do usuário do AWS Systems Manager*.
### Formato de parâmetros do Systems Manager em modelos de inicialização
Para usar um parâmetro do Systems Manager no lugar de um ID de AMI em um modelo de inicialização, você deve usar um dos seguintes formatos ao especificar o parâmetro no modelo de inicialização:
Para fazer referência a um parâmetro público:
+ `resolve:ssm:public-parameter`
Para fazer referência a um parâmetro armazenado na mesma conta:
+ `resolve:ssm:parameter-name`
+ `resolve:ssm:parameter-name:version-number`: o número da versão em si é um rótulo padrão
+ `resolve:ssm:parameter-name:label`
Para fazer referência a um parâmetro compartilhado de outra Conta da AWS:
+ `resolve:ssm:parameter-ARN`
+ `resolve:ssm:parameter-ARN:version-number`
+ `resolve:ssm:parameter-ARN:label`
**Versões de parâmetros**
Os parâmetros do Systems Manager são recursos versionados. Ao atualizar um parâmetro, você cria novas versões sucessivas do parâmetro. O Systems Manager é compatível com [rótulos de parâmetros](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-labels.html) que você pode mapear para versões específicas de um parâmetro.
Por exemplo, o parâmetro `golden-ami` pode ter três versões: `1`, `2` e `3`. É possível criar um rótulo de parâmetro `beta` que é mapeado para a versão `2` e um rótulo de parâmetro `prod` que é mapeado para a versão `3`.
Em um modelo de inicialização, você pode especificar a versão 3 do parâmetro `golden-ami` usando um dos seguintes formatos:
+ `resolve:ssm:golden-ami:3`
+ `resolve:ssm:golden-ami:prod`
Especificar a versão ou o rótulo é opcional. Por padrão, a versão mais recente do parâmetro é usada quando nenhuma versão é especificada.
### Especificar um parâmetro do Systems Manager em um modelo de inicialização
É possível especificar um parâmetro do Systems Manager em um modelo de inicialização em vez de um ID de AMI ao criar um modelo de inicialização ou uma nova versão de um modelo de inicialização.
------
#### [ Console ]
**Para especificar um parâmetro do Systems Manager em um modelo de inicialização**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, escolha **Launch Templates (Modelos de execução)** e **Create launch template (Criar modelo de execução)**.
1. Em **Device template name (Nome do modelo de dispositivo)**, insira um nome descritivo para o modelo.
1. Em **Application and OS Images (Amazon Machine Image)** (Imagens de aplicações e sistemas operacionais [imagem de máquina da Amazon]), escolha **Browse more AMIs** (Procurar mais AMIs).
1. Escolha o botão de seta à direita da barra de pesquisa e escolha **Especificar valor personalizado/parâmetro do Systems Manager**.
1. Na caixa de diálogo **Especificar valor personalizado ou parâmetro do Systems Manager**, faça o seguinte:
1. Em **ID de AMI ou string de parâmetros do Systems Manager**, insira o nome do parâmetro do Systems Manager usando um destes formatos:
Para fazer referência a um parâmetro público:
+ **resolve:ssm:*public-parameter***
Para fazer referência a um parâmetro armazenado na mesma conta:
+ **resolve:ssm:*parameter-name***
+ **resolve:ssm:*parameter-name*:*version-number***
+ **resolve:ssm:*parameter-name*:*label***
Para fazer referência a um parâmetro compartilhado de outra Conta da AWS:
+ **resolve:ssm:*parameter-ARN***
+ **resolve:ssm:*parameter-ARN*:*version-number***
+ **resolve:ssm:*parameter-ARN*:*label***
1. Escolha **Salvar**.
1. Especifique quaisquer outros parâmetros do modelo de inicialização conforme necessário e escolha **Criar modelo de inicialização**.
Para obter mais informações, consulte [Criar um modelo de execução especificando parâmetros](#create-launch-template-define-parameters).
------
#### [ AWS CLI ]
**Para especificar um parâmetro do Systems Manager em um modelo de inicialização**
+ Use o comando [create-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template.html) para criar o modelo de inicialização. Para especificar a AMI a ser usada, insira o nome do parâmetro do Systems Manager usando um dos seguintes formatos:
Para fazer referência a um parâmetro público:
+ **resolve:ssm:*public-parameter***
Para fazer referência a um parâmetro armazenado na mesma conta:
+ **resolve:ssm:*parameter-name***
+ **resolve:ssm:*parameter-name*:*version-number***
+ **resolve:ssm:*parameter-name*:*label***
Para fazer referência a um parâmetro compartilhado de outra Conta da AWS:
+ **resolve:ssm:*parameter-ARN***
+ **resolve:ssm:*parameter-ARN*:*version-number***
+ **resolve:ssm:*parameter-ARN*:*label***
O exemplo a seguir cria um modelo de execução que especifica o seguinte:
+ Um nome para o modelo de inicialização (`TemplateForWebServer`)
+ Uma etiqueta para o modelo de execução (`purpose`=`production`)
+ Os dados para a configuração da instância, especificados em um arquivo JSON:
+ A AMI a ser usada (`resolve:ssm:golden-ami`)
+ O tipo de instância a ser executada iniciada (`m5.4xlarge`)
+ Uma etiqueta para a instância (`Name`=`webserver`)
```
aws ec2 create-launch-template \
--launch-template-name TemplateForWebServer \
--tag-specifications 'ResourceType=launch-template,Tags=[{Key=purpose,Value=production}]' \
--launch-template-data file://template-data.json
```
Veja a seguir um exemplo de arquivo JSON que contém os dados do modelo de execução para a configuração da instância. O valor de `ImageId` é o nome do parâmetro do Systems Manager, inserido no formato exigido `resolve:ssm:golden-ami`.
```
{"LaunchTemplateData": {
"ImageId": "resolve:ssm:golden-ami",
"InstanceType": "m5.4xlarge",
"TagSpecifications": [{
"ResourceType": "instance",
"Tags": [{
"Key":"Name",
"Value":"webserver"
}]
}]
}
}
```
------
### Verifique se um modelo de execução obtém o ID da AMI correto
**Como resolver o parâmetro do Systems Manager para o ID da AMI real**
Use o comando [describe-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-template-versions.html) e inclua o parâmetro `--resolve-alias`.
```
aws ec2 describe-launch-template-versions \
--launch-template-name my-launch-template \
--versions $Default \
--resolve-alias
```
A resposta inclui o ID da AMI para `ImageId`. Neste exemplo, quando uma instância é iniciada usando esse modelo de execução, o ID da AMI é resolvido como `ami-0ac394d6a3example`.
```
{
"LaunchTemplateVersions": [
{
"LaunchTemplateId": "lt-089c023a30example",
"LaunchTemplateName": "my-launch-template",
"VersionNumber": 1,
"CreateTime": "2022-12-28T19:52:27.000Z",
"CreatedBy": "arn:aws:iam::123456789012:user/Bob",
"DefaultVersion": true,
"LaunchTemplateData": {
"ImageId": "ami-0ac394d6a3example",
"InstanceType": "t3.micro",
}
}
]
}
```
### Recursos relacionados
Para obter mais informações sobre como trabalhar com os parâmetros do Systems Manager, consulte os materiais de referência apresentados a seguir na documentação do Systems Manager.
+ Para obter informações sobre como pesquisar os parâmetros públicos da AMI com suporte para o Amazon EC2, consulte [Calling AMI public parameters](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-public-parameters-ami.html).
+ Para obter informações sobre como compartilhar os parâmetros com outras contas da AWS ou por meio do AWS Organizations, consulte [Working with shared parameters](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-shared-parameters.html).
+ Para obter informações sobre como monitorar se os parâmetros foram criados com êxito, consulte [Native parameter support for Amazon Machine Image IDs](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-ec2-aliases.html).
### Limitações
+ Somente as frotas do EC2 do tipo `instant` oferecem suporte ao uso de um modelo de inicialização que tenha um parâmetro do Systems Manager especificado no lugar de um ID de AMI.
+ As frotas do EC2 dos tipos `maintain` e `request` e as frotas spot não são compatíveis com o uso de um modelo de inicialização que tenha um parâmetro do Systems Manager especificado no lugar de um ID de AMI. Para frotas do EC2 dos tipos `maintain` e `request` e frotas spot, se você especificar uma AMI no modelo de inicialização, deverá especificar o ID da AMI.
+ Se você usar a [seleção de instância baseada em atributos](ec2-fleet-attribute-based-instance-type-selection.md) na frota do EC2, não poderá especificar um parâmetro do Systems Manager no lugar de um ID de AMI. Ao usar a seleção de instância baseada em atributos, você deve especificar o ID da AMI.
+ O Amazon EC2 Auto Scaling fornece outras restrições. Para obter mais informações, consulte [Use AWS Systems Manager parameters instead of AMI IDs in launch templates](https://docs.aws.amazon.com/autoscaling/ec2/userguide/using-systems-manager-parameters.html) no *Guia do usuário do Amazon EC2 Auto Scaling*.
# Modificar um modelo de inicialização (gerenciar versões do modelo de inicialização)
Os modelos de inicialização são imutáveis. Após criar um modelo de inicialização, você não poderá modificá-lo. Em vez disso, é possível criar uma nova versão do modelo de inicialização que inclua as alterações necessárias.
É possível criar diferentes versões de um modelo de execução, definir a versão padrão, descrever uma versão de modelo de execução e [excluir versões](delete-launch-template.md#delete-launch-template-version) que não sejam mais necessárias.
**Topics**
+ [Criar uma versão de modelo de execução](#create-launch-template-version)
+ [Definir a versão do modelo de execução padrão](#set-default-launch-template-version)
+ [Descrever uma versão de modelo de execução](#describe-launch-template-version)
## Criar uma versão de modelo de execução
Ao criar uma versão de modelo de execução, é possível especificar novos parâmetros de execução ou usar uma versão existente como base para a nova versão. Para uma descrição de cada parâmetro, consulte [Referência para parâmetros de configuração de instâncias do Amazon EC2](ec2-instance-launch-parameters.md).
------
#### [ Console ]
**Para criar uma versão de modelo de inicialização**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Launch Templates (Modelos de execução)**.
1. Selecione um modelo de execução e escolha **Actions (Ações)**, **Modify template (Create new version) (Modificar modelo (Criar versão))**.
1. Em **Template version description** (Descrição da versão do modelo), insira uma descrição para a versão do modelo de execução.
1. (Opcional) Expanda o **Source template (Modelo de origem)** e selecione uma versão do modelo de execução a ser usado como base para a nova versão do modelo de execução. A nova versão de modelo de execução herdará os parâmetros de execução desta versão do modelo de execução.
1. Modifique os parâmetros de execução conforme necessário.
1. Escolha **Criar modelo de execução**.
------
#### [ AWS CLI ]
**Para criar uma versão de modelo de inicialização**
Use o comando [create-launch-template-version](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-launch-template-version.html). É possível especificar uma versão de origem na qual a nova versão será baseada. A nova versão herdará os parâmetros de execução desta versão, e será possível substituí-los usando `--launch-template-data`. O exemplo a seguir cria uma nova versão com base na versão 1 do modelo de execução e especifica um ID de AMI diferente.
```
aws ec2 create-launch-template-version \
--launch-template-id lt-0abcd290751193123 \
--version-description WebVersion2 \
--source-version 1 \
--launch-template-data "ImageId=ami-0abcdef1234567890"
```
------
#### [ PowerShell ]
**Para criar uma versão de modelo de inicialização**
Use o cmdlet [New-EC2LaunchTemplateVersion](https://docs.aws.amazon.com/powershell/latest/reference/items/New-EC2LaunchTemplateVersion.html). É possível especificar uma versão de origem na qual a nova versão será baseada. A nova versão herdará os parâmetros de execução desta versão, e será possível substituí-los usando `LaunchTemplateData`. O exemplo a seguir cria uma nova versão com base na versão 1 do modelo de execução e especifica um ID de AMI diferente.
```
New-EC2LaunchTemplateVersion `
-LaunchTemplateId lt-0abcd290751193123 `
-VersionDescription WebVersion2 `
-SourceVersion 1 `
-LaunchTemplateData (
New-Object `
-TypeName Amazon.EC2.Model.RequestLaunchTemplateData `
-Property @{ImageId = 'ami-0abcdef1234567890'}
)
```
------
## Definir a versão do modelo de execução padrão
É possível definir a versão padrão do modelo de execução. Quando você executa uma instância a partir de um modelo de execução e não especifica uma versão, a instância é executada por meio dos parâmetros da versão padrão.
------
#### [ Console ]
**Para definir a versão do modelo de inicialização padrão**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Launch Templates (Modelos de execução)**.
1. Selecione o modelo de execução e escolha **Actions (Ações)**, **Set default version (Definir versão padrão)**.
1. Em **Template version (Versão do modelo)**, selecione o número da versão a ser definida como versão padrão e escolha **Set as default version (Definir como versão padrão)**.
------
#### [ AWS CLI ]
**Para definir a versão do modelo de inicialização padrão**
Use o comando [modify-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/modify-launch-template.html).
```
aws ec2 modify-launch-template \
--launch-template-id lt-0abcd290751193123 \
--default-version 2
```
------
#### [ PowerShell ]
**Para definir a versão do modelo de inicialização padrão**
Use o cmdlet [Edit-EC2LaunchTemplate](https://docs.aws.amazon.com/powershell/latest/reference/items/Edit-EC2LaunchTemplate.html).
```
Edit-EC2LaunchTemplate `
-LaunchTemplateId lt-0abcd290751193123 `
-DefaultVersion 2
```
------
## Descrever uma versão de modelo de execução
Usando o console, é possível visualizar todas as versões do modelo de execução selecionado ou obter uma lista dos modelos de execução cuja versão mais recente ou padrão corresponde a um número de versão específico. Usando o AWS CLI, é possível descrever todas as versões, versões individuais ou um intervalo de versões de um modelo de execução especificado. Também é possível descrever todas as versões mais recentes ou todas as versões padrão de todos os modelos de execução da sua conta.
------
#### [ Console ]
**Para descrever uma versão de modelo de inicialização**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Launch Templates (Modelos de execução)**.
1. É possível visualizar uma versão de um modelo de lançamento específico ou obter uma lista dos modelos de execução cuja versão mais recente ou padrão corresponde a um número de versão específico.
+ Para visualizar uma versão de um modelo de execução: selecione o modelo de execução. Na guia **Versões** em **Versão**, selecione uma versão para visualizar seus detalhes.
+ Para obter uma lista de todos os modelos de execução cuja versão mais recente corresponde a um número de versão específico: na barra de pesquisa, escolha **Versão mais recente** e selecione um número de versão.
+ Para obter uma lista de todos os modelos de execução cuja versão padrão corresponde a um número de versão específico: na barra de pesquisa, escolha **Versão padrão** e selecione um número de versão.
------
#### [ AWS CLI ]
**Para descrever uma versão de modelo de inicialização**
Use o comando [delete-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-template-versions.html) e especifique os números de versão. No exemplo a seguir, as versões `1` e *`3`* são especificadas.
```
aws ec2 describe-launch-template-versions \
--launch-template-id lt-0abcd290751193123 \
--versions 1 3
```
**Para descrever as versões mais recentes e padrão do modelo de inicialização da sua conta**
Use o comando [describe-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/describe-launch-template-versions.html) e especifique `$Latest`, `$Default`, ou ambos. É necessário omitir o ID e o nome do modelo de execução na chamada. Não é possível especificar números de versão.
```
aws ec2 describe-launch-template-versions \
--versions "$Latest,$Default"
```
------
#### [ PowerShell ]
**Para descrever uma versão de modelo de inicialização**
Use o cmdlet [Get-EC2TemplateVersion](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2TemplateVersion.html) e especifique os números da versão. No exemplo a seguir, as versões `1` e *`3`* são especificadas.
```
Get-EC2TemplateVersion `
-LaunchTemplateId lt-0abcd290751193123 `
-Version 1,3
```
**Para descrever as versões mais recentes e padrão do modelo de inicialização da sua conta**
Use o cmdlet [Get-EC2TemplateVersion](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-EC2TemplateVersion.html) e especifique `$Latest`, `$Default` ou ambos. É necessário omitir o ID e o nome do modelo de execução na chamada. Não é possível especificar números de versão.
```
Get-EC2TemplateVersion `
-Version '$Latest','$Default'
```
------
# Excluir um modelo de execução ou uma versão de modelo de execução
Caso não precise mais de um modelo de execução, exclua-o. A exclusão de um modelo de execução excluirá todas as suas versões. Caso queira excluir apenas uma versão específica de um modelo de execução, será possível fazê-lo e manter as outras versões do modelo de execução.
Excluir um modelo de execução ou uma versão de modelo de execução não afetará nenhuma instância que você executou nele.
## Excluir um modelo de execução e todas as suas versões
Caso não precise mais de um modelo de execução, incluindo todas as suas versões, você pode excluí-lo. A exclusão de um modelo de execução excluirá todas as suas versões.
------
#### [ Console ]
**Para excluir um modelo de execução e todas as suas versões**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Launch Templates (Modelos de execução)**.
1. Selecione o modelo de execução e escolha **Actions (Ações)**, **Delete template (Excluir modelo)**.
1. Digite **Delete** para confirmar a exclusão e escolha **Delete (Excluir)**.
------
#### [ AWS CLI ]
**Para excluir um modelo de execução e todas as suas versões**
Use o comando [delete-launch-template](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-launch-template.html) e especifique o modelo de execução.
```
aws ec2 delete-launch-template --launch-template-id lt-01238c059e3466abc
```
------
#### [ PowerShell ]
**Para excluir um modelo de execução e todas as suas versões**
Use o comando [Remove-EC2LaunchTemplate](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2LaunchTemplate.html) (Ferramentas da AWS para PowerShell) e especifique o modelo de execução. Se `-Force` for omitido, o PowerShell solicitará uma confirmação.
```
Remove-EC2LaunchTemplate -LaunchTemplateId lt-0123456789example -Force
```
------
## Excluir uma versão de modelo de execução
Caso não precise mais de uma versão de modelo de execução, exclua-a.
**Considerações**
+ Não é possível substituir o número de versão após excluí-lo.
+ Não é possível excluir a versão padrão do modelo de execução; antes é necessário atribuir outra versão como a 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](#delete-launch-template).
+ No console, é possível excluir uma versão do modelo de execução por vez. Usando a AWS CLI, é possível excluir até 200 versões do modelo de execução em uma única solicitação. Para excluir mais de 200 versões em uma única solicitação, [exclua o modelo de execução](#delete-launch-template), o que também exclui todas as suas versões.
------
#### [ Console ]
**Para excluir uma versão de modelo de inicialização**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, selecione **Launch Templates (Modelos de execução)**.
1. Selecione o modelo de execução e escolha **Actions (Ações)**, **Delete template version (Excluir versão de modelo)**.
1. Selecione a versão a ser excluída e escolha **Delete (Excluir)**.
------
#### [ AWS CLI ]
**Para excluir uma versão de modelo de inicialização**
Use o comando [delete-launch-template-versions](https://docs.aws.amazon.com/cli/latest/reference/ec2/delete-launch-template-versions.html) e especifique os números de versão a serem excluídos. É possível especificar até 200 versões do modelo de execução para excluir em uma única solicitação.
```
aws ec2 delete-launch-template-versions \
--launch-template-id lt-0abcd290751193123 \
--versions 1
```
------
#### [ PowerShell ]
**Para excluir uma versão de modelo de inicialização**
Use o cmdlet [Remove-EC2TemplateVersion](https://docs.aws.amazon.com/powershell/latest/reference/items/Remove-EC2TemplateVersion.html) e especifique os números de versão a serem excluídos. É possível especificar até 200 versões do modelo de execução para excluir em uma única solicitação.
```
Remove-EC2TemplateVersion `
-LaunchTemplateId lt-0abcd290751193123 `
-Version 1
```
------