Proteja dados confidenciais com o Secret Manager e o Batch

Este documento descreve como proteger dados confidenciais que quer especificar para uma tarefa em lote através de Secrets do Secret Manager.

Os segredos do Secret Manager protegem os dados confidenciais através da encriptação. Num trabalho em lote, pode especificar um ou mais segredos existentes para transmitir de forma segura os dados confidenciais que contêm, que pode usar para fazer o seguinte:

  • Definir em segurança variáveis de ambiente personalizadas que contêm dados confidenciais.

  • Especifique em segurança as credenciais de início de sessão para um registo do Docker para permitir que os executáveis de uma tarefa acedam às respetivas imagens de contentores privados.

Antes de começar

  1. Se nunca usou o Batch, reveja o artigo Comece a usar o Batch e ative o Batch concluindo os pré-requisitos para projetos e utilizadores.
  2. Crie um segredo ou identifique um segredo para os dados confidenciais que quer especificar em segurança para uma tarefa.

  3. Para receber as autorizações de que precisa para criar uma tarefa, peça ao seu administrador para lhe conceder as seguintes funções de IAM:

    Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

    Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

  4. Para garantir que a conta de serviço da tarefa tem as autorizações necessárias para aceder a segredos, peça ao administrador para conceder à conta de serviço da tarefa a função do IAM Secret Manager Secret Accessor (roles/secretmanager.secretAccessor) no segredo.

Transmita dados confidenciais em segurança para variáveis de ambiente personalizadas

Para transmitir dados confidenciais de forma segura de segredos do Secret Manager para variáveis de ambiente personalizadas, tem de definir cada variável de ambiente no subcampo secret variables (secretVariables) para um ambiente e especificar um segredo para cada valor. Sempre que especificar um segredo num trabalho, tem de o formatar como um caminho para uma versão do segredo: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION.

Pode criar uma tarefa que defina variáveis secretas usando a CLI gcloud, a API Batch, o Java, o Node.js ou o Python. O exemplo seguinte explica como criar uma tarefa que define e usa uma variável secreta para o ambiente de todos os executáveis (subcampo environment de taskSpec).

gcloud

  1. Crie um ficheiro JSON que especifique os detalhes de configuração da tarefa e inclua o subcampo secretVariables para um ou mais ambientes.

    Por exemplo, para criar uma tarefa de script básica que use uma variável secreta no ambiente para todos os executáveis, crie um ficheiro JSON com o seguinte conteúdo:

    {
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "script": {
              "text": "echo This is the secret: ${SECRET_VARIABLE_NAME}"
            }
          }
        ],
        "environment": {
          "secretVariables": {
            "{SECRET_VARIABLE_NAME}": "projects/PROJECT_ID/secrets/SECRET_NAME/versions/VERSION"
          }
        }
      }
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

    Substitua o seguinte:

    • SECRET_VARIABLE_NAME: o nome da variável secreta. Por convenção, os nomes das variáveis de ambiente são escritos em maiúsculas.

      Para aceder de forma segura aos dados confidenciais do segredo do Secret Manager, especifique este nome de variável nos executáveis desta tarefa. A variável secreta é acessível a todos os runnables que estão no mesmo ambiente onde define a variável secreta.

    • PROJECT_ID: o ID do projeto do seu projeto.

    • SECRET_NAME: o nome de um segredo do Secret Manager existente.

    • VERSION: a versão do segredo especificado que contém os dados que quer transmitir à tarefa. Pode ser o número da versão ou latest.

  2. Para criar e executar a tarefa, use o comando gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.

    • LOCATION: a localização do trabalho.

    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Faça um pedido POST ao método jobs.create que especifica o subcampo secretVariables para um ou mais ambientes.

