Protege datos sensibles mediante Secret Manager con Batch

En este documento, se describe cómo proteger los datos sensibles que quieres especificar para un trabajo por lotes con los Secrets 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 para un Registro de Docker para permitir que los ejecutables de un trabajo accedan a sus imágenes de contenedor privadas.

Antes de comenzar

  1. Si nunca usaste Batch, revisa Comienza a usar Batch y habilitar Batch completando el requisitos previos para los proyectos y usuarios.
  2. Crea un secreto o identificar un secreto de los datos sensibles que quieres especificar de forma segura para un trabajo.

  3. Para obtener los permisos que necesitas para crear un trabajo, pídele a tu administrador que te otorgue 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 a variables de entorno personalizadas de forma segura

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) de 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 las variables del Secret con gcloud CLI, la API de Batch, Java 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 del secreto de Secret Manager de la variable, especifica el nombre de esta variable en los elementos ejecutables de esta tarea. Todas las instancias de la variable secreta pueden acceder ejecutables que se encuentran en el mismo entorno en la que defines la variable del secreto.

    • 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 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 que especifica 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, 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 desde el Secret Manager, especifica el nombre de esta variable en esta ejecutables del trabajo. Todas las instancias de la variable secreta pueden acceder ejecutables que se encuentran en el mismo entorno en la que defines la variable del secreto.

  • 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.

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

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 imágenes de contenedor que requieran 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. En particular, para cualquier contenedor que se pueda ejecutar con el Campo de URI de la imagen (imageUri) configurado en una imagen de un registro privado de Docker, debes especificar credenciales necesarias para acceder al registro de Docker con el campo nombre de usuario (username) y 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 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 use imágenes de contenedor de un registro privado de Docker con gcloud CLI o la API de Batch. En el siguiente ejemplo, se explica cómo crear un trabajo que use un contenedor de un registro privado de Docker especificando directamente el nombre de usuario y la contraseña como 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 una imagen de contenedor de 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, establece PASSWORD por lo siguiente:

      projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

      Reemplaza lo siguiente:

  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. 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, establece PASSWORD por lo siguiente:

    projects/PROJECT_ID/secrets/SECRET_ID/versions/VERSION

    Reemplaza lo siguiente:

¿Qué sigue?