Crie imagens de contentor

Esta página descreve como configurar o Cloud Build para criar e armazenar imagens do Docker. Se for um utilizador recente do Cloud Build, leia os inícios rápidos e a vista geral da configuração de compilação primeiro.

O Cloud Build fornece imagens pré-criadas que pode referenciar num ficheiro de configuração do Cloud Build para executar as suas tarefas. Estas imagens são suportadas e mantidas pela Google Cloud. Pode usar a imagem do Docker pré-criada e suportada para executar comandos do Docker e criar imagens do Docker.

Nota: este guia destina-se a contentores Linux. Para contentores do Windows Server, consulte o artigo Criar imagens de várias arquiteturas com o gke-windows-builder do Cloud Build.

Antes de começar

As instruções nesta página pressupõem que tem conhecimentos sobre o Docker. Além disso:

• Tenha o código-fonte da sua aplicação e Dockerfile à mão.
• Ter um repositório Docker para armazenar imagens no Artifact Registry ou criar um novo repositório.
• Se quiser usar os comandos gcloud nesta página, instale a CLI do Google Cloud.
• Se quiser executar as imagens, instale o Docker
• Se quiser assinar as imagens com o cosign, siga as instruções em Autorize o acesso de serviço a serviço para criar uma conta de serviço especificada pelo utilizador e conceder as autorizações necessárias para gerar tokens de ID.

Crie com um ficheiro de configuração de compilação

Para criar a sua imagem do Docker com um ficheiro de configuração de compilação:

1. No mesmo diretório que contém o código fonte da sua aplicação, crie um ficheiro denominado cloudbuild.yaml ou cloudbuild.json.

2. No ficheiro de configuração de compilação:

   • Adicione um campo name e especifique a imagem Docker pré-criada. A imagem pré-criada é armazenada em gcr.io/cloud-builders/docker. No ficheiro de configuração de exemplo abaixo, o campo name especifica que a imagem 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', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.' ]
     

     JSON

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

     Substitua os valores dos marcadores de posição na configuração de compilação acima pelo seguinte:

   • LOCATION: a localização regional ou multirregional do seu repositório Docker no Artifact Registry.

   • PROJECT_ID: o ID do seu Google Cloud projeto.

   • REPOSITORY: o nome do seu repositório Docker no Artifact Registry.

   • IMAGE_NAME: o nome da imagem do contentor.

     Se o Dockerfile e o código fonte estiverem em diretórios diferentes, adicione -f e o caminho para o Dockerfile à lista de argumentos no campo args:

     YAML

     steps:
     - name: 'gcr.io/cloud-builders/docker'
       args: [ 'build', '-t', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '-f', 'DOCKERFILE_PATH', '.' ]
     

     JSON

     {
      "steps": [
       {
           "name": "gcr.io/cloud-builders/docker",
           "args": [
             "build",
             "-t",
             "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME", '-f', 'DOCKERFILE_PATH', "."
            ]
        }
        ]
      }
     

     Substitua os valores dos marcadores de posição na configuração de compilação acima pelo seguinte:

     • LOCATION: a localização regional ou multirregional do seu repositório.
     • PROJECT_ID: o ID do seu Google Cloud projeto.
     • REPOSITORY: o nome do seu repositório do Artifact Registry.
     • IMAGE_NAME: o nome da imagem do contentor.
     • DOCKERFILE_PATH: caminho para o seu Dockerfile.

3. Inicie a compilação com o ficheiro de configuração de compilação:

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Substitua os valores dos marcadores de posição no comando acima pelo seguinte:

   • CONFIG_FILE_PATH: o caminho para o ficheiro de configuração de compilação.
   • SOURCE_DIRECTORY: o caminho ou o URL para o código fonte.

   Se não especificar um CONFIG_FILE_PATH e um SOURCE_DIRECTORY no comando gcloud builds submit, o Cloud Build assume que o ficheiro de configuração e o código fonte estão no diretório de trabalho atual.

Crie com um ficheiro Docker

O Cloud Build permite-lhe criar uma imagem do Docker usando apenas um Dockerfile. Não precisa de um ficheiro de configuração de compilação separado.

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

    gcloud builds submit --tag LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME

Substitua os valores dos marcadores de posição no comando acima pelo seguinte:

• LOCATION: a localização regional ou multirregional do seu repositório.
• PROJECT_ID: o ID do seu Google Cloud projeto.
• REPOSITORY: o nome do seu repositório do Artifact Registry.
• IMAGE_NAME: o nome da imagem do contentor.

Crie com os buildpacks do Google Cloud

O Cloud Build permite-lhe criar uma imagem sem um Dockerfile ou um ficheiro de configuração de compilação. Pode fazê-lo através dos buildpacks do Google Cloud.

Para criar usando buildpacks, execute o seguinte comando a partir do diretório que contém o código-fonte:

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

Substitua os valores dos marcadores de posição nos comandos acima pelo seguinte:

• BUILDPACK_BUILDER: o criador de buildpacks a usar. Se não especificar um criador, o Cloud Build usa o gcr.io/buildpacks/builder por predefinição.
• ENVIRONMENT_VARIABLE: quaisquer variáveis de ambiente para a sua compilação.
• IMAGE: o URL da imagem no Artifact Registry. O URL da imagem tem de estar no formato LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME.

Seguem-se alguns exemplos de comandos:

• Executar uma compilação usando o gcr.io/buildpacks/builder predefinido para criar a imagem us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app:

    gcloud builds submit --pack image=us-docker.pkg.dev/gcb-docs-project/containers/gke/hello-app
  

• Transmitir várias variáveis de ambiente à sua compilação usando ^--^ como separador. Para mais informações sobre como escapar argumentos, 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'
  

Configurar acionadores para usar buildpacks: além de criar imagens através da linha de comandos, pode configurar acionadores para usar buildpacks para criar automaticamente a sua imagem. Para saber mais, consulte o artigo Criar e gerir acionadores de compilação.

Diferentes formas de armazenar imagens no Artifact Registry

Pode configurar o Cloud Build para armazenar a imagem criada de uma das seguintes formas:

• usando o campo images, que armazena a imagem no Artifact Registry após a conclusão da compilação.
• usando o comando docker push, que armazena a imagem no Artifact Registry como parte do fluxo de compilação.

A diferença entre usar o campo images e o comando push do Docker é que, se usar o campo images, a imagem armazenada é apresentada nos resultados da compilação. Isto inclui a página Descrição da compilação de uma compilação na Google Cloud consola, os resultados de Build.get()> e os resultados de gcloud builds list. No entanto, se usar o comando Docker push para armazenar a imagem criada, a imagem não é apresentada nos resultados da criação.

Se quiser armazenar a imagem como parte do fluxo de compilação e apresentar a imagem nos resultados da compilação, use o comando push do Docker e o campo images no ficheiro de configuração da compilação.

Para armazenar uma imagem de contentor no Artifact Registry após a conclusão da compilação:

1. Se o repositório de destino não existir, crie um novo repositório.
2. No mesmo diretório que contém o código fonte da sua aplicação e Dockerfile, crie um ficheiro com o nome cloudbuild.yaml ou cloudbuild.json.

3. No ficheiro de configuração de compilação, adicione um passo de compilação para criar uma imagem e, em seguida, adicione um campo images que especifique a imagem criada. Esta ação armazena a imagem no Artifact Registry. O fragmento seguinte mostra uma configuração de compilação para compilar uma imagem e armazená-la no Artifact Registry:

   YAML

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

   JSON

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

   Onde:

   • LOCATION: a localização regional ou multirregional do seu repositório.
   • PROJECT_ID: o ID do seu Google Cloud projeto.
   • REPOSITORY: o nome do seu repositório do Artifact Registry.
   • IMAGE_NAME: o nome da imagem do contentor.

4. Inicie a compilação com o ficheiro de configuração de compilação:

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Onde:

   • CONFIG_FILE_PATH é o caminho para o ficheiro de configuração de compilação.
   • SOURCE_DIRECTORY é o caminho ou o URL para o código-fonte.

Para armazenar a imagem no Artifact Registry como parte do fluxo de compilação:

1. No mesmo diretório que contém o código fonte da sua aplicação e Dockerfile, crie um ficheiro com o nome cloudbuild.yaml ou cloudbuild.json.

