Utiliser les secrets de Secret Manager

Cette page explique comment inclure des informations sensibles telles que des mots de passe et des clés API dans Cloud Build.

Secret Manager est un service Google Cloudqui stocke de manière sécurisée des clés API, des mots de passe et d'autres données sensibles. Pour inclure des informations sensibles dans vos compilations, vous pouvez les stocker dans Secret Manager, puis configurer votre compilation pour accéder aux informations de Secret Manager.

Avant de commencer

• Activez les API Cloud Build et Secret Manager.

  Rôles requis pour activer les API

  Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

  Activer les API

• Pour utiliser les exemples de ligne de commande de ce guide, installez et configurez Google Cloud CLI.

  Remarque : Si vous avez déjà installé la gcloud CLI, assurez-vous de disposer de la dernière version disponible en exécutant gcloud components update.

• Assurez-vous d'avoir stocké le secret dans Secret Manager. Pour obtenir des instructions, consultez la section Créer un secret.

  • Notez le nom et la version du secret. Vous aurez besoin de ces informations pour configurer Cloud Build et lui permettre d'accéder au secret.

Autorisations IAM requises

Accordez le rôle IAM Accesseur de secrets Secret Manager (roles/secretmanager.secretAccessor) pour le secret au compte de service que vous utilisez pour la compilation :

1. Ouvrez la page Secret Manager dans la console Google Cloud  :

   Accéder à la page Secret Manager

2. Cochez la case correspondant au secret que vous souhaitez utiliser dans votre compilation.

3. S'il n'est pas déjà ouvert, cliquez sur Afficher le panneau d'informations pour ouvrir celui-ci.

4. Dans le panneau, sous Autorisations, cliquez sur Ajouter un compte principal.

5. Dans le champ Nouveaux comptes principaux, saisissez l'adresse e-mail de votre compte de service.

6. Dans la boîte déroulante Sélectionner un rôle, sélectionnez Accesseur de secrets Secret Manager.

7. Cliquez sur Enregistrer.

Avertissement : Attribuer le rôle d'Accesseur de secrets Secret Manager à l'ancien compte de service Cloud Build permet à ce compte de service d'accéder au secret. Si le déclencheur de compilation est configuré pour utiliser l'ancien compte de service Cloud Build afin d'exécuter des compilations, tout utilisateur qui utilise des déclencheurs de compilation pour exécuter des compilations disposera des autorisations accordées au compte de service au moment de la compilation. Cela permet aux utilisateurs ne disposant pas du rôle "Accesseur de secrets" d'utiliser des déclencheurs de compilation pour effectuer une compilation qui accède au secret. Cette action est enregistrée dans l'historique de compilation du projet.

Configurer les compilations pour accéder à des secrets UTF-8 à partir de Secret Manager

1. Dans le répertoire racine de votre projet, créez un fichier de configuration de compilation nommé cloudbuild.yaml ou cloudbuild.json.

2. Dans le fichier de configuration de compilation :

   • Après toutes les compilations steps, ajoutez un champ availableSecrets contenant un champ secretManager. Le champ secretManager contient une ou plusieurs paires de champs versionName et env :

     • versionName : chemin d'accès au secret dans Secret Manager. Vous pouvez inclure des variables de substitution dans la valeur de ce champ.
     • env : nom local (variable d'environnement) que les étapes de compilation peuvent utiliser pour faire référence au secret.

   • À l'étape de compilation où vous souhaitez spécifier le secret :

     • Ajoutez un champ entrypoint pointant vers bash pour utiliser l'outil bash dans l'étape de compilation. Cette valeur est obligatoire pour faire référence à la variable d'environnement du secret.
     • Ajoutez un champ secretEnv. Ce champ spécifie les variables d'environnement qui peuvent être utilisées dans cette étape.
     • Dans le champ args, ajoutez une option -c en tant que premier argument. Toutes les chaînes que vous transmettez après -c sont traitées comme des commandes. Pour en savoir plus sur l'exécution des commandes bash avec -c, consultez la documentation bash.
     • Lorsque vous spécifiez le secret dans le champ args, spécifiez-le à l'aide de la variable d'environnement précédée de $$.
   Note: You can refer to secrets only in the args field of a build step.

   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 preceding commands with the following:

   • PROJECT_ID: The project ID or project number 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

In this example, a secret is defined in the build step so that it can be used later in a script:

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

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

• PROJECT_ID: The project ID or project number of the Google Cloud project where you've stored your secrets.
• GITHUB_USERNAME: The GitHub username of the repository owner.
• REPO_NAME: The name of the GitHub repository.
• HEAD_BRANCH: The name of the branch where the changes are implemented. For cross-repository pull requests in the same network, namespace head with a user like this: username:branch.
• BASE_BRANCH: The name of the branch you want the changes pulled into. This should be an existing branch on the current repository. You cannot submit a pull request to one repository that requests a merge to a base of another repository.
• GH_TOKEN_SECRET_NAME: The secret name corresponding to your GitHub token.
• NEW_PR: The new pull request you want to create.

Configuring builds to access non-UTF-8 secrets from Secret Manager

1. In your build config file, add a build step to access the secret version in Secret Manager and store it in a file. The following build step accesses secret-name and stores it in a file named 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. Use the file with the decrypted data in a build step. The following code snippet uses decrypted-data.txt to login to a private Docker registry:

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

   Note: To use the secret in an environment variable, you must prefix the variable name with an underscore "_" and escape the value using $$. Par exemple : _VARIABLE_NAME=$(cat password.txt) && echo -n $$_VARIABLE_NAME.