Utilizzare i secret di Secret Manager

Questa pagina spiega come includere informazioni sensibili come password e chiavi API in Cloud Build.

Secret Manager è un servizio Google Cloud che archivia in modo sicuro chiavi API, password e altri dati sensibili. Per includere informazioni sensibili nelle build, puoi archiviarle in Secret Manager e poi configurare la build in modo che acceda alle informazioni da Secret Manager.

Prima di iniziare

• Enable the Cloud Build and Secret Manager APIs.

  Enable the APIs

• Per utilizzare gli esempi a riga di comando in questa guida, installa e configura Google Cloud CLI.

  Nota: se hai già installato gcloud CLI, assicurati di avere la versione più recente disponibile eseguendo gcloud components update.

• Assicurati di aver archiviato il secret in Secret Manager. Per le istruzioni, consulta Creare un segreto.

  • Prendi nota del nome e della versione del secret. Avrai bisogno di queste informazioni per configurare Cloud Build in modo che acceda al secret.

Autorizzazioni IAM richieste

Concedi il ruolo IAM Accesso ai secret di Secret Manager (roles/secretmanager.secretAccessor) per il secret all'account di servizio che utilizzi per la compilazione:

1. Apri la pagina Secret Manager nella console Google Cloud :

   Vai alla pagina Secret Manager

2. Seleziona la casella di controllo del segreto che vuoi utilizzare nella compilazione.

3. Se non è già aperto, fai clic su Mostra riquadro informazioni per aprirlo.

4. Nel riquadro, fai clic su Aggiungi entità in Autorizzazioni.

5. Nel campo Nuove entità, inserisci l'indirizzo email del tuo account di servizio.

6. Nella casella a discesa Seleziona un ruolo, seleziona Accesso ai segreti di Secret Manager.

7. Fai clic su Salva.

Avviso: la concessione del ruolo Accesso ai secret di Secret Manager all'account di servizio Cloud Build precedente consente all'account di servizio di accedere al secret. Se Trigger di compilazione è configurato per utilizzare l'account di servizio Cloud Build precedente per eseguire le build, a qualsiasi utente che utilizza gli trigger di compilazione per eseguire le build verranno concesse le autorizzazioni all'account di servizio al momento della compilazione. In questo modo, gli utenti senza il ruolo Accesso ai segreti possono utilizzare gli attivatori di compilazione per eseguire una compilazione che accede al segreto. Questa azione viene registrata nella cronologia delle build del progetto.

Configurazione delle build per accedere ai secret UTF-8 da Secret Manager

1. Nella directory principale del progetto, crea un file di configurazione Cloud Build chiamato cloudbuild.yaml o cloudbuild.json.

2. Nel file di configurazione della build:

   • Dopo tutti i steps di compilazione, aggiungi un campo availableSecrets per specificare la versione del segreto e le variabili di ambiente da utilizzare per il segreto. Puoi includere variabili di sostituzione nel valore del campo secretVersion. Puoi specificare più di un segreto in una build.
   • Nel passaggio di compilazione in cui vuoi specificare il segreto:
     • Aggiungi un campo entrypoint che rimandi a bash per utilizzare lo strumento bash nel passaggio di compilazione. È obbligatorio fare riferimento alla variabile di ambiente per il segreto.
     • Aggiungi un campo secretEnv che specifica la variabile di ambiente.
     • Nel campo args, aggiungi un flag -c come primo argomento. Qualsiasi stringa che passi dopo -c viene considerata un comando. Per ulteriori informazioni sull'esecuzione di comandi bash con -c, consulta la documentazione di bash.
     • Quando specifichi il segreto nel campo args, utilizza la variabile di ambiente con prefisso $$.
   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 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"
  }
  ]
}
}


Sostituisci i valori segnaposto nei comandi precedenti con quanto segue:


PROJECT_ID: l'ID del progetto Google Cloud 
dove hai archiviato i tuoi secret.
GITHUB_USERNAME: il nome utente GitHub del proprietario del repository.
REPO_NAME: il nome del repository GitHub.
HEAD_BRANCH: il nome del ramo in cui vengono implementate le modifiche. Per le richieste pull tra repository nella stessa rete, usa lo spazio dei nomi
head con un utente come questo: username:branch.
BASE_BRANCH: il nome del ramo in cui vuoi che vengano incorporate le modifiche. Deve trattarsi di un branch esistente nel repository corrente. Non puoi inviare una richiesta di pull a un repository che richiede l'unione a una base di un altro repository.
GH_TOKEN_SECRET_NAME: il nome della chiave segreta corrispondente
al tuo token GitHub.
NEW_PR: la nuova richiesta di pull che vuoi creare.


Configurazione delle build per accedere ai secret non UTF-8 da Secret Manager

Nel file di configurazione di compilazione, aggiungi un passaggio di compilazione per accedere alla versione del secret in Secret Manager
e memorizzarla in un file. Il seguente passaggio di compilazione accede a secret-name
e lo memorizza in un file denominato 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"
    ]
  }
  ]
}


Utilizza il file con i dati decriptati in un passaggio di compilazione. Il seguente snippet di codice utilizza decrypted-data.txt per accedere a un registro Docker privato:

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

Nota: per utilizzare il segreto in una variabile di ambiente, devi anteporre al nome della variabile un trattino basso "_" ed eseguire la fuga del valore utilizzando "\('. For example:
_VARIABLE_NAME=$(cat password.txt) && echo -n \)_NOME_VARIABILE
.
Utilizza il file di configurazione della build per avviare una build utilizzando la riga di comando o per automatizzare le build utilizzando gli trigger.

Passaggi successivi


Scopri come utilizzare le credenziali criptate nelle build.
Scopri come accedere ai repository privati GitHub.




  

  

  
    
  

  

Invia feedback