Protege datos sensibles con Secret Manager con lotes

En este documento, se describe cómo proteger los datos sensibles que deseas especificar para un trabajo por lotes con secretos de Secret Manager.

Secretos de Secret Manager proteger datos sensibles mediante encriptación. En un trabajo por lotes, puedes especificar uno o más secretos existentes para pasar de forma segura los datos sensibles que contienen, lo siguiente:

  • Definir de forma segura variables de entorno personalizadas que contienen datos sensibles.

  • Especifica de forma segura las credenciales de acceso de un Docker Registry para permitir que los elementos ejecutables de una tarea accedan a sus imágenes de contenedor privadas.

Antes de comenzar

  1. Si nunca antes usaste Batch, consulta Cómo comenzar a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.
  2. Crea un secreto o identifica un secreto para los datos sensibles que deseas especificar de forma segura para un trabajo.

  3. A fin de obtener los permisos que necesitas para crear un trabajo, solicita a tu administrador que te otorgue el los siguientes roles de IAM:

    Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

  4. Para garantizar que la cuenta de servicio del trabajo tenga los permisos necesarios para acceder a los secretos, pídele a tu administrador que le otorgue a la cuenta de servicio del trabajo el rol de IAM de Descriptor de acceso a secretos de Secret Manager (roles/secretmanager.secretAccessor) en el secreto.

Pasa datos sensibles de forma segura a variables de entorno personalizadas

Para pasar de forma segura datos sensibles de los secretos de Secret Manager a variables de entorno personalizadas, debes definir cada variable de entorno en el subcampo de variables secretas (secretVariables) para un entorno y especificar un secreto para cada valor. Cada vez que especificas un secreto en un trabajo, debes darle el formato de una ruta de acceso. a una versión del Secret: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

Puedes crear un trabajo que defina variables secretas con la CLI de gcloud, la API de Batch, Java, Node.js o Python. En el siguiente ejemplo, se explica cómo crear un trabajo que define y usa una variable secreta para el entorno de todos los ejecutables (subcampo environment de taskSpec).

gcloud

  1. Crea un archivo JSON que especifique los detalles de configuración del trabajo y incluya el subcampo secretVariables para uno o más entornos.

    Por ejemplo, para crear un trabajo de secuencia de comandos básico que use un en el entorno para todos los ejecutables, crea un archivo JSON con el siguiente contenido:

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

    Reemplaza lo siguiente:

    • SECRET_VARIABLE_NAME: Es el nombre de la variable secreta. Por convención, los nombres de variable de entorno mayúsculas.

      Para acceder de forma segura a los datos sensibles desde el Secret Manager, especifica el nombre de esta variable en esta ejecutables del trabajo. Todos los elementos ejecutables que se encuentran en el mismo entorno en el que defines la variable secreta pueden acceder a ella.

    • PROJECT_ID: Es el ID del proyecto.

    • SECRET_NAME: Es el nombre de un secreto existente de Secret Manager.

    • VERSION: el versión del Secret especificado que contiene los datos que deseas para pasar al trabajo. Puede ser el número de versión o latest.

  2. Para crear y ejecutar el trabajo, usa el Comando gcloud batch jobs submit:

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.

    • LOCATION: Es la ubicación del trabajo.

    • JSON_CONFIGURATION_FILE: Es la ruta de acceso para un JSON. con los detalles de configuración del trabajo.

API

Realiza una solicitud POST al método jobs.create que especifique el subcampo secretVariables para uno o más entornos.

Por ejemplo, para crear un trabajo de secuencia de comandos básico que use una variable secreta en el entorno para todos los elementos ejecutables, realiza la siguiente solicitud:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.

  • LOCATION: Es la ubicación del trabajo.

  • JOB_NAME: Es el nombre del trabajo.

  • SECRET_VARIABLE_NAME: Es el nombre de la variable secreta. Por convención, los nombres de variable de entorno mayúsculas.

    Para acceder de forma segura a los datos sensibles del secreto de Secret Manager de la variable, especifica el nombre de esta variable en los elementos ejecutables de esta tarea. Todos los elementos ejecutables que se encuentran en el mismo entorno en el que defines la variable secreta pueden acceder a ella.

  • SECRET_NAME: Es el nombre de un secreto de Secret Manager existente.

  • VERSION: Es la versión del secreto especificado que contiene los datos que deseas pasar al trabajo. Puede ser el número de versión o 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)

