

# Conceitos básicos do CloudFormation
<a name="GettingStarted"></a>

Você pode começar a usar o CloudFormation por meio do Console de gerenciamento da AWS criando uma pilha a partir de um modelo de exemplo, o que ajudará você a aprender os fundamentos da criação de pilhas. Um *modelo* é um arquivo de texto que define todos os recursos em uma pilha. Uma *pilha* é a implantação de um modelo do CloudFormation. Com um único modelo, é possível criar várias pilhas. Cada pilha contém uma coleção de recursos da AWS que podem ser gerenciados como uma unidade.

O CloudFormation é um serviço gratuito, porém os recursos da AWS que você incluir nas pilhas serão cobrados segundo as tarifas correntes de cada um deles. Para obter mais informações sobre o preço da AWS, acesse a página de detalhes de cada produto em [http://aws.amazon.com](https://aws.amazon.com/).

**Vídeo: conceitos básicos do CloudFormation**  
O vídeo a seguir é uma introdução à criação de pilhas do CloudFormation via Console de gerenciamento da AWS.

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/1h-GPXQrLZw?si=MYHlJvBkE3DspKcL/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/1h-GPXQrLZw?si=MYHlJvBkE3DspKcL)


**Topics**
+ [

# Como o CloudFormation funciona
](cloudformation-overview.md)
+ [

# Cadastrar-se em uma Conta da AWS
](cfn-sign-up-for-aws.md)
+ [

# Criar sua primeira pilha
](gettingstarted.walkthrough.md)

# Como o CloudFormation funciona
<a name="cloudformation-overview"></a>

Este tópico descreve como o CloudFormation funciona e apresenta os principais conceitos que você precisa conhecer ao usá-lo.

