Como criar imagens de contêiner

Nesta página, descrevemos como configurar o Cloud Build para criar e armazenar imagens do Docker. Se você não estiver familiarizado com o Cloud Build, leia os guias de início rápido e a visão geral da configuração de build primeiro.

O Cloud Build fornece imagens pré-criadas que podem ser consultadas em um arquivo de configuração do Cloud Build para executar suas tarefas. Essas imagens são compatíveis e mantidas pelo Google Cloud. Use a imagem compatível e pré-criada do Docker para executar comandos e criar imagens do Docker.

Antes de começar

As instruções nesta página presumem que você tenha familiaridade com o Docker. Além disso:

Tenha o código-fonte do aplicativo e o Dockerfile.
Se você quiser usar os comandos de gcloud nesta página, instale a ferramenta de linha de comando gcloud.
Se você quiser executar as imagens, instale o Docker (em inglês).

Como criar com um arquivo de configuração da versão

Para criar sua imagem do Docker usando um arquivo de configuração de build:

no mesmo diretório que contém o código-fonte do aplicativo, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;
No arquivo de configuração de build:
- Adicione um campo name e especifique a imagem do Docker pré-criada. A imagem pré-criada é armazenada no Container Registry em gcr.io/cloud-builders/docker. No exemplo de arquivo de configuração abaixo, o campo name especifica que a imagem pré-criação do Docker é usada pelo Cloud Build para executar a tarefa indicada pelo campo args.
- No campo args, adicione os argumentos para criar a imagem.
  YAML
```
steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'gcr.io/PROJECT_ID/IMAGE_NAME', '.' ]
```
  JSON
```
{
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "gcr.io/PROJECT_ID/IMAGE_NAME",
        "."
       ]
   }
   ]
 }
```
  Substitua os valores de marcador na configuração da versão acima pelo seguinte:
  - PROJECT_ID: o ID do projeto do Cloud
  - IMAGE_NAME: o nome da imagem do contêiner.
  Se Dockerfile e o código-fonte estiverem em diretórios diferentes, adicione -f e o caminho para Dockerfile à lista de argumentos no campo args:
  YAML
```
steps:
- name: 'gcr.io/cloud-builders/docker'
  args: [ 'build', '-t', 'gcr.io/PROJECT_ID/IMAGE_NAME', '-f', 'DOCKERFILE_PATH', '.' ]
```
  JSON
```
{
 "steps": [
  {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
        "build",
        "-t",
        "gcr.io/PROJECT_ID/IMAGE_NAME", '-f', 'DOCKERFILE_PATH', "."
       ]
   }
   ]
 }
```
  Substitua os valores de marcador na configuração da versão acima pelo seguinte:
  - PROJECT_ID: o ID do projeto do Cloud
  - IMAGE_NAME: o nome da imagem do contêiner.
  - DOCKERFILE_PATH: caminho para Dockerfile.
Inicie a compilação usando o arquivo de configuração da compilação:
```
gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
```
Substitua os valores de marcador no comando acima pelo seguinte:
- CONFIG_FILE_PATH: o caminho para o arquivo de configuração do build.
- SOURCE_DIRECTORY: o caminho ou URL do código-fonte.
Se você não especificar CONFIG_FILE_PATH e SOURCE_DIRECTORY no comando gcloud builds submit, o Cloud Build presumirá que o arquivo de configuração e o código-fonte estão no diretório de trabalho atual.

Como criar com um Dockerfile

O Cloud Build permite que você crie uma imagem do Docker usando apenas um Dockerfile. Você não precisa de um arquivo de configuração de build à parte.

Para criar usando um Dockerfile, execute o seguinte comando no diretório que contém seu código-fonte e o Dockerfile:

    gcloud builds submit --tag gcr.io/PROJECT_ID/IMAGE_NAME

Substitua os valores de marcador no comando acima pelo seguinte:

PROJECT_ID: o ID do projeto do Cloud
IMAGE_NAME: o nome da imagem do contêiner.