2. No ficheiro de configuração de compilação, adicione um passo de compilação docker para compilar uma imagem e, em seguida, adicione outro passo de compilação docker e transmita argumentos para invocar o comando push:

   YAML

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

   JSON

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

   Onde:

   • LOCATION: a localização regional ou multirregional do seu repositório.
   • PROJECT_ID: o ID do seu Google Cloud projeto.
   • REPOSITORY: o nome do seu repositório do Artifact Registry.
   • IMAGE_NAME: o nome da imagem do contentor.

3. Inicie a compilação com o ficheiro de configuração de compilação:

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Onde:

   • CONFIG_FILE_PATH é o caminho para o ficheiro de configuração de compilação.
   • SOURCE_DIRECTORY é o caminho ou o URL para o código-fonte.

Para armazenar uma imagem como parte do fluxo de compilação e apresentar a imagem nos resultados da compilação:

1. No mesmo diretório que contém o código fonte da sua aplicação e Dockerfile, crie um ficheiro com o nome cloudbuild.yaml ou cloudbuild.json.

2. No ficheiro de configuração de compilação, após o passo que compila a imagem, adicione um passo 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', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME', '.']
   - name: 'gcr.io/cloud-builders/docker'
     args: ['push', 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   images: ['LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME']
   

   JSON

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

   Onde:

   • LOCATION: a localização regional ou multirregional do seu repositório.
   • PROJECT_ID: o ID do seu Google Cloud projeto.
   • REPOSITORY: o nome do seu repositório do Artifact Registry.
   • IMAGE_NAME: o nome da imagem do contentor.

3. Inicie a compilação com o ficheiro de configuração de compilação:

   gcloud builds submit --config CONFIG_FILE_PATH SOURCE_DIRECTORY
   

   Onde:

   • CONFIG_FILE_PATH é o caminho para o ficheiro de configuração de compilação.
   • SOURCE_DIRECTORY é o caminho ou o URL para o código-fonte.

Assine imagens de contentores com o Cosign

Se estiver a armazenar imagens no Artifact Registry, pode adicionar outra camada de segurança através da ferramenta cosign para criar um registo da conta de serviço usada para iniciar uma compilação. Com base na norma OpenID Connect (OIDC), os auditores podem usar esse registo para verificar se uma imagem foi criada por uma conta de serviço fidedigna.

Nota: não é possível concluir os passos seguintes com a conta de serviço do Cloud Build predefinida. Siga as instruções em Autorize o acesso de serviço a serviço para criar uma conta de serviço especificada pelo utilizador e conceder as autorizações necessárias para gerar tokens de ID.

Os passos seguintes demonstram como usar o cloudbuild.yamlficheiro de configuração para obter um token de identidade e assinar a imagem do contentor.

YAML

  steps:
  - name: 'gcr.io/cloud-builders/docker'
    id: 'tag-and-push'
    script: |
      #!/bin/sh
      set -e
      docker build -t $_IMAGE .
      docker push "$_IMAGE"
      docker inspect $_IMAGE --format "$_IMAGE@{{.Id}}" >image_with_digest
  - name: 'gcr.io/cloud-builders/gcloud'
    id: 'generate-token'
    script: |
      #!/bin/sh
      set -e
      gcloud auth print-identity-token --audiences=sigstore > token
  - name: 'gcr.io/cloud-builders/docker'
    id: 'sign-image'
    script: |
      #!/bin/sh
      set -e
      docker run \
      --network=cloudbuild \
      --mount source=home-volume,target=/builder/home \
      --rm \
      -e SIGSTORE_NO_CACHE=true \
      -e HOME=/builder/home \
      gcr.io/projectsigstore/cosign \
      sign --identity-token=$(cat token) $(cat image_with_digest) -y
  service_account: '$_SERVICE_ACCOUNT'
  artifacts:
    images:
    - $_IMAGE
  substitutions:
    _IMAGE: 'LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME'
    _SERVICE_ACCOUNT_ID: 'SERVICE_ACCOUNT_ID'
    _SERVICE_ACCOUNT: projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}
  options:
    env:
    - '_IMAGE=$_IMAGE'
    dynamic_substitutions: true
    logging: CLOUD_LOGGING_ONLY

