

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. Em seguida, ele envia a imagem do Docker para um repositório de imagens do Amazon ECR. Multi-stage As compilações de imagens do Docker ajudam a reduzir o tamanho da imagem final do Docker. 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 {{\#\#\# BEGIN ADDING STATEMENT HERE \#\#\#}} e{{\#\#\# END ADDING STATEMENT HERE \#\#\#}}) 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 {{\#\#\# BEGIN ADDING STATEMENT HERE \#\#\#}} e{{\#\#\# END ADDING STATEMENT HERE \#\#\#}}) à 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 **aws/codebuild/standard:5.0**. 

   1.  Adicione as seguintes variáveis de ambiente: 
      +  AWS\_DEFAULT\_REGION com um valor de {{region-ID}} 
      +  AWS\_ACCOUNT\_ID com um valor de {{account-ID}} 
      +  IMAGE\_TAG com o valor Latest 
      +  IMAGE\_REPO\_NAME com um valor de {{Amazon-ECR-repo-name}} 

   Se você usar o AWS CLI para criar o projeto de construção, a JSON-formatted entrada para o `create-project` comando poderá ser semelhante a esta. (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.