# Implantar aplicações no Amazon EC2
<a name="deploying.applications"></a>

É possível usar o CloudFormation para instalar, configurar e iniciar aplicações automaticamente em instâncias do Amazon EC2. Isso permite que você duplique implantações e atualize instalações existentes facilmente sem se conectar diretamente à instância, o que pode economizar muito tempo e esforço.

O CloudFormation inclui um conjunto de scripts auxiliares (`cfn-init`, `cfn-signal`, `cfn-get-metadata` e `cfn-hup`) baseados em `cloud-init`. Você chama esses scripts auxiliares de seus modelos do CloudFormation para instalar, configurar e atualizar os aplicativos em instâncias do Amazon EC2 que estão no mesmo modelo. Para obter mais informações, consulte [Referência de scripts auxiliares do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html) no *Guia de referência de modelos do CloudFormation*.

No [tutorial de conceitos básicos](gettingstarted.walkthrough.md), você criou um servidor Web simples usando `UserData` com um script bash básico. Embora isso tenha funcionado para uma página simples “Hello World”, as aplicações reais geralmente precisam de uma configuração mais sofisticada, incluindo:
+ Vários pacotes de software instalados na ordem correta.
+ Arquivos de configuração complexos criados com conteúdo específico.
+ Serviços iniciados e configurados para serem executados automaticamente.
+ Tratamento de erros e validação do processo de configuração.

Os scripts auxiliares do CloudFormation fornecem uma maneira mais robusta e sustentável de configurar instâncias do EC2 em comparação com os scripts bash básicos em `UserData`. O script auxiliar `cfn-init` lê os dados de configuração dos metadados do seu modelo e os aplica sistematicamente à sua instância.

Neste tutorial, você vai aprender como usar o script auxiliar `cfn-init` e como monitorar o processo de bootstrap.

