Se usó la API de Cloud Translation para traducir esta página.

Ejecuta un trabajo por lotes con Workflows

Batch es un servicio completamente administrado que te permite programar, poner en cola y ejecutar cargas de trabajo de procesamiento por lotes en instancias de máquina virtual (VM) de Compute Engine. La modalidad por lotes aprovisiona recursos y administra la capacidad en tu nombre, lo que permite que tus cargas de trabajo por lotes se ejecuten a gran escala.

Workflows te permite ejecutar los servicios que necesitas en un orden que definas con la sintaxis de Workflows.

En este instructivo, usarás el conector de flujos de trabajo para Batch para programar y ejecutar un trabajo de Batch que ejecute seis tareas en paralelo en dos VMs de Compute Engine. El uso de Batch y Workflows te permite combinar las ventajas que ofrecen y aprovisionar y orquestar todo el proceso de manera eficiente.

Objetivos

En este instructivo, realizarás las siguientes acciones:

Crea un repositorio de Artifact Registry para una imagen de contenedor de Docker.
Obtén el código de la carga de trabajo de procesamiento por lotes de GitHub: un programa de muestra que genera números primos en lotes de 10,000.
Compila la imagen de Docker para la carga de trabajo.
Implementa y ejecuta un flujo de trabajo que haga lo siguiente:
1. Crea un bucket de Cloud Storage para almacenar los resultados del generador de números primos.
2. Programa y ejecuta un trabajo por lotes que ejecuta el contenedor de Docker como seis tareas en paralelo en dos VMs de Compute Engine.
3. De manera opcional, borra el trabajo por lotes después de que se complete.
Confirma que los resultados sean los esperados y que los lotes de números primos generados se almacenen en Cloud Storage.

Puedes ejecutar la mayoría de los siguientes comandos en la consola de Google Cloud o todos los comandos con Google Cloud CLI en la terminal o en Cloud Shell.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

Es posible que las restricciones de seguridad que define tu organización no te permitan completar los siguientes pasos. Para obtener información sobre la solución de problemas, consulta Desarrolla aplicaciones en un entorno de Google Cloud restringido.

Console

En la página del selector de proyectos de la consola de Google Cloud, elige o crea un proyecto de Google Cloud.

Nota: Si no planeas conservar los recursos creados durante este procedimiento, crea un proyecto en lugar de elegir un proyecto existente. Cuando termines, puedes borrar el proyecto si quitas todos los recursos asociados con él.

Ir al selector de proyectos
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.
Habilita las APIs de Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions y Workflows.

Habilita las API
Crea una cuenta de servicio para que tu flujo de trabajo la use en la autenticación con otros servicios de Google Cloud y bríndale los roles adecuados:
1. En la consola de Google Cloud, ve a la página Crear cuenta de servicio.
  
  Ve a Crear cuenta de servicio
2. Elige tu proyecto.
3. Escribe un nombre en el campo Nombre de cuenta de servicio. La consola de Google Cloud completa el campo ID de la cuenta de servicio en función de este nombre.
  
  Opcional: en el campo Descripción de la cuenta de servicio, escribe una descripción. Por ejemplo, Service account for tutorial.
4. Haz clic en Crear y continuar.
5. En la lista Seleccionar un rol, filtra por los siguientes roles para otorgarlos a la cuenta de servicio administrada por el usuario que creaste en el paso anterior:
  - Editor de trabajos por lotes: Para editar trabajos por lotes.
  - Escritor de registros: Para escribir registros.
  - Administrador de almacenamiento: Para controlar los recursos de Cloud Storage.
  Para obtener roles adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
  
  Nota: El campo Función afecta a qué recursos puede acceder tu cuenta de servicio en el proyecto. Puedes revocar estos roles o asignar otros más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o un rol personalizado que satisfaga tus necesidades.
