# 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.