

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

# Exemplo de “Publicar imagem do Docker em um repositório de imagens do Amazon ECR” para CodeBuild
<a name="sample-docker"></a>

Este exemplo produz como saída de compilação de uma imagem do Docker e, depois, a envia a um repositório de imagens do Amazon Elastic Container Registry (Amazon ECR). Você pode adaptar esta amostra para enviar a imagem Docker para um Docker Hub. Para obter mais informações, consulte [Adapte o exemplo “Publicar imagem do Docker no Amazon ECR” para enviar para o Docker Hub](sample-docker-docker-hub.md).

Para saber como compilar uma imagem de Docker usando uma imagem de compilação personalizada do Docker (`docker:dind` no Docker Hub), consulte [Docker no exemplo de imagem personalizada](sample-docker-custom-image.md).

Esse exemplo foi testado fazendo referência a `golang:1.12`

Esse exemplo usa o novo recurso de compilações do Docker multiestágio, que produz uma imagem de Docker como saída de compilação. Depois, ele envia a imagem do Docker por push a um repositório de imagens do Amazon ECR. As compilações da imagem de Docker multiestágio ajudam a reduzir o tamanho da imagem de Docker final. Para obter mais informações, consulte [Usar compilações multiestágio com o Docker](https://docs.docker.com/engine/userguide/eng-image/multistage-build/).

**Importante**  
A execução dessa amostra pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças por AWS CodeBuild AWS recursos e ações relacionados ao Amazon S3 AWS KMS, CloudWatch Logs e Amazon ECR. Para obter mais informações, consulte [CodeBuild preços, preços](https://aws.amazon.com/codebuild/pricing) do [Amazon S3, preços, preços](https://aws.amazon.com/s3/pricing) da Amazon e [AWS Key Management Service preços](https://aws.amazon.com/kms/pricing) do [Amazon CloudWatch ](https://aws.amazon.com/cloudwatch/pricing) [Elastic Container Registry](https://aws.amazon.com/ecr/pricing).

**Topics**
+ [Execute o exemplo “Publicar imagem do Docker no Amazon ECR”](#sample-docker-running)
+ [Adapte o exemplo “Publicar imagem do Docker no Amazon ECR” para enviar para o Docker Hub](sample-docker-docker-hub.md)

## Execute o exemplo “Publicar imagem do Docker no Amazon ECR”
<a name="sample-docker-running"></a>

Use o procedimento a seguir para executar o exemplo que publica uma imagem do Docker no Amazon ECR. Para obter mais informações sobre este exemplo, consulte [Exemplo de “Publicar imagem do Docker em um repositório de imagens do Amazon ECR” para CodeBuild](#sample-docker).

**Como executar este exemplo**

1. Se você já possui um repositório de imagens no Amazon ECR que deseje usar, avance para a etapa 3. Caso contrário, se você estiver usando um usuário em vez de uma conta AWS raiz ou um usuário administrador para trabalhar com o Amazon ECR, adicione essa declaração (entre *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1* e*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*) ao usuário (ou grupo do IAM ao qual o usuário está associado). Não é recomendável usar uma conta AWS raiz. Essa declaração permite a criação de repositórios Amazon ECR para armazenar imagens do Docker. As elipses (`...`) são usadas para agilizar e para ajudá-lo a encontrar onde adicionar a declaração. Não remova nenhuma declaração e não digite essas elipses nas políticas. Para obter mais informações, consulte [Working with inline policies using the Console de gerenciamento da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_inline-using.html#AddingPermissions_Console) no *Guia do usuário*. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:CreateRepository"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------
**nota**  
A entidade do IAM que modifica essa política deve ter permissão no IAM para alterar políticas.

1. Crie um repositório de imagens no Amazon ECR. Certifique-se de criar o repositório na mesma AWS região em que você cria seu ambiente de compilação e executa sua compilação. Para obter mais informações, consulte [Creating a repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) no *Guia do usuário do Amazon ECR*. O nome desse repositório deve corresponder ao nome do repositório que você especificará posteriormente neste procedimento, representado pela variável de ambiente `IMAGE_REPO_NAME`. Certifique-se de que a política de repositório do Amazon ECR conceda acesso push de imagens para sua função CodeBuild de serviço IAM. 

1. Adicione essa declaração (entre *\$1\$1\$1 BEGIN ADDING STATEMENT HERE \$1\$1\$1* e*\$1\$1\$1 END ADDING STATEMENT HERE \$1\$1\$1*) à política que você anexou à sua função AWS CodeBuild de serviço. Essa declaração permite CodeBuild fazer o upload de imagens do Docker para os repositórios do Amazon ECR. As elipses (`...`) são usadas para agilizar e para ajudá-lo a encontrar onde adicionar a declaração. Não remova nenhuma declaração e não digite essas elipses nas políticas. 

------
#### [ JSON ]

****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "ecr:BatchCheckLayerAvailability",
                   "ecr:CompleteLayerUpload",
                   "ecr:GetAuthorizationToken",
                   "ecr:InitiateLayerUpload",
                   "ecr:PutImage",
                   "ecr:UploadLayerPart"
               ],
               "Resource": "*"
           }
       ]
   }
   ```

------
**nota**  
A entidade do IAM que modifica essa política deve ter permissão no IAM para alterar políticas.

1. Crie os arquivos conforme descrito nas [Arquivos](#sample-docker-files) seções [Estrutura de diretório](#sample-docker-dir) e deste tópico e, em seguida, carregue-os em um bucket de entrada do S3 ou em um AWS CodeCommit repositório do Bitbucket. GitHub Para obter mais informações, consulte [Image definitions file reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/file-reference.html) no *Guia do usuário do AWS CodePipeline *.
**Importante**  
Não faça upload de `(root directory name)`, apenas dos arquivos dentro de `(root directory name)`.   
Se você estiver usando um bucket de entrada do S3, crie um arquivo ZIP que contenha os arquivos e envie-o para o bucket de entrada. Não adicione `(root directory name)` ao arquivo ZIP, apenas aos arquivos dentro de `(root directory name)`.

1. Crie um projeto de compilação, execute a compilação e exiba suas informações.

    Se você usar o console para criar seu projeto:

   1.  Para **Operating system**, selecione **Ubuntu**. 

   1.  Em **Runtime (Tempo de execução)**, selecione **Standard (Padrão)**. 

   1.  **Para **Imagem**, escolha: 5.0aws/codebuild/standard.** 

   1.  Adicione as seguintes variáveis de ambiente: 
      +  AWS\$1DEFAULT\$1REGION com um valor de *region-ID* 
      +  AWS\$1ACCOUNT\$1ID com um valor de *account-ID* 
      +  IMAGE\$1TAG com o valor Latest 
      +  IMAGE\$1REPO\$1NAME com um valor de *Amazon-ECR-repo-name* 

   Se você usar o AWS CLI para criar o projeto de construção, a entrada formatada em JSON para o `create-project` comando poderá ser semelhante a essa. (Substitua os espaços reservados com seus próprios valores.)

   ```
   {
     "name": "sample-docker-project",
     "source": {
       "type": "S3",
       "location": "codebuild-region-ID-account-ID-input-bucket/DockerSample.zip"
     },
     "artifacts": {
       "type": "NO_ARTIFACTS"
     },
     "environment": {
       "type": "LINUX_CONTAINER",
       "image": "aws/codebuild/standard:5.0",
       "computeType": "BUILD_GENERAL1_SMALL",
       "environmentVariables": [
         {
           "name": "AWS_DEFAULT_REGION",
           "value": "region-ID"
         },
         {
           "name": "AWS_ACCOUNT_ID",
           "value": "account-ID"
         },
         {
           "name": "IMAGE_REPO_NAME",
           "value": "Amazon-ECR-repo-name"
         },
         {
           "name": "IMAGE_TAG",
           "value": "latest"
         }
       ],
     },
     "serviceRole": "arn:aws:iam::account-ID:role/role-name",
     "encryptionKey": "arn:aws:kms:region-ID:account-ID:key/key-ID"
   }
   ```

1. Confirme se a imagem do Docker foi enviada CodeBuild com sucesso para o repositório:

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

   1. Escolha o nome do repositório. A imagem deve ser listada na coluna **Image tag (Tag de imagem)**

### Estrutura de diretório
<a name="sample-docker-dir"></a>

Essa amostra pressupõe esta estrutura de diretório.

```
(root directory name)
├── buildspec.yml
└── Dockerfile
```

### Arquivos
<a name="sample-docker-files"></a>

Esta amostra usa estes arquivos.

`buildspec.yml` (em `(root directory name)`)

```
version: 0.2

phases:
  pre_build:
    commands:
      - echo Logging in to Amazon ECR...
      - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
  build:
    commands:
      - echo Build started on `date`
      - echo Building the Docker image...          
      - docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
      - docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG      
  post_build:
    commands:
      - echo Build completed on `date`
      - echo Pushing the Docker image...
      - docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
```

`Dockerfile` (em `(root directory name)`)

```
FROM golang:1.12-alpine AS build
#Install git
RUN apk add --no-cache git
#Get the hello world package from a GitHub repository
RUN go get github.com/golang/example/hello
WORKDIR /go/src/github.com/golang/example/hello
# Build the project and send the output to /bin/HelloWorld 
RUN go build -o /bin/HelloWorld

FROM golang:1.12-alpine
#Copy the build's output binary from the previous build container
COPY --from=build /bin/HelloWorld /bin/HelloWorld
ENTRYPOINT ["/bin/HelloWorld"]
```

**nota**  
CodeBuild substitui as imagens personalizadas do `ENTRYPOINT` Docker.

# Adapte o exemplo “Publicar imagem do Docker no Amazon ECR” para enviar para o Docker Hub
<a name="sample-docker-docker-hub"></a>

Para adaptar o exemplo “Publicar imagem do Docker no Amazon ECR” de modo que a imagem do Docker seja enviada ao Docker Hub e não ao Amazon ECR, edite o código do exemplo. Para obter mais informações sobre o exemplo, consulte [Exemplo de “Publicar imagem do Docker em um repositório de imagens do Amazon ECR” para CodeBuild](sample-docker.md) e [Execute o exemplo “Publicar imagem do Docker no Amazon ECR”](sample-docker.md#sample-docker-running).
**nota**  
Se você estiver usando uma versão do Docker anterior à 17.06, remova a opção `--no-include-email`.

1. Substitua estas linhas de código específicas do Amazon ECR no arquivo `buildspec.yml`:

   ```
   ...
     pre_build:
       commands:
         - echo Logging in to Amazon ECR...
         - aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com
     build:
       commands:
         - echo Build started on `date`
         - echo Building the Docker image...          
         - docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
         - docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
     post_build:
       commands:
         - echo Build completed on `date`
         - echo Pushing the Docker image...
         - docker push $AWS_ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com/$IMAGE_REPO_NAME:$IMAGE_TAG
   ...
   ```

   Por estas linhas de código específicas no Docker Hub:

   ```
   ...
     pre_build:
       commands:
         - echo Logging in to Docker Hub...
         # Type the command to log in to your Docker Hub account here.          
     build:
       commands:
         - echo Build started on `date`
         - echo Building the Docker image...
         - docker build -t $IMAGE_REPO_NAME:$IMAGE_TAG .
         - docker tag $IMAGE_REPO_NAME:$IMAGE_TAG $IMAGE_REPO_NAME:$IMAGE_TAG
     post_build:
       commands:
         - echo Build completed on `date`
         - echo Pushing the Docker image...
         - docker push $IMAGE_REPO_NAME:$IMAGE_TAG
   ...
   ```

1. Faça o upload do código editado em um bucket de entrada do S3 ou em um AWS CodeCommit repositório do Bitbucket. GitHub 
**Importante**  
Não faça upload de `(root directory name)`, apenas dos arquivos dentro de `(root directory name)`.   
Se você estiver usando um bucket de entrada do S3, crie um arquivo ZIP que contenha os arquivos e envie-o para o bucket de entrada. Não adicione `(root directory name)` ao arquivo ZIP, apenas aos arquivos dentro de `(root directory name)`.

1. Substitua estas linhas de código da entrada formatada JSON para o comando `create-project`:

   ```
   ...
       "environmentVariables": [
         {
           "name": "AWS_DEFAULT_REGION",
           "value": "region-ID"
         },
         {
           "name": "AWS_ACCOUNT_ID",
           "value": "account-ID"
         },
         {
           "name": "IMAGE_REPO_NAME",
           "value": "Amazon-ECR-repo-name"
         },
         {
           "name": "IMAGE_TAG",
           "value": "latest"
         }
       ]
   ...
   ```

   Por estas linhas de código:

   ```
   ...
       "environmentVariables": [
         {
           "name": "IMAGE_REPO_NAME",
           "value": "your-Docker-Hub-repo-name"
         },
         {
           "name": "IMAGE_TAG",
           "value": "latest"
         }
       ]
   ...
   ```

1. Crie um ambiente de compilação, execute a compilação e exiba informações relacionadas.

1. Confirme se a imagem do Docker foi enviada AWS CodeBuild com sucesso para o repositório. Faça login no Docker Hub, vá até o repositório e selecione a guia **Tags**. A tag `latest` deve conter um valor **Last Updated** bem recente.