6. Haga clic en Continuar.
7. Para terminar de crear la cuenta, haz clic en Listo.
Otorga el rol de usuario de cuenta de servicio de IAM en la cuenta de servicio predeterminada a la cuenta de servicio administrada por el usuario que se creó en el paso anterior. Después de habilitar la API de Compute Engine, la cuenta de servicio predeterminada es la cuenta de servicio predeterminada de Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), y el permiso suele asignarse a través del rol roles/iam.serviceAccountUser.

Precaución: Si asignas el rol de usuario de la cuenta de servicio, se otorga indirectamente al usuario el rol asociado con la cuenta de servicio predeterminada. Por ejemplo, si la cuenta de servicio predeterminada tiene el rol de Editor, el usuario puede "actuar como" Editor. Para minimizar el impacto de estas asignaciones de roles, te recomendamos que configures la cuenta de servicio predeterminada según el principio de privilegio mínimo. Para obtener más información, consulta Inhabilita las asignaciones de roles automáticas a las cuentas de servicio predeterminadas.
1. En la página Cuentas de servicio, haz clic en la dirección de correo electrónico de la cuenta de servicio predeterminada (PROJECT_NUMBER-compute@developer.gserviceaccount.com).
2. Haz clic en la pestaña Permisos.
3. Haz clic en el botón Otorgar acceso.
4. Para agregar un principal nuevo, ingresa la dirección de correo electrónico de tu cuenta de servicio (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com).
5. En la lista Seleccionar un rol, selecciona el rol Cuentas de servicio > Usuario de cuenta de servicio.
6. Haz clic en Guardar.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

Habilita las APIs de Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions y Workflows.

gcloud services enable artifactregistry.googleapis.com \
  batch.googleapis.com \
  cloudbuild.googleapis.com \
  compute.googleapis.com \
  workflowexecutions.googleapis.com \
  workflows.googleapis.com

Crea una cuenta de servicio para que tu flujo de trabajo la use en la autenticación con otros servicios de Google Cloud y bríndale los roles adecuados.
1. Cree la cuenta de servicio:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Reemplaza SERVICE_ACCOUNT_NAME por un nombre para la cuenta de servicio.
2. Otorga roles a la cuenta de servicio administrada por el usuario que creaste en el paso anterior. Ejecuta el siguiente comando una vez para cada uno de los siguientes roles de IAM:
  - roles/batch.jobsEditor: Para editar trabajos por lotes.
  - roles/logging.logWriter: Para escribir registros.
  - roles/storage.admin: Para controlar los recursos de Cloud Storage.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=ROLE
```
  Reemplaza lo siguiente:
  - PROJECT_ID: El ID del proyecto en el que creaste la cuenta de servicio
  - ROLE: el rol a otorgar
  Nota: La marca --role afecta a qué recursos puede acceder tu cuenta de servicio en el proyecto. Puedes revocar estos roles o asignar otros más adelante. En entornos de producción, no otorgues los roles de propietario, editor o visualizador. En su lugar, otorga un rol predefinido o un rol personalizado que satisfaga tus necesidades.
Otorga el rol de usuario de cuenta de servicio de IAM en la cuenta de servicio predeterminada a la cuenta de servicio administrada por el usuario que creaste en el paso anterior. Después de habilitar la API de Compute Engine, la cuenta de servicio predeterminada es la cuenta de servicio predeterminada de Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com), y el permiso suele asignarse a través del rol roles/iam.serviceAccountUser.

Precaución: Si asignas el rol de usuario de la cuenta de servicio, se otorga indirectamente al usuario el rol asociado con la cuenta de servicio predeterminada. Por ejemplo, si la cuenta de servicio predeterminada tiene el rol de Editor, el usuario puede "actuar como" Editor. Para minimizar el impacto de estas asignaciones de roles, te recomendamos que configures la cuenta de servicio predeterminada según el principio de privilegio mínimo. Para obtener más información, consulta Inhabilita las asignaciones de roles automáticas a las cuentas de servicio predeterminadas.
```
PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
gcloud iam service-accounts add-iam-policy-binding \
  $PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountUser
