Secrets aus Secret Manager verwenden

Auf dieser Seite wird erläutert, wie Sie vertrauliche Informationen wie Passwörter und API-Schlüssel in Cloud Build einbinden.

Secret Manager ist ein Google Cloud-Dienst, der API-Schlüssel, Passwörter und andere sensible Daten sicher speichert. Wenn Sie vertrauliche Informationen in Ihre Builds aufnehmen möchten, können Sie die Informationen in Secret Manager speichern und dann den Build für den Zugriff auf die Informationen aus Secret Manager konfigurieren.

Hinweis

  • Enable the Cloud Build and Secret Manager APIs.

    Enable the APIs

  • Um die Befehlszeilenbeispiele in dieser Anleitung zu verwenden, installieren und Konfigurieren Sie die Google Cloud CLI.

  • Das Secret muss in Secret Manager gespeichert werden. Eine Anleitung finden Sie unter Secret erstellen.

    • Notieren Sie sich den Namen des Secrets und die Secret-Version Ihres Secrets. Sie benötigen diese Informationen, um Cloud Build für den Zugriff auf das Secret zu konfigurieren.

Erforderliche IAM-Berechtigungen

Weisen Sie dem Dienstkonto, das Sie für den Build verwenden, die IAM-Rolle Zugriffsperson für Secret Manager-Secret (roles/secretmanager.secretAccessor) für das Secret zu:

  1. Öffnen Sie in der Google Cloud Console die Seite „Secret Manager“:

    Zur Seite „Secret Manager“

  2. Klicken Sie auf das Kästchen des Secrets, das Sie in Ihrem Build verwenden möchten.

  3. Falls das Fenster noch nicht geöffnet ist, klicken Sie auf Infofeld ansehen, um es zu öffnen.

  4. Klicken Sie im Steuerfeld unter Berechtigungen auf Hauptkonto hinzufügen.

  5. Geben Sie im Feld Neue Hauptkonten die E-Mail-Adresse Ihres Dienstkontos ein.

  6. Wählen Sie im Drop-down-Menü Rolle auswählen die Option Auf Secret Manager-Secret zugreifende Person.

  7. Klicken Sie auf Speichern.

Builds für den Zugriff auf UTF-8-Secrets aus Secret Manager konfigurieren

  1. Erstellen Sie im Stammverzeichnis des Projekts eine Cloud Build-Konfigurationsdatei mit dem Namen cloudbuild.yaml oder cloudbuild.json.

  2. In der Build-Konfigurationsdatei:

    • Fügen Sie nach allen Build-steps ein Feld availableSecrets hinzu, um die Secret-Version und die Umgebungsvariablen anzugeben, die für Ihr Secret verwendet werden sollen. In den Wert des Felds secretVersion können Sie Substitutionsvariablen einfügen. Sie können in einem Build mehrere Secrets angeben.
    • Geben Sie im Build-Schritt, in dem Sie das Secret angeben möchten, Folgendes an:
      • Fügen Sie das Feld entrypoint hinzu, das auf bash verweist, um das Bash-Tool im Build-Schritt zu verwenden. Dies ist erforderlich, um auf die Umgebungsvariable für den geheim halten.
      • Fügen Sie das Feld secretEnv hinzu, das die Umgebungsvariable angibt.
      • Fügen Sie im Feld args das Flag -c als erstes Argument hinzu. Jeder String, den Sie nach -c übergeben, wird als Befehl behandelt. Weitere Informationen zum Ausführen von Bash-Befehlen mit -c finden Sie in der Bash-Dokumentation.
      • Wenn Sie das Secret im Feld args angeben, geben Sie es mithilfe der Methode Umgebungsvariable mit dem Präfix $$.

    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"
  }
  ]
}
}




Ersetzen Sie die Platzhalterwerte in den obigen Befehlen durch Folgendes:



    

  • PROJECT_ID: die ID des Google Cloud-Projekts
wo Sie Ihre Geheimnisse gespeichert haben.
    • 

  • GITHUB_USERNAME: Der GitHub-Nutzername des Repository-Inhabers.
    • 

  • REPO_NAME: Der Name des GitHub-Repositorys.
    • 

  • HEAD_BRANCH: Der Name des Zweigs, in dem die Änderungen implementiert sind. Geben Sie bei repository-übergreifende Pull-Anfragen im gleichen Netzwerk für den Namespace head einen Nutzer wie den folgenden an: username:branch.
    • 

  • BASE_BRANCH: Der Name des Zweigs, in den die Änderungen übernommen werden sollen. Dies sollte ein vorhandener Zweig im aktuellen Repository sein. Sie können keine Pull-Anfrage an ein Repository senden, das eine Zusammenführung an eine Basis eines anderen Repositorys anfordert.
    • 

  • GH_TOKEN_SECRET_NAME: Der Secret-Name, der Ihrem GitHub-Token entspricht.
    • 

  • NEW_PR: Die neue Pull-Anfrage, die Sie erstellen möchten.
    • 




Builds für den Zugriff auf Nicht-UTF-8-Secrets aus Secret Manager konfigurieren


    

  1. Fügen Sie in Ihrer Build-Konfigurationsdatei einen Build-Schritt hinzu, um im Secret Manager auf die geheime Version zuzugreifen und sie in einer Datei zu speichern. Mit dem folgenden Build-Schritt wird auf secret-name zugegriffen und in der Datei decrypted-data.txt gespeichert:
    

    

    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. Verwenden Sie die Datei mit den entschlüsselten Daten in einem Build-Schritt. Das folgende Code-Snippet verwendet zur Anmeldung bei einer privaten Docker-Registry 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" ]
- 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. Verwenden Sie die Build-Konfigurationsdatei, um einen Build über die Befehlszeile zu starten oder Builds mit Triggern zu automatisieren.
    4. 



Nächste Schritte