Usar secrets do Secret Manager

Nesta página, explicamos como incluir informações confidenciais, como senhas e chaves de API, no Cloud Build.

O Gerenciador de secrets é um serviço do Google Cloud que armazena com segurança chaves de API, senhas e outros dados confidenciais. Para incluir informações confidenciais nos seus builds, é possível armazená-las no Gerenciador de secrets e, em seguida, configurar seu build para acessar as informações do Gerenciador de secrets.

Antes de começar

  • Ative as APIs Cloud Build and Secret Manager.

    Ative as APIs

  • Para usar os exemplos de linha de comando neste guia, instale e configure a Google Cloud CLI.

  • Verifique se você armazenou o secret no Gerenciador de secrets. Para instruções, consulte Como criar um secret.

    • Anote o nome e a versão do secret. Você precisará dessas informações para configurar o Cloud Build para acessar o secret.

Permissões do IAM obrigatórias

Conceda o papel do IAM de Acessador de Secrets do Secret Manager (roles/secretmanager.secretAccessor) ao secret à conta de serviço que você está usando para o build:

  1. Abra a página do Secret Manager no console do Google Cloud:

    Acessar a página "Gerenciador de secrets"

  2. Marque a caixa de seleção do secret que você quer usar no build.

  3. Se ela ainda não estiver aberta, clique em Mostrar painel de informações para abrir o painel.

  4. No painel, em Permissões, clique em Adicionar principal.

  5. No campo Novos principais, insira o endereço de e-mail da sua conta de serviço.

  6. Na caixa suspensa Selecionar um papel, escolha Acessador de secrets do Secret Manager.

  7. Clique em Salvar.

Configurar builds para acessar secrets UTF-8 do Secret Manager

  1. No diretório raiz do projeto, crie um arquivo de configuração do Cloud Build chamado cloudbuild.yaml ou cloudbuild.json.

  2. No arquivo de configuração de build:

    • Após a criação de steps, adicione um campo availableSecrets para especificar a versão do secret e as variáveis de ambiente a serem usadas no secret. É possível incluir variáveis de substituição no valor do campo secretVersion. É possível especificar mais de um secret em uma versão.
    • Na etapa de versão em que você quer especificar o secret:
      • Adicione um campo entrypoint que aponte para bash para usar a ferramenta bash na etapa de versão. Ele é necessário para se referir à variável de ambiente do secret.
      • Adicione um campo de secretEnv especificando a variável de ambiente.
      • No campo args, adicione uma sinalização -c como primeiro argumento. Qualquer string que você passar depois de -c será tratada como um comando. Para mais informações sobre como executar comandos bash com -c, consulte a documentação do bash.
      • Ao especificar o secret no campo args, especifique-o usando a variável de ambiente prefixada com $$.

    The following example build config file shows how to login to Docker using the Docker username and password stored in Secret Manager.

    YAML 

    steps:
- name: 'gcr.io/cloud-builders/docker'
  entrypoint: 'bash'
  args: ['-c', 'docker login --username=$$USERNAME --password=$$PASSWORD']
  secretEnv: ['USERNAME', 'PASSWORD']