Como criar com o Cloud Native Buildpacks

O Cloud Build permite que você crie uma imagem sem um Dockerfile ou um arquivo de configuração da versão. É possível fazer isso usando o Cloud Native Buildpacks.

Para criar usando pacotes de criação, execute o seguinte comando no diretório que contém seu código-fonte:

    gcloud builds submit --pack builder=BUILDPACK_BUILDER, \
        env=ENVIRONMENT_VARIABLE, \
        image=IMAGE

Substitua os valores dos marcadores nos comandos acima pelo seguinte:

BUILDPACK_BUILDER: o builder do pacote de criação a ser usado. Se você não especificar um builder, o Cloud Build usará gcr.io/buildpacks/builder por padrão.
ENVIRONMENT_VARIABLE: qualquer variável de ambiente para a versão.
IMAGE: o URL da imagem no Container Registry. O nome da imagem precisa estar nos namespaces gcr.io/ ou pkg.dev.

Veja alguns comandos de exemplo:

Como executar uma versão usando o gcr.io/buildpacks/builder padrão para criar a imagem gcr.io/gcb-docs-project/hello:
```
  gcloud alpha builds submit --pack image=gcr.io/gcb-docs-project/hello
```
Como transmitir várias variáveis de ambiente para sua versão usando ^--^ como um separador. Para mais informações sobre como usar argumentos de escape, consulte gcloud topic escaping.
```
  gcloud builds submit --pack \
      ^--^image=gcr.io/my-project/myimage--env=GOOGLE_ENTRYPOINT='java -jar target/myjar.jar',GOOGLE_RUNTIME_VERSION='3.1.301'
```

Como armazenar imagens no Container Registry

Configure o Cloud Build para armazenar sua imagem criada de uma das seguintes maneiras:

Use o campo images, que armazena a imagem no Container Registry depois que a criação for concluída.
Use o comando docker push, que armazena a imagem no Container Registry como parte de seu fluxo de build.

A diferença entre o uso do campo images e do comando push do Docker é que, se você usar o campo images, a imagem armazenada será exibida nos resultados da versão. Isso inclui a página Descrição da build para uma build no Console do Cloud, os resultados de Build.get() e os resultados de gcloud builds list. No entanto, se você usar o comando push do Docker para armazenar a imagem criada, ela não será exibida nos resultados da versão.

Se quiser armazenar a imagem como parte de seu fluxo de build e exibir a imagem nos resultados do build, use o comando push do Docker e o campo images em seu arquivo de configuração de build.

Para armazenar uma imagem de contêiner no Container Registry depois que sua build for concluída:

no mesmo diretório que contém o código-fonte do aplicativo e Dockerfile, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;
no seu arquivo de configuração de build, adicione uma etapa da criação para criar uma imagem e, em seguida, adicione um campo images especificando a imagem criada. Isso armazena a imagem no Container Registry. O snippet a seguir mostra uma configuração de build para criar uma imagem e armazená-la no Container Registry:
YAML
```
steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/PROJECT_ID/IMAGE_NAME', '.']
images: ['gcr.io/PROJECT_ID/IMAGE_NAME']
```
JSON
```
{
"steps": [
{
    "name": "gcr.io/PROJECT_ID/IMAGE_NAME",
    "args": [
        "build",
        "-t",
        "gcr.io/PROJECT_ID/IMAGE_NAME",
        "."
    ]
}
],
"images": [
    "gcr.io/PROJECT_ID/IMAGE_NAME"
]
}
```
Em que:
- PROJECT_ID é seu código do projeto do Cloud;
- IMAGE_NAME é o nome da imagem do contêiner.
Inicie a criação usando o arquivo de configuração de build:
```
gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
```
Em que:
- CONFIG_FILE_PATH é o caminho para o arquivo de configuração da compilação;
- SOURCE_DIRECTORY é o caminho ou o URL do código-fonte.

