Esta página se ha traducido con Cloud Translation API.

Ejecutar un trabajo de Batch con Workflows

Batch es un servicio totalmente gestionado que te permite programar, poner en cola y ejecutar cargas de trabajo de procesamiento por lotes en instancias de máquina virtual de Compute Engine. Batch aprovisiona recursos y gestiona 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 el orden que definas mediante la sintaxis de Workflows.

En este tutorial, usarás el conector de Workflows para Batch para programar y ejecutar un trabajo de Batch que ejecute seis tareas en paralelo en dos VMs de Compute Engine. Si usas tanto Batch como Workflows, podrás combinar las ventajas que ofrecen y aprovisionar y orquestar todo el proceso de forma eficiente.

Objetivos

En este tutorial, aprenderás a hacer lo siguiente:

Crea un repositorio de Artifact Registry para una imagen de contenedor Docker.
Obtén el código de la carga de trabajo de procesamiento por lotes de GitHub: un programa de ejemplo que genera números primos en lotes de 10.000.
Compila la imagen de Docker de la carga de trabajo.
Despliega y ejecuta un flujo de trabajo que haga lo siguiente:
1. Crea un segmento de Cloud Storage para almacenar los resultados del generador de números primos.
2. Programa y ejecuta una tarea de Batch que ejecuta el contenedor Docker como seis tareas en paralelo en dos máquinas virtuales de Compute Engine.
3. Elimina la tarea de Batch de forma opcional una vez que se haya completado.
Confirma que los resultados son los esperados y que los lotes de números primos generados se almacenan en Cloud Storage.

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

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Antes de empezar

Es posible que las restricciones de seguridad definidas por tu organización te impidan completar los siguientes pasos. Para obtener información sobre cómo solucionar problemas, consulta el artículo Desarrollar aplicaciones en un entorno limitado Google Cloud .

Consola

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

Nota: Si no tienes la intención de guardar los recursos que obtendrás a lo largo de este procedimiento, crea un proyecto en lugar de seleccionar uno disponible. Después de completar estos pasos, podrás eliminar el proyecto y, con él, todos los recursos asociados.

Ir al selector de proyectos
Comprueba que la facturación esté habilitada en tu Google Cloud proyecto. Consulta cómo comprobar si la facturación está habilitada en un proyecto.
Habilita las APIs Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions y Workflows.

Habilita las APIs
Crea una cuenta de servicio para que tu flujo de trabajo la use para autenticarse con otros servicios de Google Cloud y concédele los roles adecuados:
1. En la Google Cloud consola, ve a la página Crear cuenta de servicio.
  
  Ir a Crear cuenta de servicio
2. Selecciona el proyecto.
3. En el campo Nombre de cuenta de servicio, escribe un nombre. La Google Cloud consola rellena el campo ID de cuenta de servicio con este nombre.
  
  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 Selecciona un rol, filtra los siguientes roles para asignarlos a la cuenta de servicio gestionada por el usuario que has creado en el paso anterior:
  - Editor de tareas por lotes: para editar tareas por lotes.
  - Editor de registros: para escribir registros.
  - Administrador de almacenamiento: para controlar los recursos de Cloud Storage.
  Para añadir más roles, haz clic en Añadir otro rol y añade cada rol adicional.
  
  Nota: El campo Rol determina a qué recursos puede acceder tu cuenta de servicio en tu proyecto. Puedes revocar estos roles o conceder roles adicionales más adelante. En entornos de producción, no concedas los roles de propietario, editor o lector. En su lugar, concede un rol predefinido o un rol personalizado que se ajuste a tus necesidades.
6. Haz clic en Continuar.
7. Para terminar de crear la cuenta, haga clic en Hecho.
Asigna el rol Usuario de cuenta de servicio de IAM en la cuenta de servicio predeterminada a la cuenta de servicio gestionada por el usuario que has creado en el paso anterior. Después de habilitar la API 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 se suele asignar a través del rol roles/iam.serviceAccountUser.

Precaución: Si asignas el rol Usuario de cuenta de servicio se concede indirectamente al usuario el rol asociado a la cuenta de servicio predeterminada. Por ejemplo, si la cuenta de servicio predeterminada tiene el rol 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 de acuerdo con el principio de mínimos accesos. Para obtener más información, consulta Inhabilitar las concesiones automáticas de roles a las cuentas de servicio predeterminadas
.
1. En la página Cuentas de servicio, haz clic en la dirección de correo 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 Conceder acceso.
4. Para añadir un nuevo principal, introduce la dirección de correo 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.
Comprueba que la facturación esté habilitada en tu Google Cloud proyecto. Consulta cómo comprobar si la facturación está habilitada en un proyecto.

Habilita las APIs 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 para autenticarse con otros servicios de Google Cloud y concédele los roles adecuados.
1. Crea la cuenta de servicio:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Sustituye SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio.
2. Asigna roles a la cuenta de servicio gestionada por el usuario que has creado en el paso anterior. Ejecuta el siguiente comando una vez por cada uno de los siguientes roles de gestión de identidades y accesos:
  - 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
