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:

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:

  1. no mesmo diretório que contém o código-fonte do aplicativo, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;
  2. 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 arquivo de configuração de exemplo abaixo, o campo name especifica que a imagem do Docker pré-criada é 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 o Dockerfile e o código-fonte estiverem em diretórios diferentes, adicione -f e o caminho ao Dockerfile na 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.
  3. 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 o 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 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'
    

Configuração de acionadores para usar pacotes de criação: além de criar usando a linha de comando, você pode configurar acionadores para usar pacotes de criação para criar sua imagem automaticamente. Para saber mais, consulte Como criar e gerenciar gatilhos de compilação.

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 o 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:

  1. no mesmo diretório que contém o código-fonte do aplicativo e Dockerfile, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;
  2. 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.
  3. 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:

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

  2. No arquivo de configuração de versão, adicione uma etapa de versão docker para criar uma imagem, adicione outra etapa de versão 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.
  3. 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:

  1. no mesmo diretório que contém o código-fonte do aplicativo e Dockerfile, crie um arquivo chamado cloudbuild.yaml ou cloudbuild.json;
  2. 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.
  3. 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.

  1. 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)?
    
  2. Digite y e pressione Enter.

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