Accede de forma segura a las imágenes de contenedor que requieren credenciales del registro de Docker

Para usar una imagen de contenedor de un registro privado de Docker, un ejecutable debe especificar credenciales de acceso que le permitan acceder a ese registro de Docker. Específicamente, para cualquier contenedor ejecutable con el campo URI de la imagen (imageUri) establecido en una imagen de un registro privado de Docker, debes especificar las credenciales necesarias para acceder a ese registro de Docker con el campo de nombre de usuario (username) y el campo de contraseña (password).

Para proteger las credenciales sensibles de un registro de Docker, especifica secretos existentes que contengan la información en lugar de definir estos campos directamente. Cada vez que especifiques un secreto en un trabajo, debes darle el formato de una ruta a una versión del secreto: projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION.

Puedes crear un trabajo que use imágenes de contenedor de un registro de Docker privado con la CLI de gcloud o la API de Batch. En el siguiente ejemplo, se explica cómo crear un trabajo que use una imagen de contenedor de un registro privado de Docker especificando el nombre de usuario directamente y la contraseña como un secreto.

gcloud

  1. Crea un archivo JSON que especifique los detalles de configuración del trabajo. Para cualquier contenedor ejecutable que use imágenes de un contenedor Docker, incluye las credenciales necesarias para acceder a él. en los campos username y password.

    Por ejemplo, para crear un trabajo de contenedor básico que especifique una imagen de un registro privado de Docker, crea un archivo JSON con el siguiente contenido:

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

    Reemplaza lo siguiente:

    • PRIVATE_IMAGE_URI: Es el URI de imagen de un contenedor de un registro privado de Docker. Si esta imagen requiere cualquier otra configuración de contenedor debes incluirlos también.

    • USERNAME: Es el nombre de usuario del registro privado de Docker, que se puede especificar como un secreto o directamente.

    • PASSWORD: el contraseña para el registro privado de Docker, que se puede especificar como secreto (recomendado) o directamente.

      Por ejemplo, para especificar la contraseña como un secreto, configura PASSWORD de la siguiente manera:

      projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

      Reemplaza lo siguiente:

  2. Para crear y ejecutar la tarea, usa el comando gcloud batch jobs submit:

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre del trabajo.

    • LOCATION: Es la ubicación. del trabajo.

    • JSON_CONFIGURATION_FILE: Es la ruta de acceso a un archivo JSON con los detalles de configuración de la tarea.

API

Realiza una solicitud POST al método jobs.create. Para cualquier contenedor ejecutable que use imágenes de un contenedor Docker, incluye las credenciales necesarias para acceder a él. en los campos username y password.

Por ejemplo, para crear un trabajo de contenedor básico que especifique una imagen de un registro privado de Docker, realiza la siguiente solicitud:

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

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto.

  • LOCATION: Es la ubicación. del trabajo.

  • JOB_NAME: Es el nombre del trabajo.

  • PRIVATE_IMAGE_URI: Es el URI de imagen para un de contenedor desde un registro privado de Docker. Si esta imagen requiere cualquier otra configuración de contenedor debes incluirlos también.

  • USERNAME: el nombre de usuario para el registro privado de Docker, que se puede especificar como secreto o directamente.

  • PASSWORD: el contraseña para el registro privado de Docker, que se puede especificar como secreto (recomendado) o directamente.

    Por ejemplo, para especificar la contraseña como un secreto, configura PASSWORD de la siguiente manera:

    projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

    Reemplaza lo siguiente:

¿Qué sigue?