```
  Haz los cambios siguientes:
  - PROJECT_ID: el ID del proyecto en el que has creado la cuenta de servicio
  - ROLE: el rol que se va a conceder
  Nota: La marca --role afecta a los recursos a los que puede acceder tu cuenta de servicio en tu proyecto. Puedes revocar estos roles o conceder roles adicionales más adelante. En entornos de producción, no concedas los roles de propietario, editor o lector. En su lugar, concede un rol predefinido o un rol personalizado que se ajuste a tus necesidades.
Asigna el rol Usuario de cuenta de servicio de IAM en la cuenta de servicio predeterminada a la cuenta de servicio gestionada por el usuario que has creado en el paso anterior. Después de habilitar la API 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 se suele asignar a través del rol roles/iam.serviceAccountUser.

Precaución: Si asignas el rol Usuario de cuenta de servicio se concede indirectamente al usuario el rol asociado a la cuenta de servicio predeterminada. Por ejemplo, si la cuenta de servicio predeterminada tiene el rol 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 de acuerdo con el principio de mínimos accesos. Para obtener más información, consulta Inhabilitar las concesiones automáticas de roles 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
```

Crear un repositorio de Artifact Registry

Crea un repositorio para almacenar tu imagen de contenedor Docker.

Consola

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

Ir a Repositorios
Haz clic en Crear repositorio.
Introduce containers como 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

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

Obtener los códigos de ejemplo

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

Clona el repositorio de aplicaciones de muestra en la máquina local:
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
También puedes descargar las muestras en el archivo main.zip y extraerlo.
Accede 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.

Compilar la imagen Docker con Cloud Build

El archivo Dockerfile contiene la información necesaria para crear 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/

Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

Cuando se haya completado la compilación, debería 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, has creado una imagen Docker llamada primegen-service y has enviado la imagen a un repositorio de Artifact Registry llamado containers.

Desplegar un flujo de trabajo que programe y ejecute una tarea de Batch

El siguiente flujo de trabajo programa y ejecuta una tarea de Batch que ejecuta un contenedor Docker como seis tareas en paralelo en dos máquinas virtuales de Compute Engine. El resultado es la generación de seis lotes de números primos, almacenados en un segmento de Cloud Storage.

Consola

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

Ve a Workflows
Haz clic en Crear.
Escribe un nombre para el nuevo flujo de trabajo, como batch-workflow.
En la lista Región, selecciona us-central1.
Selecciona la cuenta de servicio que has creado anteriormente.
Haz clic en Siguiente.

En el editor del flujo de trabajo, introduce 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 Desplegar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch batch-workflow.JSON_OR_YAML
```
Sustituye JSON_OR_YAML por yaml o json en función del 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 desplegar el flujo de trabajo, introduce 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

Sustituye SERVICE_ACCOUNT_NAME por el nombre de la cuenta de servicio que has creado anteriormente.

Ejecutar el flujo de trabajo

Al ejecutar un flujo de trabajo, se ejecuta la definición del flujo de trabajo actual asociada al flujo de trabajo.

Consola

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

Ve a Workflows
En la página Workflows (Flujos de trabajo), haz clic en el flujo de trabajo batch-workflow (flujo de trabajo por lotes) para ir a su página de detalles.
En la página Detalles del flujo de trabajo, haz clic en Ejecutar.
Vuelve a hacer clic en Ejecutar.

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

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

Los resultados deberían ser similares a los siguientes:
```
{
  "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 se produce un error IAM permission denied for service account en el paso createBucket, es probable que se deba a un retraso en la propagación. Espera uno o dos minutos y vuelve a ejecutar el flujo de trabajo.
Puedes consultar 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

Mostrar los objetos del segmento de salida

Para confirmar que los resultados son los esperados, enumera los objetos del segmento de salida de Cloud Storage.

Consola

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

Ir a Contenedores
En la lista de segmentos, haga clic en el nombre del segmento cuyo contenido quiera ver.

Los resultados deberían ser similares a los siguientes, con seis archivos en total y cada uno con 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 del segmento de salida:
```
gcloud storage ls
```
El resultado debería ser similar al siguiente:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Lista los objetos del segmento de salida:

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

Sustituye TIMESTAMP por la marca de tiempo devuelta por el comando anterior.

La salida debería ser similar a la siguiente, con seis archivos en total, y cada uno de ellos con 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

Limpieza

Si has creado un proyecto para este tutorial, elimínalo. Si has usado un proyecto y quieres conservarlo sin los cambios que se han añadido en este tutorial, elimina los recursos creados para el tutorial.

Eliminar el proyecto

La forma más fácil de evitar que te cobren es eliminar el proyecto que has creado para el tutorial.

Para ello, sigue las instrucciones que aparecen a continuación:

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

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.

Eliminar los recursos creados en este tutorial

Elimina el trabajo por lotes:

Primero, recupera el nombre del trabajo:
```
gcloud batch jobs list --location=us-central1
```
La salida debería ser similar a la siguiente:
```
NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
STATE: SUCCEEDED
```
Donde job-primegen-TIMESTAMP es el nombre del trabajo por lotes.

Elimina el trabajo:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

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

Elimina 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 eliminar un segmento de Cloud Storage, consulta Eliminar segmentos.

Ejecutar un trabajo de Batch con Workflows Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Objetivos

Costes

Antes de empezar

Consola

gcloud

Crear un repositorio de Artifact Registry

Consola

gcloud

Obtener los códigos de ejemplo

Compilar la imagen Docker con Cloud Build

Desplegar un flujo de trabajo que programe y ejecute una tarea de Batch

Consola

YAML

JSON

gcloud

YAML

JSON

Ejecutar el flujo de trabajo

Consola

gcloud

Mostrar los objetos del segmento de salida

Consola

gcloud

Limpieza

Eliminar el proyecto

Eliminar los recursos creados en este tutorial

Siguientes pasos

Ejecutar un trabajo de Batch con Workflows