```

Crea un repositorio de Artifact Registry

Crea un repositorio para almacenar tu imagen de contenedor de Docker.

Console

En la consola de Google Cloud, ve a la página Repositorios.

Ir a Repositorios
Haz clic en Crear repositorio.
Ingresa containers como el nombre del repositorio.
En Formato, elige Docker.
En Tipo de ubicación, elige Región.
En la lista Región, selecciona us-central1.
Haz clic en Crear.

gcloud

Ejecuta el siguiente comando:

  gcloud artifacts repositories create containers \
    --repository-format=docker \
    --location=us-central1

Creaste un repositorio de Artifact Registry llamado containers en la región us-central1. Para obtener más información sobre las regiones compatibles, consulta Ubicaciones de Artifact Registry.

Obtén las muestras de código

Google Cloud almacena el código fuente de la aplicación de este instructivo en GitHub. Puedes clonar ese repositorio o descargar las muestras.

Clona el repositorio de la app de muestra en tu máquina local:
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
Como alternativa, puedes descargar los samples del archivo main.zip y extraerlos.
Dirígete al directorio que contiene el código de muestra:
```
cd batch-samples/primegen
```

Ahora tienes el código fuente de la aplicación en tu entorno de desarrollo.

Compila la imagen de Docker con Cloud Build

El Dockerfile contiene la información necesaria para compilar una imagen de Docker con Cloud Build. Ejecuta el siguiente comando para compilarlo:

gcloud builds submit \
  -t us-central1-docker.pkg.dev/PROJECT_ID/containers/primegen-service:v1 PrimeGenService/

Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

Cuando se complete la compilación, deberías ver un resultado similar al siguiente:

DONE
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID: a54818cc-5d14-467b-bfda-5fc9590af68c
CREATE_TIME: 2022-07-29T01:48:50+00:00
DURATION: 48S
SOURCE: gs://project-name_cloudbuild/source/1659059329.705219-17aee3a424a94679937a7200fab15bcf.tgz
IMAGES: us-central1-docker.pkg.dev/project-name/containers/primegen-service:v1
STATUS: SUCCESS

Con un Dockerfile, compilaste una imagen de Docker llamada primegen-service y la enviaste a un repositorio de Artifact Registry llamado containers.

Implementa un flujo de trabajo que programe y ejecute un trabajo de Batch

El siguiente flujo de trabajo programa y ejecuta un trabajo por lotes que ejecuta un contenedor de Docker como seis tareas en paralelo en dos VMs de Compute Engine. El resultado es la generación de seis lotes de números primos, almacenados en un bucket de Cloud Storage.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo, como batch-workflow.
En la lista Región, selecciona us-central1.
Selecciona la Cuenta de servicio que creaste antes.
Haz clic en Siguiente.

En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch batch-workflow.JSON_OR_YAML
```
Reemplaza JSON_OR_YAML por yaml o json, según el formato de tu flujo de trabajo.

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Para implementar el flujo de trabajo, ingresa el siguiente comando:

gcloud workflows deploy batch-workflow \
  --source=batch-workflow.yaml \
  --location=us-central1 \
  --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Reemplaza SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio que creaste anteriormente.

Ejecuta el flujo de trabajo

Ejecuta la definición actual del flujo de trabajo asociada con el flujo de trabajo.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
En la página Flujos de trabajo, haz clic en el flujo de trabajo batch-workflow para ir a su página de detalles.
En la página Detalles del flujo de trabajo, haz clic en Ejecutar.
Haz clic de nuevo en Ejecutar.

La ejecución del flujo de trabajo debería tardar unos minutos.

Nota: Si encuentras un error IAM permission denied for service account en el paso createBucket, es probable que se deba a una demora de propagación. Espera uno o dos minutos y vuelve a intentar ejecutar el flujo de trabajo.
Consulta los resultados del flujo de trabajo en el panel Resultado.

Los resultados debería ser similar al siguiente:
```
{
  "bucket": "project-name-job-primegen-TIMESTAMP",
  "jobId": "job-primegen-TIMESTAMP"
}
```