**nota**  
O CloudFormation é gratuito, mas os recursos do Amazon EC2 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](#bootstrapping-tutorial-prerequisites)
+ [Como entender os conceitos de bootstrap](#bootstrapping-tutorial-understand-concepts)
+ [Começar com um exemplo simples de bootstrap](#bootstrapping-tutorial-simple-example)
+ [Como adicionar arquivos e comandos](#bootstrapping-tutorial-add-complexity)
+ [Como adicionar segurança](#bootstrapping-tutorial-security-group)
+ [O modelo completo de bootstrap](#bootstrapping-tutorial-complete-template)
+ [Criar uma pilha usando o console](#bootstrapping-tutorial-create-stack)
+ [Monitorar o processo de bootstrap](#bootstrapping-tutorial-validate-bootstrap)
+ [Testar o servidor Web bootstrapped](#bootstrapping-tutorial-test-web-server)
+ [Solucionar problemas de bootstrap](#bootstrapping-tutorial-troubleshooting)
+ [Limpar os recursos](#bootstrapping-tutorial-clean-up)
+ [Próximas etapas](#bootstrapping-tutorial-next-steps)

## Pré-requisitos
<a name="bootstrapping-tutorial-prerequisites"></a>
+ Você deve ter concluído o tutorial [Criar sua primeira pilha](gettingstarted.walkthrough.md) ou ter uma experiência equivalente com os conceitos básicos do CloudFormation.
+ 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 e o CloudFormation ou ter acesso de usuário administrativo.
+ Você deve ter uma nuvem privada virtual (VPC) que tenha acesso à internet. Este modelo de tutorial 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 no tutorial [Criar sua primeira pilha](gettingstarted.walkthrough.md) para obter soluções alternativas.

## Como entender os conceitos de bootstrap
<a name="bootstrapping-tutorial-understand-concepts"></a>

Vamos entender os principais conceitos que fazem o bootstrapping funcionar antes de criar o modelo.

### O script de ajuda `cfn-init`
<a name="bootstrapping-tutorial-cfn-init-overview"></a>

O CloudFormation fornece os scripts auxiliares do Python que podem ser usados para instalar software e iniciar serviços em uma instância do Amazon EC2. O script `cfn-init` lê os metadados dos recursos do seu modelo e aplica a configuração à sua instância.

O processo funciona da seguinte maneira:

1. Você define a configuração na seção `Metadata` do seu recurso do EC2.

1. Você chama `cfn-init` no script `UserData`.

1. O script `cfn-init` lê os metadados e aplica a configuração.

1. A instância é configurada de acordo com suas especificações.

### Estrutura de metadados
<a name="bootstrapping-tutorial-metadata-structure"></a>

A configuração é definida em uma estrutura específica dentro da instância do EC2.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:                       # Metadata section for the resource
      AWS::CloudFormation::Init:    # Required key that cfn-init looks for
        config:                     # Configuration name (you can have multiple)
          packages:                 # Install packages
          files:                    # Create files
          commands:                 # Run commands
          services:                 # Start/stop services
```

O script `cfn-init` processa essas seções na seguinte ordem: pacotes, grupos, usuários, origens, arquivos, comandos e serviços.

## Começar com um exemplo simples de bootstrap
<a name="bootstrapping-tutorial-simple-example"></a>

Vamos começar com um exemplo mínimo de bootstrap que apenas instala e inicia o Apache.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:                 # Install Apache web server
            yum:
              httpd: []
          services:                 # Start Apache and enable it to start on boot
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      UserData: !Base64             # Script that runs when instance starts
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource EC2Instance --region ${AWS::Region}
```

Este exemplo simples demonstra os principais conceitos:
+ A seção `packages` instala o pacote `httpd` usando yum. Isso funciona no Amazon Linux e em outras distribuições Linux que usamyum.
+ A seção `services` garante que o `httpd` inicie e seja executado automaticamente.
+ O `UserData` instala as ferramentas de bootstrap mais recentes e chama o `cfn-init`.

## Como adicionar arquivos e comandos
<a name="bootstrapping-tutorial-add-complexity"></a>

Agora, vamos aprimorar nosso exemplo adicionando uma página da Web personalizada e um arquivo de log no diretório `/var/log` na instância do EC2.

### Criar arquivos
<a name="bootstrapping-tutorial-files-section"></a>

A seção `files` permite que você crie arquivos na instância com conteúdo específico. A barra vertical (`|`) permite que você passe um bloco literal de texto (código HTML) como conteúdo do arquivo (`/var/www/html/index.html`).

```
files:
  /var/www/html/index.html:
    content: |
      <body>
        <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
      </body>
```

### Executar comandos
<a name="bootstrapping-tutorial-commands-section"></a>

A seção `commands` permite que você execute comandos shell durante o processo de bootstrap. Esse comando cria um arquivo de log em `/var/log/welcome.txt` na instância do EC2. Para visualizá-lo, você precisa de um par de chaves do Amazon EC2 para usar no acesso por SSH e um intervalo de endereços IP que possa ser usado para o SSH na instância (não abordados aqui).

```
commands:
  createWelcomeLog:
    command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
```

## Como adicionar segurança
<a name="bootstrapping-tutorial-security-group"></a>

Como estamos configurando um servidor Web, precisamos permitir que o tráfego da Web (HTTP) chegue à nossa instância do EC2. Para isso, criaremos um grupo de segurança que permita tráfego de entrada na porta 80 do seu endereço IP. As instâncias do EC2 também precisam enviar tráfego para a internet, por exemplo, para instalar atualizações de pacotes. Por padrão, os grupos de segurança permitem todo o tráfego de saída. Vamos então associar esse grupo de segurança à nossa instância do EC2 usando a propriedade `SecurityGroupIds`.

```
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Allow HTTP access from my IP address
    SecurityGroupIngress:
      - IpProtocol: tcp
        Description: HTTP
        FromPort: 80
        ToPort: 80
        CidrIp: !Ref MyIP
```

## O modelo completo de bootstrap
<a name="bootstrapping-tutorial-complete-template"></a>

Agora, vamos juntar todas as peças. Confira o modelo completo que combina todos os conceitos que discutimos.

```
AWSTemplateFormatVersion: 2010-09-09
Description: Bootstrap an EC2 instance with Apache web server using cfn-init

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: 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 from my IP address
      SecurityGroupIngress:
        - IpProtocol: tcp
          Description: HTTP
          FromPort: 80
          ToPort: 80
          CidrIp: !Ref MyIP

  WebServer:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <body>
                  <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                </body>
          commands:
            createWelcomeLog:
              command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServer --region ${AWS::Region}
      Tags:
        - Key: Name
          Value: Bootstrap Tutorial Web Server

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServer.PublicDnsName}'
    Description: EC2 instance public DNS name
```

## Criar uma pilha usando o console
<a name="bootstrapping-tutorial-create-stack"></a>

O procedimento a seguir envolve o upload do modelo de pilha de amostra a partir de um arquivo. Abra um editor de texto na sua máquina local e adicione o modelo. Salve o arquivo com o nome `samplelinux2stack.template`.

**Para executar o modelo de pilha**

1. Faça login no Console de gerenciamento da AWS e abra o console CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Escolha **Create stack (Criar pilha)**, **With new resources (Com novos recursos (padrão))**.

1. Em **Especificar modelo**, escolha **Carregar um arquivo de modelo**, **Escolher arquivo** para carregar o arquivo `samplelinux2stack.template`. 

1. Escolha **Próximo**.

1. Na página **Especificar detalhes da pilha**, digite **BootstrapTutorialStack** como o nome da pilha.

1. Em **Parâmetros**, faça o seguinte:
   + **LatestAmiId**: deixe o valor padrão.
   + **InstanceType**: escolha **t2.micro** ou **t3.micro** como o tipo de instância do EC2.
   + **MyIP**: insira seu endereço IP público com um sufixo `/32`.

1. Escolha **Avançar** duas vezes e, em seguida, **Enviar** para criar a pilha.

## Monitorar o processo de bootstrap
<a name="bootstrapping-tutorial-validate-bootstrap"></a>

Os processos de bootstrap demoram mais do que simples execuções do EC2 porque software adicional está sendo instalado e configurado.

**Para monitorar o progresso do bootstrap**

1. No console do CloudFormation, selecione sua pilha e abra a guia **Eventos**.

1. Fique atento ao evento `WebServer CREATE_IN_PROGRESS`. O processo de bootstrap começa após a inicialização da instância.

1. Normalmente, o processo de bootstrap leva alguns minutos. Você verá `WebServer CREATE_COMPLETE` quando tiver terminado.

Caso queira ver o que está acontecendo durante o processo de bootstrap, você pode verificar os logs da instância.

**Para visualizar os logs de bootstrap (opcional)**

1. Abra o [console do EC2](https://console.aws.amazon.com/ec2/) e encontre sua instância.

1. Selecione a instância e escolha **Ações**, **Monitorar e solucionar problemas** e **Obter log do sistema** para ver o progresso do bootstrap.

1. Se você não visualizar os logs de imediato, aguarde e atualize a página. 

## Testar o servidor Web bootstrapped
<a name="bootstrapping-tutorial-test-web-server"></a>

Quando sua pilha mostrar `CREATE_COMPLETE`, teste seu servidor Web.

**Para testar o servidor Web**

1. No console do CloudFormation, acesse a guia **Saídas** da sua pilha.

1. Clique no valor **WebsiteURL** para abrir o servidor Web em uma nova guia.

1. Você verá sua página da Web personalizada com a mensagem `Congratulations, you have successfully launched the AWS CloudFormation sample`.

**nota**  
Se a página não for carregada de imediato, aguarde um minuto e tente novamente. O processo de bootstrap ainda pode estar sendo concluído mesmo após a pilha mostrar `CREATE_COMPLETE`.

## Solucionar problemas de bootstrap
<a name="bootstrapping-tutorial-troubleshooting"></a>

Se o processo de bootstrap falhar ou se o servidor Web não estiver funcionando, confira abaixo os problemas e soluções comuns.

### Problemas comuns
<a name="bootstrapping-tutorial-common-issues"></a>
+ **Falha na criação da pilha**: verifique a guia **Eventos** para ver mensagens de erro específicas.
+ **Servidor Web não acessível**: verifique se o endereço IP está correto no parâmetro `MyIP`. Lembre-se de incluir `/32` no final.
+ **Falha no processo de bootstrap**: a instância pode ser inicializada, mas o `cfn-init` falha. Verifique os logs do sistema conforme descrito na seção de monitoramento.

## Limpar os recursos
<a name="bootstrapping-tutorial-clean-up"></a>

Para evitar cobranças contínuas, você pode fazer a limpeza excluindo a pilha e seus recursos. 

**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 (**BootstrapTutorialStack**) 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 **BootstrapTutorialStack** é alterado para `DELETE_IN_PROGRESS`. Quando o CloudFormation conclui a exclusão da pilha, ela é removida da lista.

## Próximas etapas
<a name="bootstrapping-tutorial-next-steps"></a>

Parabéns\$1 Você aprendeu com êxito como fazer bootstrap de instâncias do EC2 com o CloudFormation. Agora você já sabe:
+ Como usar scripts `cfn-init` auxiliares
+ Como estruturar metadados para bootstrapping
+ Como instalar pacotes, criar arquivos, executar comandos e gerenciar serviços
+ Como monitorar problemas de bootstrap

Para continuar aprendendo:
+ Saiba como atualizar uma pilha em execução e usar o script auxiliar `cfn-hup`. Para obter mais informações, consulte [Atualizar uma pilha do CloudFormation](updating.stacks.walkthrough.md).
+ Aprenda a fazer bootstrap de uma pilha do Windows. Para obter mais informações, consulte [Fazer o bootstrap de pilhas do CloudFormation baseadas em Windows](cfn-windows-stacks-bootstrapping.md).
+ Conheça cenários de bootstrap mais complexos com vários conjuntos de configurações. Para obter mais informações, consulte [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) e [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html) no *Guia de referência de modelos do CloudFormation*.
+ Saiba mais sobre o script `cfn-signal` para relatar o status de conclusão do bootstrap. Para obter mais informações, consulte [cfn-signal](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-signal.html) no *Guia de referência de modelos do CloudFormation*.