**Topics**
+ [

## Principais conceitos
](#cfn-whatis-concepts)
+ [

## Como o CloudFormation funciona
](#cfn-whatis-howdoesitwork)
+ [

## Maneiras de começar a usar o CloudFormation
](#ways-to-get-started)

## Principais conceitos
<a name="cfn-whatis-concepts"></a>

Ao usar o CloudFormation, você trabalha com *modelos* e *pilhas*. Você cria modelos para descrever os recursos da AWS e suas respectivas propriedades. Sempre que você cria uma pilha, o CloudFormation provisiona os recursos descritos no modelo.

**Topics**
+ [

### Modelos
](#cfn-concepts-templates)
+ [

### Pilhas
](#cfn-concepts-stacks)
+ [

### Conjuntos de alterações
](#cfn-concepts-change-sets)

### Modelos
<a name="cfn-concepts-templates"></a>

Um modelo do CloudFormation é um arquivo de texto formatado em YAML ou JSON. Você pode salvar esses arquivos com qualquer extensão, por exemplo, `.yaml`, `.json`, `.template` ou `.txt`. O CloudFormation usa esses modelos como esquemas para a criação dos recursos da AWS. Por exemplo, em um modelo, é possível descrever uma instância do Amazon EC2, como o tipo de instância, o ID da AMI, os mapeamentos de dispositivos de blocos e o nome do par de chaves do Amazon EC2. Sempre que cria uma pilha, você também deve especificar um modelo usado pelo CloudFormation para criar o que você descreveu no modelo.

Por exemplo, caso você tenha criado uma pilha usando o modelo a seguir, o CloudFormation provisiona uma instância com uma ID da AMI `ami-0ff8a91507f77f867`, um tipo de instância `t2.micro`, um nome do par de chaves `testkey` e um volume do Amazon EBS.

#### YAML
<a name="t2-micro-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample template
Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: t2.micro
      KeyName: testkey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
```

#### JSON
<a name="t2-micro-example.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "A sample template",
    "Resources": {
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-0ff8a91507f77f867",
                "InstanceType": "t2.micro",
                "KeyName": "testkey",
                "BlockDeviceMappings": [
                    {
                        "DeviceName": "/dev/sdm",
                        "Ebs": {
                            "VolumeType": "io1",
                            "Iops": 200,
                            "DeleteOnTermination": false,
                            "VolumeSize": 20
                        }
                    }
                ]
            }
        }
    }
}
```

Também é possível especificar vários recursos em um único modelo e configurar esses recursos para que funcionem juntos. Por exemplo, é possível modificar o modelo anterior para incluir um endereço IP elástico (EIP) e associá-lo à instância Amazon EC2, conforme mostrado no seguinte exemplo:

#### YAML
<a name="multiple-resources-single-template.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample template
Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: t2.micro
      KeyName: testkey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
  MyEIP:
    Type: AWS::EC2::EIP
    Properties:
      InstanceId: !Ref MyEC2Instance
```

#### JSON
<a name="multiple-resources-single-template.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "A sample template",
    "Resources": {
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-0ff8a91507f77f867",
                "InstanceType": "t2.micro",
                "KeyName": "testkey",
                "BlockDeviceMappings": [
                    {
                        "DeviceName": "/dev/sdm",
                        "Ebs": {
                            "VolumeType": "io1",
                            "Iops": 200,
                            "DeleteOnTermination": false,
                            "VolumeSize": 20
                        }
                    }
                ]
            }
        },
        "MyEIP": {
            "Type": "AWS::EC2::EIP",
            "Properties": {
                "InstanceId": {
                    "Ref": "MyEC2Instance"
                }
            }
        }
    }
}
```

Os modelos anteriores se baseiam em uma instância do Amazon EC2 única. No entanto, os modelos do CloudFormation têm recursos adicionais que é possível usar para criar conjuntos complexos de recursos e reutilizar esses modelos em vários contextos. Por exemplo, é possível adicionar parâmetros de entrada cujos valores são especificados quando você cria uma pilha do CloudFormation. Em outras palavras, você pode especificar um valor como o tipo de instância ao criar uma pilha, em vez de quando cria o modelo, o que facilita a reutilização do modelo em situações diferentes.

### Pilhas
<a name="cfn-concepts-stacks"></a>

Ao usar o CloudFormation, você gerencia recursos relacionados como uma única unidade, chamada pilha. Você pode criar, atualizar e excluir um conjunto de recursos criando, atualizando e excluindo pilhas. Todos os recursos em uma pilha são definidos pelo modelo CloudFormation dela. Suponhamos que você tenha criado um modelo que inclui um grupo do Auto Scaling, um load balancer do Elastic Load Balancing e uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS). Para criar esses recursos, você cria uma pilha enviando o modelo que criou, e o CloudFormation provisiona todos esses recursos para você.

### Conjuntos de alterações
<a name="cfn-concepts-change-sets"></a>

Caso precise fazer alterações nos recursos em execução em uma pilha, você atualiza a pilha. Antes de fazer alterações nos recursos, você pode gerar um conjunto de alterações, que é o resumo das alterações propostas. Os conjuntos de alterações permitem ver como as alterações podem afetar os recursos em execução, especialmente para recursos críticos, antes de implementá-las.

Por exemplo, se você alterar o nome de uma instância de banco de dados do Amazon RDS, o CloudFormation criará um novo banco de dados e excluirá o anterior. Você perderá os dados no banco de dados anterior, a menos que já tenha feito backup deles. Se gerar um conjunto de alterações, você verá que a alteração fará o banco de dados ser substituído, e poderá planejar de acordo antes de atualizar a pilha. 

## Como o CloudFormation funciona
<a name="cfn-whatis-howdoesitwork"></a>

Quando você usa o CloudFormation para criar sua pilha, o CloudFormation faz chamadas de serviço subjacentes à AWS para provisionar e configurar os recursos descritos no seu modelo. Você precisa de permissão para criar esses recursos. Por exemplo, para criar instâncias do EC2 usando o CloudFormation, você precisa ter permissões para criar instâncias. Você gerencia essas permissões com [AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/) (IAM).

As chamadas que o CloudFormation faz são todas declaradas por seu modelo. Por exemplo, suponha que você tem um modelo que descreve uma instância EC2 com um tipo de instância `t2.micro`. Quando você usa esse modelo para criar uma pilha, o CloudFormation chama a API de criação de instância do Amazon EC2 e especifica o tipo de instância como `t2.micro`. O diagrama a seguir resume o fluxo de trabalho do CloudFormation para a criação de pilhas.

![\[Um modelo criado ou existente que é salvo localmente, ou em um bucket, usado para criar uma pilha.\]](http://docs.aws.amazon.com/pt_br/AWSCloudFormation/latest/UserGuide/images/create-stack-diagram.png)


**Para criar uma pilha**

1. Use um editor de texto para criar um modelo do CloudFormation no formato YAML ou JSON. O modelo de CloudFormation descreve os recursos que você deseja e suas configurações. Use [Compositor de Infraestrutura da AWS](infrastructure-composer-for-cloudformation.md) para visualizar e validar seu modelo. Isso ajuda você a garantir que seu modelo esteja adequadamente estruturado e livre de erros de sintaxe. Para obter mais informações, consulte [Trabalhar com modelos do CloudFormation](template-guide.md).

1. Salve o modelo do localmente ou em um bucket do Amazon S3.

1. Crie uma pilha do CloudFormation especificando o local de seu arquivo de modelo, como um caminho em seu computador local ou um URL do Amazon S3. Se o modelo contiver parâmetros, você poderá especificar valores de entrada ao criar a pilha. Os parâmetros permitem que você passe valores para seu modelo, para que possa personalizar seus recursos toda vez que você criar uma pilha.
**nota**  
Se você especificar um arquivo de modelo armazenado localmente, o CloudFormation o carregará em um bucket do S3 na sua conta da AWS. O CloudFormation cria um bucket para cada região na qual você carrega um arquivo de modelo. Os buckets são acessíveis a qualquer pessoa com permissões do Amazon Simple Storage Service (Amazon S3) na sua conta da AWS. Se um bucket criado pelo CloudFormation já estiver presente, o modelo será adicionado a esse bucket.  
É possível utilizar seu próprio bucket e gerenciar suas permissões carregando modelos manualmente no Amazon S3. Em seguida, sempre que você criar ou atualizar uma pilha, especifique o URL do Amazon S3 de um arquivo de modelo.

Depois que todos os recursos foram criados, o CloudFormation informa que sua pilha foi criada. Em seguida, você pode começar a usar os recursos de sua pilha. Se houver falha na criação da pilha, o CloudFormation reverterá as alterações excluindo os recursos que ele criou.

### Atualizar uma pilha com um conjunto de alterações
<a name="updating-stack-with-change-sets"></a>

Quando precisar atualizar os recursos da pilha, você poderá modificar o modelo da pilha. Você não precisa criar uma nova pilha e excluir a antiga. Para atualizar uma pilha, crie um conjunto de alterações enviando uma versão modificada do modelo da pilha original, diferentes valores de parâmetros de entrada ou ambos. O CloudFormation compara o modelo modificado com o modelo original e gera um conjunto de alterações. O conjunto de alterações lista as alterações propostas. Depois de revisar as alterações, você pode iniciar o conjunto de alterações para atualizar sua pilha ou pode criar um novo conjunto de alterações. O diagrama a seguir resume o fluxo de trabalho da atualização de uma pilha.

![\[Um modelo usando um conjunto de alterações para visualizar o valor modificado antes de executar o conjunto de alterações para atualizar a pilha.\]](http://docs.aws.amazon.com/pt_br/AWSCloudFormation/latest/UserGuide/images/update-stack-diagram.png)


**Para atualizar uma pilha com um conjunto de alterações**

1. Você pode modificar um modelo de pilha do CloudFormation usando o [Compositor de Infraestrutura da AWS](infrastructure-composer-for-cloudformation.md) ou um editor de texto. Para obter mais informações, consulte [Atualizar seu modelo de pilha](using-cfn-updating-stacks-get-template.md).

   Ao atualizar seu modelo, lembre-se de que as atualizações podem causar interrupções. Dependendo do recurso e das propriedades que você está atualizando, uma atualização pode interromper ou até substituir um recurso existente. Para obter mais informações, consulte [Compreender atualização de comportamentos de recursos da pilha](using-cfn-updating-stacks-update-behaviors.md).

1. Salve o modelo do CloudFormation localmente ou em um bucket do S3.

1. Crie um conjunto de alterações especificando a pilha que você deseja atualizar e o local do modelo modificado, como um caminho no seu computador local ou um URL do Amazon S3. Para obter mais informações sobre como criar conjuntos de alterações, consulte [Atualizar pilhas do CloudFormation usando conjuntos de alterações](using-cfn-updating-stacks-changesets.md).
**nota**  
Se você especificar um modelo armazenado em seu computador local, o CloudFormation carregará esse modelo automaticamente em um bucket do S3 na sua Conta da AWS.

1. Visualize o conjunto de alterações para verificar se o CloudFormation executará as alterações que você espera. Por exemplo, verifique se o CloudFormation substituirá todos os recursos cruciais da pilha. Você pode criar quantos conjuntos de alterações precisar até ter incluído as alterações desejadas.
**Importante**  
Os conjuntos de alterações não indicam se a atualização da pilha será bem-sucedida. Por exemplo, um conjunto de alterações não verifica se você vai ultrapassar a [cota](cloudformation-limits.md) de uma conta, se estiver atualizando um recurso que não permita alterações nem se tem [permissões](control-access-with-iam.md) suficientes para modificar um recurso, o que pode provocar falha em uma atualização de pilha.

1. Inicie o conjunto de alterações que você deseja aplicar à sua pilha. O CloudFormation atualiza a pilha atualizando apenas os recursos que você modificou e sinaliza que sua pilha foi atualizada com êxito. Se houver falha na atualização da pilha, o CloudFormation reverterá as alterações para restaurar a pilha para o estado de funcionamento conhecido mais recente.

## Maneiras de começar a usar o CloudFormation
<a name="ways-to-get-started"></a>

Para criar uma pilha Hello world do CloudFormation com o console, consulte [Criar sua primeira pilha](gettingstarted.walkthrough.md).

Para um aprendizado guiado, experimente o workshop [Introdução ao CloudFormation](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US), que oferece experiência prática com desenvolvimento de modelos.

# Cadastrar-se em uma Conta da AWS
<a name="cfn-sign-up-for-aws"></a>

Ao cadastrar-se na AWS, sua Conta da AWS é automaticamente cadastrada em todos os serviços da AWS, incluindo o CloudFormation. Se você já tiver uma Conta da AWS, pule para o próximo tópico. Se você não tem uma Conta da AWS, siga o procedimento abaixo para criar uma.

## Inscrever-se para uma Conta da AWS
<a name="sign-up-for-aws"></a>

Se você ainda não tem uma Conta da AWS, siga as etapas abaixo para criar uma.

**Como cadastrar uma Conta da AWS**

1. Abra [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup).

1. Siga as instruções online.

   Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.

   Quando você se inscreve para uma Conta da AWS, um *Usuário raiz da conta da AWS* é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

A AWS envia um e-mail de confirmação depois que o processo de inscrição é concluído. A qualquer momento, é possível exibir as atividades da conta atual e gerenciar sua conta acessando [https://aws.amazon.com/](https://aws.amazon.com/) e selecionando **Minha conta**.

## Criar um usuário com acesso administrativo
<a name="create-an-admin"></a>

Depois de se cadastrar em uma Conta da AWS, proteja seu Usuário raiz da conta da AWS, habilite o Centro de Identidade do AWS IAM e crie um usuário administrativo para não usar o usuário-raiz em tarefas cotidianas.

**Proteger o Usuário raiz da conta da AWS**

1.  Faça login no [Console de gerenciamento da AWS](https://console.aws.amazon.com/) como o proprietário da conta ao escolher a opção **Usuário-raiz** e inserir o endereço de e-mail da Conta da AWS. Na próxima página, insira a senha.

   Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS*.

1. Habilite a autenticação multifator (MFA) para o usuário-raiz.

   Para obter instruções, consulte [Habilitar um dispositivo MFA virtual para sua Conta da AWS de usuário-raiz (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) no *Guia do usuário do IAM*.

**Criar um usuário com acesso administrativo**

1. Habilita o Centro de Identidade do IAM.

   Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.

1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.

   Para obter um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como a fonte de identidade, consulte [Configurar o acesso dos usuários com o Diretório do Centro de Identidade do IAM padrão](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.

**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.

  Para obter ajuda para fazer login usando um usuário do Centro de Identidade do IAM, consulte [Fazer login no portal de acesso da AWS](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html), no *Guia do usuário do Início de Sessão da AWS*.

**Atribuir acesso a usuários adicionais**

1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.

   Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.

1. Atribua usuários a um grupo e, em seguida, atribua o acesso de autenticação única ao grupo.

   Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM*.

**nota**  
Para obter mais informações sobre como gerenciar quem acessa o quê, consulte [Controle o acesso ao CloudFormation com o AWS Identity and Access Management](control-access-with-iam.md).

# Criar sua primeira pilha
<a name="gettingstarted.walkthrough"></a>

Este tópico mostra a você o passo a passo da criação da sua primeira pilha do CloudFormation usando o Console de gerenciamento da AWS. Seguindo este tutorial, você aprenderá a provisionar recursos básicos da AWS, monitorar eventos de pilha e gerar saídas.

Neste exemplo, o modelo do CloudFormation é escrito em YAML. O YAML é um formato legível por humanos que é amplamente usado para definir infraestrutura como código. À medida que aprender mais sobre o CloudFormation, também poderá encontrar outros modelos no formato JSON, mas para este tutorial, o YAML é escolhido por sua legibilidade.

**nota**  
O CloudFormation é gratuito, mas os recursos do Amazon EC2 e do Amazon S3 que você criar serão cobrados. Porém, se você for novo na AWS, poderá aproveitar o [nível gratuito](https://aws.amazon.com/free/) para minimizar ou eliminar os custos durante este processo de aprendizagem.

**Topics**
+ [

## Pré-requisitos
](#getting-started-prerequisites)
+ [

## Criar uma pilha do CloudFormation com o console
](#getting-started-create-stack)
+ [

## Monitorar a criação da pilha
](#getting-started-monitor-stack-creation)
+ [

## Testar o servidor Web
](#getting-started-test-web-server)
+ [

## Solução de problemas
](#getting-started-troubleshooting)
+ [

## Limpeza
](#getting-started-clean-up)
+ [

## Próximas etapas
](#getting-started-next-steps)

## Pré-requisitos
<a name="getting-started-prerequisites"></a>
+ Você deve ter acesso a uma Conta da AWS com um usuário ou perfil do IAM que tenha permissões para usar o Amazon EC2, o Amazon S3 e o CloudFormation ou ter acesso de usuário administrativo.
+ Você deve ter uma nuvem privada virtual (VPC) que tenha acesso à internet. Este modelo passo a passo requer uma VPC padrão, que vem automaticamente com as Contas da AWS mais recentes. Se você não tiver uma VPC padrão, ou se ela tiver sido excluída, consulte a seção de solução de problemas neste tópico para ver as soluções alternativas.

## Criar uma pilha do CloudFormation com o console
<a name="getting-started-create-stack"></a>

**Para criar uma pilha Hello world do CloudFormation com o console**

1. Abra o [console do CloudFormation](https://console.aws.amazon.com/cloudformation/).

1. Selecione **Create Stack** (Criar pilha).

1. Na página **Criar pilha**, escolha **Compilar do Infrastructure Composer** e depois **Criar no Infrastructure Composer**. Isso leva você ao Infrastructure Composer no modo de console do CloudFormation, onde você pode carregar e validar o exemplo de modelo.

1. Para carregar e validar o modelo de exemplo, faça o seguinte:

   1. Escolha **Modelos**. Depois, copie e cole o seguinte modelo do CloudFormation no editor de modelos:

      ```
      AWSTemplateFormatVersion: 2010-09-09
      Description: CloudFormation Template for WebServer with Security Group and EC2 Instance
      
      Parameters:
        LatestAmiId:
          Description: The latest Amazon Linux 2 AMI from the Parameter Store
          Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
          Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'
      
        InstanceType:
          Description: WebServer EC2 instance type
          Type: String
          Default: t2.micro
          AllowedValues:
            - t3.micro
            - t2.micro
          ConstraintDescription: must be a valid EC2 instance type.
          
        MyIP:
          Description: Your IP address in CIDR format (e.g. 203.0.113.1/32).
          Type: String
          MinLength: '9'
          MaxLength: '18'
          Default: 0.0.0.0/0
          AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
          ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
      
      Resources:
        WebServerSecurityGroup:
          Type: AWS::EC2::SecurityGroup
          Properties:
            GroupDescription: Allow HTTP access via my IP address
            SecurityGroupIngress:
              - IpProtocol: tcp
                FromPort: 80
                ToPort: 80
                CidrIp: !Ref MyIP
      
        WebServer:
          Type: AWS::EC2::Instance
          Properties:
            ImageId: !Ref LatestAmiId
            InstanceType: !Ref InstanceType
            SecurityGroupIds:
              - !Ref WebServerSecurityGroup
            UserData: !Base64 |
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<html><body><h1>Hello World!</h1></body></html>" > /var/www/html/index.html
      
      Outputs:
        WebsiteURL:
          Value: !Join
            - ''
            - - http://
              - !GetAtt WebServer.PublicDnsName
          Description: Website URL
      ```

      Antes de passar para a próxima etapa, vamos examinar o modelo e entender alguns conceitos-chave do Lambda.
      + A seção **`Parameters`** declara os valores que podem ser passados para o modelo quando você cria a pilha. Os recursos especificados posteriormente nesse modelo fazem referência a esses valores e usam os dados. Parâmetros são uma maneira eficaz de especificar informações que você não deseja armazenar no modelo em si. Também são uma maneira de especificar informações que sejam exclusivas da aplicação ou da configuração que você estiver implantando.
      + O modelo define os seguintes parâmetros:
        + **`LatestAmiId`**: recupera o ID do Amazon Linux 2 AMI mais recente da AWS Systems Manager Parameter Store.
        + **`InstanceType`**: permite a seleção do tipo de instância do EC2 (padrão: `t2.micro`, permitido: `t3.micro`, `t2.micro`). 
        + **`MyIP`**: especifica o intervalo de endereços IP para acesso por HTTP (padrão: 0.0.0.0/0, permitindo acesso de qualquer IP).
      + A seção **`Resources`** contém as definições dos recursos da AWS que você deseja criar com o modelo. As declarações de recursos são uma maneira eficiente de especificar todas essas definições da configuração de uma só vez. Quando você inclui declarações de recursos em um modelo, pode criar e configurar todos os recursos declarados usando esse modelo para criar uma pilha. Você também pode criar novas pilhas a partir do mesmo modelo para iniciar configurações de recursos idênticas.
      + Este modelo cria os seguintes recursos:
        + **`WebServerSecurityGroup`**: um grupo de segurança do EC2 que permite tráfego HTTP de entrada na porta 80 originado no intervalo de IP especificado.
        + **`WebServer`**: uma instância do EC2 com a seguinte configuração:
          + Usa o Amazon Linux 2 AMI mais recente
          + Aplica o tipo de instância selecionado
          + Adiciona o `WebServerSecurityGroup` à propriedade `SecurityGroupIds`
          + Inclui um script de dados de usuário para instalar o Apache HTTP Server
      + Um nome lógico é especificado no início de cada declaração de recurso e parâmetro. Por exemplo, `WebServerSecurityGroup` é o nome lógico atribuído ao recurso do grupo de segurança do EC2. A função `Ref` é usada então para referenciar recursos e parâmetros por seus nomes lógicos em outras partes do modelo. Quando um recurso referencia outro, isso cria uma dependência entre eles.
      + A seção **`Outputs`** define valores personalizados que são retornados após a criação da pilha. Você pode usar os valores de saída para retornar informações dos recursos na pilha, como os identificadores ou URLs dos recursos.
      + O modelo define uma única saída:
        + **`WebsiteURL`**: a URL do servidor Web implantado, construída usando o nome de DNS público da instância EC2. A função `Join` ajuda a combinar o `http://` fixo com o `PublicDnsName` variável em uma única string, facilitando a saída da URL completa do servidor Web.

   1. Escolha **Validar** para se certificar de que o código YAML seja válido antes de carregar o modelo.

   1. Depois, escolha **Criar modelo** para criar o modelo e adicioná-lo a um bucket do S3.

   1. Na caixa de diálogo que se abre, anote o nome do bucket do S3 para poder excluí-lo posteriormente. Depois, escolha **Confirmar e continuar no CloudFormation**. Isso leva você para o console do CloudFormation, onde o caminho do S3 para o modelo agora está especificado.

1. Na página **Criar pilha**, selecione **Avançar**.

1. Na página **Especificar detalhes da tarefa**, digite um nome no campo **Nome da pilha**. O nome da pilha não pode conter espaços. Neste exemplo, use **MyTestStack**.

1. Em **Parâmetros**, especifique os valores dos parâmetros da seguinte maneira:
   + **LatestAmiId**: isso é definido por padrão como o Amazon Linux 2 AMI mais recente.
   + **InstanceType**: escolha **t2.micro** ou **t3.micro** como o tipo de instância do EC2.
**nota**  
Se você for novo na AWS, poderá usar o nível gratuito para iniciar e usar uma instância `t2.micro` gratuitamente por 12 meses (em regiões onde `t2.micro` não estiver disponível, será possível usar uma instância do `t3.micro` no nível gratuito).
   + **MyIP**: especifique seu endereço IP público real com um sufixo `/32`. O sufixo `/32` é usado na notação CIDR para especificar que apenas um endereço IP é permitido. Isso significa, em essência, permitir tráfego de e para esse endereço IP específico, e nenhum outro.

1. Escolha **Avançar** duas vezes para ir até a página **Revisar e criar**. Para este tutorial, você pode deixar os padrões na página **Configurar opções da pilha** como estão.

1. Revise as informações da pilha. Quando estiver satisfeito com as configurações, clique em **Submit (Enviar)**.

## Monitorar a criação da pilha
<a name="getting-started-monitor-stack-creation"></a>

Depois que você escolhe **Enviar**, o CloudFormation começa a criar os recursos especificados no modelo. Sua nova pilha, **MyTestStack**, aparecerá na lista na parte superior do console do **CloudFormation**. Seu status deveria ser `CREATE_IN_PROGRESS`. Você pode ver o status detalhado de uma pilha visualizando seus eventos.

**Para visualizar os eventos da pilha**

1. No console do CloudFormation, escolha a pilha **MyTestStack** na lista.

1. No painel de detalhes da pilha, clique na guia **Eventos**.

   O console atualiza automaticamente a lista de eventos com os eventos mais recentes a cada 60 segundos.

A guia **Events** (Eventos) exibe cada etapa principal da criação da pilha classificada pelo tempo de cada evento, com os eventos mais recentes na parte superior.

O primeiro evento (na parte inferior da lista de eventos) é o início do processo de criação da pilha:

`2024-12-23 18:54 UTC-7 MyTestStack CREATE_IN_PROGRESS User initiated`

Em seguida, estão os eventos que marcam o início e a conclusão da criação de cada recurso. Por exemplo, a criação da instância EC2 resulta nas seguintes entradas:

`2024-12-23 18:59 UTC-7 WebServer CREATE_COMPLETE`

`2024-12-23 18:54 UTC-7 WebServer CREATE_IN_PROGRESS Resource creation initiated`

O evento `CREATE_IN_PROGRESS` é registrado quando o CloudFormation relata que começou a criar o recurso. O evento `CREATE_COMPLETE` é registrado em log quando o recurso é criado com êxito.

Quando o CloudFormation tiver criado a pilha com êxito, você verá o seguinte evento na parte superior da guia **Eventos**:

`2024-12-23 19:17 UTC-7 MyTestStack CREATE_COMPLETE`

Se não puder criar um recurso, o CloudFormation relatará um evento `CREATE_FAILED` e, por padrão, reverterá a pilha e excluirá todos os recursos que foram criados. A coluna **Status Reason** (Motivo do status) exibe o problema que provocou a falha.

Depois que a pilha é criada, você pode acessar a guia **Recursos** para visualizar a instância e o grupo de segurança do EC2 criados.

## Testar o servidor Web
<a name="getting-started-test-web-server"></a>

Depois que a pilha for criada com sucesso, navegue até a guia **Saídas** no console do CloudFormation. Procure o campo **WebsiteURL**. Isso conterá a URL pública da instância do EC2.

Abra um navegador e acesse a URL listada em **WebsiteURL**. Você deve ver uma mensagem "Hello World\$1" simples exibida no navegador.

Isso confirma que a instância do EC2 está executando o Apache HTTP Server e servindo uma página da Web básica.

## Solução de problemas
<a name="getting-started-troubleshooting"></a>

Se você experimentar uma reversão durante a criação de uma pilha, pode ser devido à falta de uma VPC. Confira como resolver esse problema.

### Nenhuma VPC padrão disponível
<a name="getting-started-troubleshooting-no-default-vpc"></a>

O modelo neste passo a passo requer uma VPC padrão. Se a criação da pilha falhar devido a erros de disponibilidade de uma VPC ou sub-rede, você talvez não tenha uma VPC padrão em sua conta. Você tem as seguintes opções:
+ **Criar uma nova VPC padrão**: você pode criar uma nova VPC padrão no console da Amazon VPC. Para obter instruções, consulte [Criar uma VPC padrão](https://docs.aws.amazon.com/vpc/latest/userguide/work-with-default-vpc.html#create-default-vpc) no *Guia do usuário da Amazon VPC*.
+ **Modificar o modelo para especificar uma sub-rede**: caso tenha uma VPC não padrão, você poderá modificar o modelo para especificar explicitamente os IDs da VPC e da sub-rede. Adicione o seguinte parâmetro ao modelo:

  ```
    SubnetId:
      Description: The subnet ID to launch the instance into
      Type: AWS::EC2::Subnet::Id
  ```

  Em seguida, atualize o recurso `WebServer` para incluir o ID da sub-rede:

  ```
    WebServer:
      Type: AWS::EC2::Instance
      Properties:
        ImageId: !Ref LatestAmiId
        InstanceType: !Ref InstanceType
        SecurityGroupIds:
          - !Ref WebServerSecurityGroup
        SubnetId: !Ref SubnetId
        UserData: !Base64 |
          #!/bin/bash
          yum update -y
          yum install -y httpd
          systemctl start httpd
          systemctl enable httpd
          echo "<html><body><h1>Hello World!</h1></body></html>" > /var/www/html/index.html
  ```

  Ao criar a pilha, você precisará especificar uma sub-rede que tenha acesso à internet para que o servidor Web possa ser acessado.

## Limpeza
<a name="getting-started-clean-up"></a>

Para ter certeza de que você não será cobrado por qualquer serviço não desejado, poderá fazer uma limpeza excluindo a pilha e os recursos dela. Você também pode excluir o bucket do S3 que armazena o modelo da pilha.

**Para excluir a pilha e seus recursos**

1. Abra o [console do CloudFormation](https://console.aws.amazon.com/cloudformation/).

1. Na página **Pilhas**, selecione a opção ao lado do nome da pilha que você criou (**MyTestStack**) e escolha **Excluir.**

1. Quando a confirmação for solicitada, escolha **Excluir**.

1. Monitore o andamento do processo de exclusão da pilha na guia **Evento**. O status de **MyTestStack** é alterado para `DELETE_IN_PROGRESS`. Quando o CloudFormation conclui a exclusão da pilha, ela é removida da lista.

Se tiver terminado de trabalhar com o exemplo de modelo e não precisar mais do bucket do Amazon S3, exclua-o. Para excluir um bucket, primeiro exclua seu conteúdo. Esvaziar um bucket exclui todos os objetos nele contidos.

**Para esvaziar e excluir o bucket do Amazon S3**

1. Abra o [console Amazon S3](https://console.aws.amazon.com/s3/).

1. No painel de navegação, no lado esquerdo do console, selecione **Buckets**.

1. Na lista **Buckets**, selecione a opção ao lado do nome do bucket que você criou para este tutorial e depois escolha **Esvaziar**.

1. Na página **Esvaziar bucket**, confirme se deseja esvaziar o bucket digitando **permanently delete** no campo de texto, depois escolha **Esvaziar**.

1. Monitore o andamento do processo de esvaziamento do bucket na página **Esvaziar bucket: status**. 

1. Para retornar à sua lista de buckets, escolha **Exit (Sair)**.

1. Selecione a opção ao lado do nome do bucket e escolha **Excluir**.

1. Quando for solicitada a confirmação, digite o nome do bucket e escolha **Excluir bucket**.

1. Monitore o andamento do processo de exclusão do bucket na lista **Buckets**. Quando o Amazon S3 conclui a exclusão do bucket, remove-o da lista.

## Próximas etapas
<a name="getting-started-next-steps"></a>

Parabéns\$1 Você criou uma pilha, monitorou sua criação e usou sua saída com sucesso.

Para continuar aprendendo:
+ Saiba mais sobre modelos para que possa criar os seus próprios. Para obter mais informações, consulte [Trabalhar com modelos do CloudFormation](template-guide.md).
+ Confira o workshop [Getting Started with CloudFormation](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US) para praticar ainda mais a criação de modelos.
+ Para obter uma versão resumida de [Getting Started with CloudFormation](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US), consulte [Implantar aplicações no Amazon EC2](deploying.applications.md). Este tópico descreve o mesmo cenário de uso de um script auxiliar do CloudFormation, `cfn-init`, para fazer o bootstrap de uma instância do Amazon EC2.