JSON

    {
        "steps": [
            {
                "name": "gcr.io/cloud-builders/docker",
                "id": "tag-and-push",
                "script": "#!/bin/sh set -e \ndocker build -t $_IMAGE . \ndocker push \"$_IMAGE\""
            },
            {
                "name": "gcr.io/cloud-builders/gcloud",
                "id": "generate-token-and-get-digest",
                "script": "#!/bin/sh set -e \ngcloud auth print-identity-token --audiences=sigstore > token \ngcloud container images describe \"$_IMAGE\" --format=\"value(image_summary.fully_qualified_digest)\" > image_with_digest"
            },
            {
                "name": "gcr.io/projectsigstore/cosign",
                "id": "sign-image",
                "script": "#!/busybox/sh cosign sign --identity-token=$(cat token) $(cat image_with_digest) -y",
                "env": [
                    "SIGSTORE_NO_CACHE=true"
                ]
            }
        ],
        "service_account": "$_SERVICE_ACCOUNT",
        "artifacts": {
            "images": [
                "$_IMAGE"
            ]
        },
        "substitutions": {
            "_IMAGE": "LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME",
            "_SERVICE_ACCOUNT_ID": "SERVICE_ACCOUNT_ID",
            "_SERVICE_ACCOUNT": "projects/${PROJECT_ID}/serviceAccounts/${_SERVICE_ACCOUNT_ID}"
        },
        "options": {
            "env": [
                "_IMAGE=$_IMAGE"
            ],
            "dynamic_substitutions": true,
            "logging": "CLOUD_LOGGING_ONLY"
        }
    }

Onde:

• LOCATION é a localização regional ou multirregional do repositório onde a imagem está armazenada, por exemplo, us-east1 ou us.

• PROJECT_ID: o ID do seu Google Cloud projeto.

• REPOSITORY é o nome do repositório onde a imagem está armazenada.

• IMAGE_NAME é o nome da imagem.

• SERVICE_ACCOUNT_ID é o endereço de email da conta de serviço especificada pelo utilizador que quer usar para executar a compilação. Por exemplo, um endereço de email de uma conta de serviço tem o seguinte aspeto: [e-mail].

Para validar a assinatura, instale o cosign na sua máquina local e, em seguida, execute o comando cosign verify:

cosign verify \
--certificate-identity=SERVICE_ACCOUNT_ID \
--certificate-oidc-issuer=https://accounts.google.com \
IMAGE

Onde:

• SERVICE_ACCOUNT_ID é o endereço de email da conta de serviço fidedigna que espera ter sido usado para criar a imagem do contentor.
• IMAGE é o nome completo da imagem, incluindo o resumo da imagem sha256.

Nota: tem de especificar o resumo da imagem, uma vez que o resumo é um identificador imutável da sua imagem. As etiquetas são mutáveis, o que as torna menos fiáveis. Consulte o artigo Versões de imagens de contentores para obter informações sobre as versões.

Execute a imagem de Docker

Para verificar se a imagem criada funciona como esperado, pode executá-la através do Docker.

1. Configure o Docker para usar as suas credenciais do Artifact Registry quando interagir com o Artifact Registry. (Só tem de o fazer uma vez.) Use o seguinte comando para fazer a autenticação através do auxiliar de credenciais do gcloud.

   gcloud auth configure-docker HOSTNAME-LIST
   

   Onde HOSTNAME-LIST é uma lista separada por vírgulas de nomes de anfitriões de repositórios a adicionar à configuração do auxiliar de credenciais.

   Por exemplo, para adicionar as regiões us-central1 e asia-northeast1, execute o comando:

   gcloud auth configure-docker us-central1-docker.pkg.dev,asia-northeast1-docker.pkg.dev
   

2. Execute a imagem de Docker que criou anteriormente:

   docker run LOCATION-docker.pkg.dev/PROJECT_ID/REPOSITORY/IMAGE_NAME
   

   Onde:

   • LOCATION: a localização regional ou multirregional do seu repositório.
   • PROJECT_ID: o ID do seu Google Cloud projeto.
   • REPOSITORY: o nome do seu repositório do Artifact Registry.
   • IMAGE_NAME: o nome da imagem do contentor.

   Vai ver um resultado semelhante ao seguinte:

   Hello, world! The time is Fri Feb  2 16:09:54 UTC 2018.
   

O que se segue?

• Saiba como criar aplicações Java.
• Saiba como criar aplicações Python.
• Saiba como criar aplicações Go.
• Saiba como armazenar artefactos de compilação no Cloud Storage.
• Saiba como armazenar artefactos de compilação no Artifact Registry.
• Saiba como resolver problemas de erros de compilação.