Para armazenar a imagem no Container Registry como parte do fluxo de build:

no mesmo diretório que contém o código-fonte do aplicativo e Dockerfile, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;

no seu arquivo de configuração de build, adicione uma etapa de build docker para criar uma imagem, adicione outra etapa de build docker e transmita argumentos para invocar o comando push:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/PROJECT_ID/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'gcr.io/PROJECT_ID/IMAGE_NAME']

JSON

{
  "steps": [
   {
      "name": "gcr.io/cloud-builders/docker",
      "args": [
          "build",
          "-t",
          "gcr.io/PROJECT_ID/IMAGE_NAME",
          "."
       ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
          "push",
          "gcr.io/PROJECT_ID/IMAGE_NAME"
        ]
   }
  ]
}

Em que:

PROJECT_ID é seu código do projeto do Cloud;
IMAGE_NAME é o nome da imagem do contêiner.

Inicie a criação usando o arquivo de configuração de build:
```
gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
```
Em que:
- CONFIG_FILE_PATH é o caminho para o arquivo de configuração da compilação;
- SOURCE_DIRECTORY é o caminho ou o URL do código-fonte.

Para armazenar uma imagem como parte de seu fluxo de build e para exibir a imagem nos resultados do build:

no mesmo diretório que contém o código-fonte do aplicativo e Dockerfile, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;

no arquivo de configuração de build, após a etapa de criação da imagem, adicione uma etapa para invocar o comando push do Docker e, em seguida, adicione o campo images:

YAML

steps:
- name: 'gcr.io/cloud-builders/docker'
  args: ['build', '-t', 'gcr.io/PROJECT_ID/IMAGE_NAME', '.']
- name: 'gcr.io/cloud-builders/docker'
  args: ['push', 'gcr.io/PROJECT_ID/IMAGE_NAME']
images: ['gcr.io/PROJECT_ID/IMAGE_NAME']

JSON

{
    "steps": [
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "build",
           "-t",
           "gcr.io/PROJECT_ID/IMAGE_NAME",
           "."
        ]
   },
   {
       "name": "gcr.io/cloud-builders/docker",
       "args": [
           "push",
           "gcr.io/PROJECT_ID/IMAGE_NAME"
        ]
   }
   ],
    "images": [
       "gcr.io/PROJECT_ID/IMAGE_NAME"
    ]
}

Em que:

PROJECT_ID é seu código do projeto do Cloud;
IMAGE_NAME é o nome da imagem do contêiner.

Inicie a criação usando o arquivo de configuração de build:
```
gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
```
Em que:
- CONFIG_FILE_PATH é o caminho para o arquivo de configuração da compilação;
- SOURCE_DIRECTORY é o caminho ou o URL do código-fonte.

Executar a imagem do Docker

Para verificar se a imagem que você criou funciona como esperado, é possível executá-la usando o Docker.

Configure o Docker para usar as credenciais do Container Registry quando interagir com o Container Registry (você só precisa fazer isso uma vez):

gcloud auth configure-docker

Você verá uma mensagem semelhante à seguinte:

The following settings will be added to your Docker config file
located at [/.docker/config.json]:

{
  "credHelpers": {
    "gcr.io": "gcloud",
    "us.gcr.io": "gcloud",
    "eu.gcr.io": "gcloud",
    "asia.gcr.io": "gcloud",
    "staging-k8s.gcr.io": "gcloud",
    "marketplace.gcr.io": "gcloud"
  }
}

Do you want to continue (Y/n)?

Digite y e pressione Enter.
Execute a imagem do Docker que você criou antes, em que PROJECT_ID é o ID do projeto do Cloud:
```
docker run gcr.io/PROJECT_ID/IMAGE_NAME
```
Você verá um resultado semelhante a este:
```
Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.
```

A seguir

Saiba como criar aplicativos Go.
Saiba como armazenar artefatos de builds no Cloud Storage.
Saiba como armazenar artefatos de builds no Artifact Registry.