As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Tutorial: Implante em instâncias do Amazon EC2 com CodePipeline
<a name="tutorials-ec2-deploy"></a>

Este tutorial ajuda você a criar uma ação de implantação CodePipeline que implanta seu código em instâncias que você configurou no Amazon EC2.

**nota**  
Como parte da criação de um pipeline no console, um bucket de artefatos S3 será usado CodePipeline por for artefacts. (Este bucket não é o mesmo utilizado para uma ação de origem do S3.) Se o bucket de artefatos do S3 estiver em uma conta diferente da conta do seu pipeline, certifique-se de que o bucket de artefatos do S3 Contas da AWS seja de propriedade de quem é seguro e confiável.

**nota**  
A ação de implantação `EC2` está disponível somente para pipelines do tipo V2.

## Pré-requisitos
<a name="tutorials-ec2-deploy-prereqs"></a>

Para você usar este tutorial para criar seu pipeline de CD, alguns recursos precisam estar em operação. Veja aqui estão os itens que você precisa para começar:

**nota**  
Todos esses recursos devem ser criados na mesma AWS região.
+ Um repositório de controle de origem (este tutorial usa GitHub) onde você adicionará um `script.sh` arquivo de amostra.
+ Você deve usar uma função CodePipeline de serviço existente que tenha sido atualizada com as permissões para essa ação. Para atualizar o perfil de serviço, consulte [Permissões de política do perfil de serviço para a ação de implantação do EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

Assim que você atender a esses pré-requisitos, poderá continuar com o tutorial e criar seu pipeline de CD.

## Etapa 1: Criar instâncias do Amazon EC2 Linux
<a name="tutorials-ec2-deploy-instances"></a>

Nesta etapa, você vai criar as instâncias do Amazon EC2 nas quais implantará uma aplicação de amostra. Como parte desse processo, crie uma função de instância no IAM, caso ainda não tenha criado uma função de instância na região onde deseja criar recursos.

**Como criar uma função de instância**

1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)).

1. No painel do console, escolha **Roles (Funções)**.

1. Selecione **Criar perfil**.

1. Em **Selecionar tipo de entidade confiável**, selecione **AWS service (Serviço da AWS)**. Em **Escolha um caso de uso**, selecione **EC2**. Em **Select your use case (Selecione seu caso de uso)**, escolha **EC2**. Escolha **Próximo**.

1. Procure e selecione a política chamada **`AmazonSSMManagedEC2InstanceDefaultPolicy`**. 

1. Procure e selecione a política chamada **`AmazonSSMManagedInstanceCore`**. Escolha **Próximo: tags**.

1. Selecione **Próximo: revisar**. Forneça um nome para a função (por exemplo, **EC2InstanceRole**).
**nota**  
Anote o nome da função para a próxima etapa. Escolha essa função ao criar a instância.
**nota**  
Você adicionará permissões a essa função para permitir o acesso ao bucket de artefato do S3 para o pipeline depois da criação do pipeline.

   Selecione **Criar perfil**.

**Para executar instâncias**

1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Na navegação lateral, escolha **Instâncias** e selecione **Executar instâncias** na parte superior da página.

1. Em **Nome**, insira **MyInstances**. Isso atribui à instância uma tag **Chave** de **Name** e uma tag **Valor** de **MyInstances**. 

1. Em **Imagens do aplicativo e do sistema operacional (Amazon Machine Image)**, localize a opção **Amazon Linux** AMI com o AWS logotipo e verifique se ela está selecionada. (Essa AMI é descrita como AMI do Amazon Linux 2 (HVM) e é identificada como “Elegível para o nível gratuito”.)

1. Em **Tipo de instância**, selecione o tipo `t2.micro` elegível para o nível gratuito como configuração de hardware para a instância.

1. Na seção **Par de chaves (login)**, selecione um par de chaves ou crie um. 

1. Em **Configurações de rede**, verifique se o status é **Habilitar**.

1. Expanda **Advanced details** (Detalhes avançados). Em **Perfil de instância do IAM**, selecione o perfil do IAM criado no procedimento anterior (por exemplo, **EC2InstanceRole**).
**nota**  
Não deixe a função da instância em branco, pois isso cria uma função padrão e não seleciona a função criada por você.

1. Em **Resumo**, em **Número de instâncias**, insira `2`.

1. Escolha **Iniciar instância**. 

1. É possível visualizar o status da ativação na página **Instâncias**. Ao executar uma instância, seu estado inicial é `pending`. Após o início da instância, seu estado muda para `running` e ela recebe um nome DNS público. (Se a coluna do **Public DNS (DNS público)** não for exibida, selecione o ícone **Show/Hide (Exibir/Ocultar)** e **Public DNS (DNS público)**.)

## Etapa 2: adicionar permissões de bucket do artefato à função de instância do EC2
<a name="tutorials-ec2-deploy-role-s3"></a>

Atualize a função de instância do EC2 criada para a instância a fim de permitir que ela acesse o bucket de artefato do pipeline. 

**nota**  
Ao criar a instância, você cria ou usa uma função de instância do EC2 existente. Para evitar `Access Denied` erros, você deve adicionar permissões de bucket do S3 à função da instância para conceder permissões de instância ao bucket de CodePipeline artefatos. Crie uma função padrão ou atualize a função existente com a permissão `s3:GetObject` limitada ao bucket de artefato da região do pipeline.

1. Navegue até seu pipeline no CodePipeline console. Escolha **Configurações**. Exiba o nome e o local do armazenamento de artefato de um pipeline existente. Anote o nome do recurso da Amazon (ARN) do bucket de artefato e o copie.

1. Navegue até o console do IAM e escolha **Roles** (Funções). Selecione a função de instância que você criou na etapa 1 deste tutorial.