availableSecrets:
  secretManager:
  - versionName: projects/PROJECT_ID/secrets/DOCKER_PASSWORD_SECRET_NAME/versions/DOCKER_PASSWORD_SECRET_VERSION
    env: 'PASSWORD'
  - versionName: projects/PROJECT_ID/secrets/DOCKER_USERNAME_SECRET_NAME/versions/DOCKER_USERNAME_SECRET_VERSION
    env: 'USERNAME'

    JSON 

    {
  "steps": [
  {
    "name": "gcr.io/cloud-builders/docker",
    "entrypoint": "bash",
    "args": [
      "-c",
      "docker login --username=$$USERNAME --password=$$PASSWORD"
    ],
    "secretEnv": [
      "USERNAME",
      "PASSWORD"
    ]
  }
  ],
  "availableSecrets": {
    "secretManager": [{
      "versionName": "projects/PROJECT_ID/secrets/DOCKER_PASSWORD_SECRET_NAME/versions/DOCKER_PASSWORD_SECRET_VERSION",
      "env": "PASSWORD"
  }, {
    "versionName": "projects/PROJECT_ID/secrets/DOCKER_USERNAME_SECRET_NAME/versions/DOCKER_USERNAME_SECRET_VERSION",
    "env": "USERNAME"
     }]
  }
}

    Replace the placeholder values in the above commands with the following:

    • PROJECT_ID: The ID of the Google Cloud project where you've stored your secrets.
    • DOCKER_USERNAME_SECRET_NAME: The secret name corresponding to your Docker username. You can get the secret name from the Secret Manager page in the Google Cloud console.
    • DOCKER_USERNAME_SECRET_VERSION: The secret version of your Docker username. You can get the secret version by clicking on a secret name on the Secret Manager page in the Google Cloud console.
    • DOCKER_PASSWORD_SECRET_NAME: The secret name corresponding to your Docker password. You can get the secret name from the Secret Manager page in the Google Cloud console.
    • DOCKER_PASSWORD_SECRET_VERSION: The secret version of your Docker password. You can get the secret version by clicking on a secret name on the Secret Manager page in the Google Cloud console.

  3. Use the build config file to start a build using the command line or to automate builds using triggers.

Example: Accessing secrets from scripts and processes

secretEnv field adds the value of the secret to the environment and you can access this value via environment variable from scripts or processes:

YAML 

steps:
- name: python:slim
  entrypoint: python
  args: ['main.py']
  secretEnv: ['MYSECRET']
availableSecrets:
  secretManager:
  - versionName: projects/$PROJECT_ID/secrets/mySecret/versions/latest
    env: 'MYSECRET'

JSON 

{
  "steps": [
  {
    "name": "python:slim",
    "entrypoint": "python",
    "args": [
        "main.py"
    ],
    "secretEnv": [
        "MYSECRET"
    ]
}
],
"availableSecrets": {
  "secretManager": [
    {
        "versionName": "projects/$PROJECT_ID/secrets/mySecret/versions/latest",
        "env": "MYSECRET"
    }
  ]
}
}

The following contents of main.py prints the first five characters of the secret:

import os
print(os.environ.get("MYSECRET", "Not Found")[:5], "...")

Example: authenticating to Docker

In some situations, before interacting with Docker images, your build would need to authenticate to Docker. For example, Docker authentication is required for builds to pull private images and push private or public images to Docker Hub. In these cases, you can store your Docker username and password in Secret Manager and then configure Cloud Build to access the username and password from Secret Manager. For instructions on doing this see Interacting with Docker Hub images.

Example: GitHub pull request creation

Another example where you might want to configure your build to access a sensitive information from Secret Manager is for creating a GitHub pull request in response to builds. To do this:

  • Create a GitHub token.
  • Store the GitHub token in Secret Manager.
  • In your build config file:
    • After all the build steps, add an availableSecrets field to specify the secret version and the environment variable to use for the GitHub token.
    • Add a build step to invoke the command to create a GitHub pull request.
  • Create a GitHub app trigger and use the build config file to invoke the trigger.

The following example config file shows how to create a GitHub pull request using the GitHub token:

YAML 

steps:
- name: 'launcher.gcr.io/google/ubuntu1604'
  id: Create GitHub pull request
  entrypoint: bash
  args:
  - -c
  - curl -X POST -H "Authorization:Bearer $$GH_TOKEN" -H 'Accept:application/vnd.github.v3+json' https://api.github.com/repos/GITHUB_USERNAME/REPO_NAME/pulls -d '{"head":"HEAD_BRANCH","base":"BASE_BRANCH", "title":"NEW_PR"}'
  secretEnv: ['GH_TOKEN']