Por exemplo, para criar uma tarefa de script básica que use uma variável secreta no ambiente para todos os executáveis, faça o seguinte pedido:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
{
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "script": {
              "text": "echo This is the secret: ${SECRET_VARIABLE_NAME}"
            }
          }
        ],
        "environment": {
          "secretVariables": {
            "{SECRET_VARIABLE_NAME}": "projects/PROJECT_ID/secrets/SECRET_NAME/versions/VERSION"
          }
        }
      }
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto do seu projeto.

  • LOCATION: a localização do trabalho.

  • JOB_NAME: o nome da tarefa.

  • SECRET_VARIABLE_NAME: o nome da variável secreta. Por convenção, os nomes das variáveis de ambiente são escritos em maiúsculas.

    Para aceder de forma segura aos dados confidenciais do segredo do Secret Manager, especifique este nome de variável nos executáveis desta tarefa. A variável secreta é acessível a todos os runnables que estão no mesmo ambiente onde define a variável secreta.

  • SECRET_NAME: o nome de um segredo do Secret Manager existente.

  • VERSION: a versão do segredo especificado que contém os dados que quer transmitir à tarefa. Pode ser o número da versão ou latest.

Java 


import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Environment;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateBatchUsingSecretManager {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // The name of the secret variable.
    // This variable name is specified in this job's runnables
    // and is accessible to all of the runnables that are in the same environment.
    String secretVariableName = "VARIABLE_NAME";
    // The name of an existing Secret Manager secret.
    String secretName = "SECRET_NAME";
    // The version of the specified secret that contains the data you want to pass to the job.
    // This can be the version number or latest.
    String version = "VERSION";

    createBatchUsingSecretManager(projectId, region,
            jobName, secretVariableName, secretName, version);
  }

  // Create a basic script job to securely pass sensitive data.
  // The data is obtained from Secret Manager secrets
  // and set as custom environment variables in the job.
  public static Job createBatchUsingSecretManager(String projectId, String region,
                                                  String jobName, String secretVariableName,
                                                  String secretName, String version)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          String.format("echo This is the secret: ${%s}.", secretVariableName))
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      // Construct the resource path to the secret's version.
      String secretValue = String
              .format("projects/%s/secrets/%s/versions/%s", projectId, secretName, version);

      // Set the secret as an environment variable.
      Environment.Builder environmentVariable = Environment.newBuilder()
          .putSecretVariables(secretVariableName, secretValue);

      TaskSpec task = TaskSpec.newBuilder()
          // Jobs can be divided into tasks. In this case, we have only one task.
          .addRunnables(runnable)
          .setEnvironment(environmentVariable)
          .setMaxRetryCount(2)
          .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
          .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskSpec(task)
          .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-job-secret-manager';
// The name of the secret variable.
// This variable name is specified in this job's runnables
// and is accessible to all of the runnables that are in the same environment.
const secretVariableName = 'secretVariableName';
// The name of an existing Secret Manager secret.
const secretName = 'secretName';
// The version of the specified secret that contains the data you want to pass to the job.
// This can be the version number or latest.
const version = 'version';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', `echo This is the secret: ${secretVariableName}`],
  }),
});

// Construct the resource path to the secret's version.
const secretValue = `projects/${projectId}/secrets/${secretName}/versions/${version}`;

// Set the secret as an environment variable.
const environment = new batch.Environment();
environment.secretVariables[secretVariableName] = secretValue;