1. Na guia **Permissions (Permissões)**, escolha **Add inline policy (Adicionar política em linha)**.

1. Adicione o JSON a seguir ao documento da política, substituindo o valor no campo `Resource` pelo ARN do bucket.

   ```
   {
       "Effect": "Allow",
       "Principal": "*",
       "Action": "s3:GetObject",
       "Resource": "arn:aws:s3:::BucketName"
   }
   ```

1. Selecione **Atualizar**.

## Etapa 3: Adicionar um arquivo de script ao repositório
<a name="tutorials-ec2-deploy-file"></a>

Cole esse texto de amostra a fim de criar o arquivo `script.sh` para a etapa pós-script da implantação.

```
echo "Hello World!" 
```

**Para adicionar um arquivo `script.sh` ao repositório de origem**

1. Abra um editor de texto e, em seguida, copie e cole o arquivo acima em um novo arquivo.

1. Confirme e envie o arquivo `script.sh` para o repositório de origem.

   1. Adicione o arquivo.

      ```
      git add .
      ```

   1. Confirme a alteração.

      ```
      git commit -m "Adding script.sh."
      ```

   1. Envie a confirmação.

      ```
      git push
      ```

   Anote o caminho no repositório.

   ```
   /MyDemoRepo/test/script.sh
   ```

## Etapa 4: Criação do pipeline
<a name="tutorials-ec2-deploy-pipeline"></a>

Use o CodePipeline assistente para criar seus estágios de funil e conectar seu repositório de origem.

**Para criar o pipeline**

1. Abra o CodePipeline console em [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Na página **Welcome (Bem-vindo)**, **Getting started (Conceitos básicos)** ou **Pipelines**, selecione **Create pipeline (Criar pipeline)**.

1. Na página **Etapa 1: Escolher opção de criação**, em **Opções de criação**, selecione a opção **Criar pipeline personalizado**. Escolha **Próximo**.

1. Em **Etapa 2: Escolher as configurações do pipeline**, em **Nome do pipeline**, insira **MyPipeline**.

1. CodePipeline fornece tubulações do tipo V1 e V2, que diferem em características e preço. O tipo V2 é o único tipo que você pode escolher no console. Para ter mais informações, consulte [Pipeline types](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obter informações sobre preços de CodePipeline, consulte [Preços](https://aws.amazon.com/codepipeline/pricing/).

1. Em **Função de serviço**, escolha **Usar função de serviço existente** e, em seguida, escolha a função de CodePipeline serviço que foi atualizada com as permissões necessárias para essa ação. Para configurar sua função CodePipeline de serviço para essa ação, consulte[Permissões de política do perfil de serviço para a ação de implantação do EC2](action-reference-EC2Deploy.md#action-reference-EC2Deploy-permissions-action).

1. Deixe as configurações em **Advanced settings (Configurações avançadas)** como padrão e escolha **Next (Próximo)**.

1. Na página **Etapa 3: Adicionar etapa de origem**, adicione uma etapa de origem:

   1. Em **Provedor de origem**, escolha **GitHub (via GitHub aplicativo)**.

   1. Em **Conexão**, escolha uma conexão existente ou crie uma nova. Para criar ou gerenciar uma conexão para sua ação GitHub de origem, consulte[GitHub conexões](connections-github.md).

   1. Em **Repository name (Nome do repositório)**, selecione o nome do seu repositório do GitHub .

   Escolha **Próximo**.

1. Na página **Etapa 4: Adicionar etapa de compilação**, escolha **Ignorar**.

1. Na página **Etapa 5: Adicionar etapa de implantação**, escolha **EC2**.  
![\[\]](http://docs.aws.amazon.com/pt_br/codepipeline/latest/userguide/images/ec2deploy-action.png)

   1. Em **Diretório de destino**, insira o diretório na instância na qual você deseja implantar, como `/home/ec2-user/testhelloworld`.
**nota**  
Especifique o diretório de implantação que você deseja que a ação use na instância. A ação automatizará a criação do diretório especificado na instância como parte da implantação.

   1. Para **PostScript**, insira o caminho e o nome do arquivo para seu script, como`test/script.sh`.

   1. Escolha **Próximo**.

1. Na página **Step 6: Review**, revise a configuração do pipeline e escolha **Create pipeline** para criá-lo.  
![\[\]](http://docs.aws.amazon.com/pt_br/codepipeline/latest/userguide/images/ec2deploy-pipeline.png)

1. Depois que o pipeline for executado com êxito, escolha **Visualizar detalhes** para exibir os logs na ação a fim de exibir a saída da ação da computação gerenciada.  
![\[\]](http://docs.aws.amazon.com/pt_br/codepipeline/latest/userguide/images/ec2deploy-logs.png)  
![\[\]](http://docs.aws.amazon.com/pt_br/codepipeline/latest/userguide/images/ec2deploy-logs2.png)

## Etapa 5: Teste seu pipeline
<a name="tutorials-ec2-deploy-test"></a>

Seu pipeline deve ter tudo para executar uma implantação AWS contínua end-to-end nativa. Agora, teste a funcionalidade enviando uma alteração de código ao repositório de origem.

**Para testar o pipeline**

1. Faça uma alteração no código no repositório de origem configurado, confirme e envie a alteração.

1. Abra o CodePipeline console em [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).

1. Escolha o pipeline na lista.

1. Observe a evolução do pipeline pelos respectivos estágios. O pipeline deve ser concluído, e a ação implanta o script nas instâncias.

1. Para obter mais informações sobre solução de problemas, consulte [A ação Implantar do EC2 falha com uma mensagem de erro `No such file`](troubleshooting.md#troubleshooting-ec2-deploy).