availableSecrets:
  secretManager:
  - versionName: projects/PROJECT_ID/secrets/GH_TOKEN_SECRET_NAME/versions/latest
    env: GH_TOKEN


 JSON 
{
  "steps": [
  {
    "name": "launcher.gcr.io/google/ubuntu1604",
    "id": "Create GitHub pull request",
    "entrypoint": "bash",
    "args": [
      "-c",
       "curl -X POST -H \"Authorization:Bearer $$GH_TOKEN\" -H 'Accept:application/vnd.github.v3+json' https://api.github.com/repos/GITHUB_USERNAME/REPO_NAME -d '{\"head\":\"HEAD_BRANCH\",\"base\":\"BASE_BRANCH\", \"title\":\"NEW_PR\"}'
    ],
    "secretEnv": ['GH_TOKEN']
}
],
"availableSecrets": {
  "secretManager": [
  {
    "versionName": "projects/PROJECT_ID/secrets/GH_TOKEN_SECRET_NAME/versions/latest",
    "env": "GH_TOKEN"
  }
  ]
}
}




Substitua os valores dos marcadores nos comandos acima pelo seguinte:



    

  • PROJECT_ID: o ID do projeto do Google Cloud
em que você armazenou os secrets.
    • 

  • GITHUB_USERNAME: o nome de usuário do GitHub do proprietário do repositório;
    • 

  • REPO_NAME: o nome do repositório do GitHub.
    • 

  • HEAD_BRANCH: o nome da ramificação em que as alterações
são implementadas. Para solicitações de envio entre repositórios na mesma rede, o namespace
head com um usuário como este: username:branch.
    • 

  • BASE_BRANCH: o nome da ramificação em que você quer receber as
mudanças. Essa precisa ser uma ramificação existente no repositório atual. Não é possível enviar uma solicitação de envio para um repositório que solicita uma mesclagem a uma base de outro repositório.
    • 

  • GH_TOKEN_SECRET_NAME: o nome do secret correspondente ao seu token do GitHub.
    • 

  • NEW_PR: a nova solicitação de envio que você quer criar;
    • 




Configurar builds para acessar secrets não UTF-8 do Secret Manager


    

  1. No arquivo de configuração da versão, adicione uma etapa de versão para acessar a versão secreta no Gerenciador de secrets e armazená-la em um arquivo. A etapa de versão a seguir acessa secret-name
e a armazena em um arquivo chamado decrypted-data.txt:
    

    

     YAML 
    steps:
- name: gcr.io/cloud-builders/gcloud
  entrypoint: 'bash'
  args: [ '-c', "gcloud secrets versions access latest --secret=secret-name --format='get(payload.data)' | tr '_-' '/+' | base64 -d > decrypted-data.txt" ]

    

     JSON 
    {
  "steps": [
  {
    "name": "gcr.io/cloud-builders/gcloud",
    "entrypoint": "bash",
    "args": [
      "-c",
      "gcloud secrets versions access latest --secret=secret-name --format='get(payload.data)' | tr '_-' '/+' | base64 -d > decrypted-data.txt"
    ]
  }
  ]
}

    

    2. 

  2. Use o arquivo com os dados descriptografados em uma etapa de versão. O snippet de código a seguir
usa decrypted-data.txt para fazer login em um registro particular
do Docker:
    

    

     YAML 
    steps:
- name: gcr.io/cloud-builders/gcloud
  entrypoint: 'bash'
  args: [ '-c', "gcloud secrets versions access latest --secret=secret-name --format='get(payload.data)' | tr '_-' '/+' | base64 -d > decrypted-data.txt" ]
- name: gcr.io/cloud-builders/docker
  entrypoint: 'bash'
  args: [ '-c', 'docker login --username=my-user --password-stdin < decrypted-data.txt']

    

     JSON 
    {
  "steps": [
  {
    "name": "gcr.io/cloud-builders/gcloud",
    "entrypoint": "bash",
    "args": [
      "-c",
      "gcloud secrets versions access latest --secret=secret-name --format='get(payload.data)' | tr '_-' '/+' | base64 -d > password.txt"
     ]
  },
  {
    "name": "gcr.io/cloud-builders/docker",
    "entrypoint": "bash",
    "args": [
      "-c",
      "docker login --username=my-user --password-stdin < decrypted-data.txt"
     ]
  }
  ]
}

    

    3. 

  3. Use o arquivo de configuração do build para iniciar um build usando a linha de comando
ou automatizar builds usando gatilhos.
    4. 



A seguir