const task = new batch.TaskSpec({
  runnables: [runnable],
  environment,
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateUsingSecretManager() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const [response] = await batchClient.createJob(request);
  console.log(JSON.stringify(response));
}

await callCreateUsingSecretManager();

Python 

from typing import Dict, Optional

from google.cloud import batch_v1


def create_with_secret_manager(
    project_id: str,
    region: str,
    job_name: str,
    secrets: Dict[str, str],
    service_account_email: Optional[str] = None,
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances with passing secrets from secret manager.
    Note: Job's service account should have the permissions to access secrets.
        - Secret Manager Secret Accessor (roles/secretmanager.secretAccessor) IAM role.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        secrets: secrets, which should be passed to the job. Environment variables should be capitalized
        by convention https://google.github.io/styleguide/shellguide.html#constants-and-environment-variable-names
            The format should look like:
                - {'SECRET_NAME': 'projects/{project_id}/secrets/{SECRET_NAME}/versions/{version}'}
            version can be set to 'latest'.
        service_account_email (optional): custom service account email

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = (
        "echo Hello world! from task ${BATCH_TASK_INDEX}."
        + f" ${next(iter(secrets.keys()))} is the value of the secret."
    )
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    envable = batch_v1.Environment()
    envable.secret_variables = secrets
    task.environment = envable

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    service_account = batch_v1.ServiceAccount()
    service_account.email = service_account_email
    allocation_policy.service_account = service_account

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Aceda em segurança a imagens de contentores que requerem credenciais do registo do Docker

Para usar uma imagem de contentor de um registo Docker privado, um executável tem de especificar credenciais de início de sessão que lhe permitam aceder a esse registo Docker. Especificamente, para qualquer contentor executável com o campo URI da imagem (imageUri) definido como uma imagem de um registo Docker privado, tem de especificar as credenciais necessárias para aceder a esse registo Docker através do campo nome de utilizador (username) e do campo palavra-passe (password).

Pode proteger quaisquer credenciais confidenciais para um registo do Docker especificando segredos existentes que contenham as informações em vez de definir estes campos diretamente. Sempre que especificar um segredo num trabalho, tem de o formatar como um caminho para uma versão do segredo: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION.

Pode criar uma tarefa que use imagens de contentores de um registo do Docker privado através da CLI gcloud ou da API Batch. O exemplo seguinte explica como criar uma tarefa que usa uma imagem de contentor de um registo Docker privado especificando o nome de utilizador diretamente e a palavra-passe como um segredo.

gcloud

  1. Crie um ficheiro JSON que especifique os detalhes de configuração da tarefa. Para todos os executáveis de contentores que usam imagens de um registo do Docker privado, inclua todas as credenciais necessárias para aceder ao mesmo nos campos username e password.

    Por exemplo, para criar uma tarefa de contentor básica que especifique uma imagem de um registo Docker privado, crie um ficheiro JSON com o seguinte conteúdo:

    {
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "container": {
              "imageUri": "PRIVATE_IMAGE_URI",
              "commands": [
                "-c",
                "echo This runnable uses a private image."
              ],
              "username": "USERNAME",
              "password": "PASSWORD"
            }
          }
        ],
      }
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

    Substitua o seguinte:

    • PRIVATE_IMAGE_URI: o URI da imagem de um contentor de um registo Docker privado. Se esta imagem requerer outras definições do contentor, também as tem de incluir.

    • USERNAME: o nome de utilizador do registo Docker privado, que pode ser especificado como um segredo ou diretamente.

    • PASSWORD: a palavra-passe do registo Docker privado, que pode ser especificada como um segredo (recomendado) ou diretamente.

      Por exemplo, para especificar a palavra-passe como um segredo, defina PASSWORD da seguinte forma:

      projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

      Substitua o seguinte:

  2. Para criar e executar a tarefa, use o comando gcloud batch jobs submit:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Substitua o seguinte:

    • JOB_NAME: o nome da tarefa.

    • LOCATION: a localização do trabalho.

    • JSON_CONFIGURATION_FILE: o caminho para um ficheiro JSON com os detalhes de configuração da tarefa.

API

Faça um pedido POST ao método jobs.create. Para todos os executáveis de contentores que usam imagens de um registo do Docker privado, inclua todas as credenciais necessárias para aceder ao mesmo nos campos username e password.

Por exemplo, para criar uma tarefa de contentor básica que especifica uma imagem de um registo Docker privado, faça o seguinte pedido:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
{
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "container": {
              "imageUri": "PRIVATE_IMAGE_URI",
                "commands": [
                  "-c",
                  "echo This runnable uses a private image."
                ],
                "username": "USERNAME",
                "password": "PASSWORD"
            }
          }
        ],
      }
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

Substitua o seguinte:

  • PROJECT_ID: o ID do projeto do seu projeto.

  • LOCATION: a localização do trabalho.

  • JOB_NAME: o nome da tarefa.

  • PRIVATE_IMAGE_URI: o URI da imagem de um contentor de um registo Docker privado. Se esta imagem requerer outras definições do contentor, também as tem de incluir.

  • USERNAME: o nome de utilizador do registo Docker privado, que pode ser especificado como um segredo ou diretamente.

  • PASSWORD: a palavra-passe do registo Docker privado, que pode ser especificada como um segredo (recomendado) ou diretamente.

    Por exemplo, para especificar a palavra-passe como um segredo, defina PASSWORD da seguinte forma:

    projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

    Substitua o seguinte:

O que se segue?