gcloud

Ejecuta el flujo de trabajo:
```
gcloud workflows run batch-workflow \
  --location=us-central1
```
La ejecución del flujo de trabajo debería tardar unos minutos.

Nota: Si encuentras un error IAM permission denied for service account en el paso createBucket, es probable que se deba a una demora de propagación. Espera uno o dos minutos y vuelve a intentar ejecutar el flujo de trabajo.
Puedes verificar el estado de una ejecución de larga duración.

Para obtener el estado de la última ejecución completada, ejecuta el siguiente comando:

gcloud workflows executions describe-last

Los resultados deberían ser similares a los siguientes:

name: projects/PROJECT_NUMBER/locations/us-central1/workflows/batch-workflow/executions/EXECUTION_ID
result: '{"bucket":"project-name-job-primegen-TIMESTAMP","jobId":"job-primegen-TIMESTAMP"}'
startTime: '2022-07-29T16:08:39.725306421Z'
state: SUCCEEDED
status:
  currentSteps:
  - routine: main
    step: returnResult
workflowRevisionId: 000001-9ba

Enumera los objetos del bucket de salida

Para confirmar que los resultados sean los esperados, puedes enumerar los objetos en el bucket de salida de Cloud Storage.

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
En la lista de bucket s, haz clic en el nombre del bucket que posee el contenido que deseas ver.

Los resultados deberían ser similares al siguiente, con seis archivos en total, cada uno con una lista de un lote de 10,000 números primos:
```
primes-1-10000.txt
primes-10001-20000.txt
primes-20001-30000.txt
primes-30001-40000.txt
primes-40001-50000.txt
primes-50001-60000.txt
```

gcloud

Recupera el nombre de tu bucket de salida:
```
gcloud storage ls
```
El resultado es similar a este:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Haz una lista de los objetos de tu bucket de salida:

gcloud storage ls gs://PROJECT_ID-job-primegen-TIMESTAMP/** --recursive

Reemplaza TIMESTAMP por la marca de tiempo que mostró el comando anterior.

El resultado debería ser similar al siguiente, con seis archivos en total, cada uno con una lista de un lote de 10,000 números primos:

gs://project-name-job-primegen-TIMESTAMP/primes-1-10000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-10001-20000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-20001-30000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-30001-40000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-40001-50000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-50001-60000.txt

Realiza una limpieza

Si creaste un proyecto nuevo para este instructivo, bórralo. Si usaste un proyecto existente y deseas conservarlo sin los cambios que se agregaron en este instructivo, borra los recursos creados para el instructivo.

Borra el proyecto

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, sigue estos pasos:

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Borra los recursos creados en este instructivo

Borra el trabajo por lotes:

Primero, recupera el nombre del trabajo:
```
gcloud batch jobs list --location=us-central1
```
El resultado debería ser similar al siguiente ejemplo:
```
NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
STATE: SUCCEEDED
```
En el que job-primegen-TIMESTAMP es el nombre del trabajo de lotes.

Borra el trabajo:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

Borra el flujo de trabajo:
```
gcloud workflows delete WORKFLOW_NAME
```

Borra el repositorio de contenedores:

gcloud artifacts repositories delete REPOSITORY_NAME --location=us-central1

Cloud Build usa Cloud Storage para almacenar recursos de compilación. Para borrar un bucket de Cloud Storage, consulta Borra buckets.

Ejecuta un trabajo por lotes con Workflows

Objetivos

Costos

Antes de comenzar

Console

gcloud

Crea un repositorio de Artifact Registry

Console

gcloud

Obtén las muestras de código

Compila la imagen de Docker con Cloud Build

Implementa un flujo de trabajo que programe y ejecute un trabajo de Batch

Console

YAML

JSON

gcloud

YAML

JSON

Ejecuta el flujo de trabajo

Console

gcloud

Enumera los objetos del bucket de salida

Console

gcloud

Realiza una limpieza

Borra el proyecto

Borra los recursos creados en este instructivo

¿Qué sigue?