Esegui un job Cloud Run utilizzando Workflows

Crea un job Cloud Run

Questo tutorial utilizza un job Cloud Run di esempio da GitHub. Il job legge i dati da un file di input in Cloud Storage ed esegue un'elaborazione arbitraria per ogni riga del file.

1. Recupera il codice campione clonando il repository dell'app di esempio sulla tua macchina locale:

   git clone https://github.com/GoogleCloudPlatform/jobs-demos.git

   In alternativa, puoi scaricare il sample come file ZIP ed estrarlo.

2. Passa alla directory che contiene il codice di esempio:

   cd jobs-demos/parallel-processing

3. Crea un bucket Cloud Storage per archiviare un file di input in cui è possibile scrivere e attivare un evento:

   Console

   1. Nella console Google Cloud, vai alla pagina Bucket in Cloud Storage.
      

      Vai a Bucket

   2. Fai clic su Aggiungi Crea.
   3. Nella pagina Crea un bucket, inserisci un nome per il bucket:

      input-PROJECT_ID

      Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.
   4. Mantieni gli altri valori predefiniti.
   5. Fai clic su Crea.

   gcloud

   Esegui il comando gcloud storage buckets create:

   gcloud storage buckets create gs://input-PROJECT_ID

   Se la richiesta riesce, il comando restituisce il seguente messaggio:

   Creating gs://input-PROJECT_ID/...

   Terraform

   Per creare un bucket Cloud Storage, utilizza la risorsa google_storage_bucket e modifica il file main.tf come mostrato nel seguente esempio.

   Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

   Tieni presente che in un flusso di lavoro Terraform tipico, l'intero piano viene applicato contemporaneamente. Tuttavia, ai fini di questo tutorial, puoi scegliere come target una risorsa specifica. Ad esempio:

   terraform apply -target="random_id.bucket_name_suffix"
   e
   terraform apply -target="google_storage_bucket.default"

   # Cloud Storage bucket names must be globally unique
   resource "random_id" "bucket_name_suffix" {
     byte_length = 4
   }
   
   # Create a Cloud Storage bucket
   resource "google_storage_bucket" "default" {
     name                        = "input-${data.google_project.project.name}-${random_id.bucket_name_suffix.hex}"
     location                    = "us-central1"
     storage_class               = "STANDARD"
     force_destroy               = false
     uniform_bucket_level_access = true
   }

4. Crea un repository standard Artifact Registry in cui puoi archiviare la tua immagine container:

   Console

   1. Nella console Google Cloud, vai alla pagina Repositori di Artifact Registry:

      Vai a Repository

   2. Fai clic su add Crea repository.

   3. Inserisci un nome per il repository, ad esempio my-repo. Per ogni posizione del repository in un progetto, i nomi dei repository devono essere univoci.

   4. Mantieni il formato predefinito, che dovrebbe essere Docker.

   5. Mantieni la modalità predefinita, che dovrebbe essere Standard.

   6. Per la regione, seleziona us-central1 (Iowa).

   7. Mantieni tutti gli altri valori predefiniti.

   8. Fai clic su Crea.

   gcloud

   Esegui il comando:

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

   Sostituisci REPOSITORY con un nome univoco per il repository, ad esempio my-repo. Per ogni posizione del repository in un progetto, i nomi dei repository devono essere univoci.

   Terraform

   Per creare un repository Artifact Registry, utilizza la risorsa google_artifact_registry_repository e modifica il file main.tf come mostrato nell'esempio seguente.

   Tieni presente che in un flusso di lavoro Terraform tipico, l'intero piano viene applicato contemporaneamente. Tuttavia, ai fini di questo tutorial, puoi scegliere come target una risorsa specifica. Ad esempio:

   terraform apply -target="google_artifact_registry_repository.default"

   # Create an Artifact Registry repository
   resource "google_artifact_registry_repository" "default" {
     location      = "us-central1"
     repository_id = "my-repo"
     format        = "docker"
   }

5. Crea l'immagine del contenitore utilizzando un buildpack Google Cloud predefinito:

   export SERVICE_NAME=parallel-job
   gcloud builds submit \
       --pack image=us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/${SERVICE_NAME}

   Sostituisci REPOSITORY con il nome del repository Artifact Registry.

   Il completamento della compilazione può richiedere un paio di minuti.

6. Crea un job Cloud Run che esegue il deployment dell'immagine container:

   Console

   1. Nella console Google Cloud, vai alla pagina Cloud Run:

      Vai a Cloud Run

   2. Fai clic su Crea job per visualizzare il modulo Crea job.

      1. Nel modulo, seleziona us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/parallel-job:latest come URL dell'immagine container di Artifact Registry.
      2. (Facoltativo) Per il nome del job, inserisci parallel-job.
      3. (Facoltativo) Per la regione, seleziona us-central1 (Iowa).
      4. Per il numero di attività da eseguire nel job, inserisci 10. Affinché il job riesca, tutte le attività devono avere esito positivo. Per impostazione predefinita, le attività vengono eseguite in parallelo.

   3. Espandi la sezione Container, variabili e secret, connessioni, sicurezza e mantieni tutte le impostazioni predefinite, ad eccezione delle seguenti:

      1. Fai clic sulla scheda Generale.

         1. Per il comando del contenitore, inserisci python.
         2. Per l'argomento contenitore, inserisci process.py.

      2. Fai clic sulla scheda Variabili e secret.

         1. Fai clic su Aggiungi variabile e inserisci INPUT_BUCKET per il nome e input-PROJECT_ID per il valore.
         2. Fai clic su Aggiungi variabile e inserisci INPUT_FILE per il nome e input_file.txt per il valore.

   4. Per creare il job, fai clic su Crea.

   gcloud

   1. Imposta la regione Cloud Run predefinita:

      gcloud config set run/region us-central1

   2. Crea il job Cloud Run:

      gcloud run jobs create parallel-job \
          --image us-central1-docker.pkg.dev/PROJECT_ID/REPOSITORY/parallel-job:latest \
          --command python \
          --args process.py \
          --tasks 10 \
          --set-env-vars=INPUT_BUCKET=input-PROJECT_ID,INPUT_FILE=input_file.txt

      Tieni presente che se non specifichi un tag immagine, Artifact Registry cercherà l'immagine con il tag latest predefinito.

      Per un elenco completo delle opzioni disponibili durante la creazione di un job, consulta la documentazione della riga di comando gcloud run jobs create.

      Una volta creato il job, dovresti visualizzare un messaggio che indica il completamento dell'operazione.

   Terraform

   Per creare un job Cloud Run, utilizza la risorsa google_cloud_run_v2_job e modifica il file main.tf come mostrato nell'esempio seguente.

   Tieni presente che in un flusso di lavoro Terraform tipico, l'intero piano viene applicato contemporaneamente. Tuttavia, ai fini di questo tutorial, puoi scegliere come target una risorsa specifica. Ad esempio:

   terraform apply -target="google_cloud_run_v2_job.default"

   # Create a Cloud Run job
   resource "google_cloud_run_v2_job" "default" {
     name     = "parallel-job"
     location = "us-central1"
   
     template {
       task_count = 10
       template {
         containers {
           image   = "us-central1-docker.pkg.dev/${data.google_project.project.name}/${google_artifact_registry_repository.default.repository_id}/parallel-job:latest"
           command = ["python"]
           args    = ["process.py"]
           env {
             name  = "INPUT_BUCKET"
             value = google_storage_bucket.default.name
           }
           env {
             name  = "INPUT_FILE"
             value = "input_file.txt"
           }
         }
       }
     }
   }

Esegui il deployment di un flusso di lavoro che esegue il job Cloud Run

Definisci ed esegui il deployment di un flusso di lavoro che esegua il job Cloud Run che hai appena creato. Una definizione di flusso di lavoro è composta da una serie di passaggi illustrati utilizzando la sintassi dei flussi di lavoro.

# Create a workflow
resource "google_workflows_workflow" "default" {
  name        = "cloud-run-job-workflow"
  region      = "us-central1"
  description = "Workflow that routes a Cloud Storage event and executes a Cloud Run job"

  # Note that $$ is needed for Terraform
  source_contents = <<EOF
  main:
      params: [event]
      steps:
          - init:
              assign:
                  - project_id: $${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                  - event_bucket: $${event.data.bucket}
                  - event_file: $${event.data.name}
                  - target_bucket: "${google_storage_bucket.default.name}"
                  - job_name: parallel-job
                  - job_location: us-central1
          - check_input_file:
              switch:
                  - condition: $${event_bucket == target_bucket}
                    next: run_job
                  - condition: true
                    next: end
          - run_job:
              call: googleapis.run.v1.namespaces.jobs.run
              args:
                  name: $${"namespaces/" + project_id + "/jobs/" + job_name}
                  location: $${job_location}
                  body:
                      overrides:
                          containerOverrides:
                              env:
                                  - name: INPUT_BUCKET
                                    value: $${event_bucket}
                                  - name: INPUT_FILE
                                    value: $${event_file}
              result: job_execution
          - finish:
              return: $${job_execution}
  EOF
}

Il flusso di lavoro esegue le seguenti operazioni:

1. Passaggio init: accetta un evento Cloud Storage come argomento e poi imposta le variabili necessarie.

2. Passaggio check_input_file: verifica se il bucket Cloud Storage specificato nell'evento è quello utilizzato dal job Cloud Run.

   • In caso affermativo, il flusso di lavoro passa al passaggio run_job.
   • In caso contrario, il flusso di lavoro viene interrotto e l'elaborazione viene interrotta.

3. Passaggio run_job: utilizza il metodo googleapis.run.v1.namespaces.jobs.run del connettore dell'API Cloud Run Admin per eseguire il job. I nomi del bucket Cloud Storage e dei file di dati vengono passati come variabili di override dal flusso di lavoro al job.

4. Passaggio finish: restituisce informazioni sull'esecuzione del job come risultato del flusso di lavoro.

Crea un trigger Eventarc per il flusso di lavoro

Per eseguire automaticamente il flusso di lavoro e, a sua volta, il job Cloud Run ogni volta che il file di dati di input viene aggiornato, crea un attivatore Eventarc che risponda agli eventi Cloud Storage nel bucket contenente il file di dati di input.

gcloud eventarc triggers create cloud-run-job-workflow-trigger \
    --location=us \
    --destination-workflow=cloud-run-job-workflow  \
    --destination-workflow-location=us-central1 \
    --event-filters="type=google.cloud.storage.object.v1.finalized" \
    --event-filters="bucket=input-PROJECT_ID" \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

# Create an Eventarc trigger that routes Cloud Storage events to Workflows
resource "google_eventarc_trigger" "default" {
  name     = "cloud-run-job-trigger"
  location = google_workflows_workflow.default.region

  # Capture objects changed in the bucket
  matching_criteria {
    attribute = "type"
    value     = "google.cloud.storage.object.v1.finalized"
  }
  matching_criteria {
    attribute = "bucket"
    value     = google_storage_bucket.default.name
  }

  # Send events to Workflows
  destination {
    workflow = google_workflows_workflow.default.id
  }

  service_account = google_service_account.workflows.email

}

Ogni volta che un file viene caricato o sovrascritto nel bucket Cloud Storage contenente il file di dati di input, il flusso di lavoro viene eseguito con l'evento Cloud Storage corrispondente come argomento.

Attiva il flusso di lavoro

Testa il sistema end-to-end aggiornando il file di dati di input in Cloud Storage.

1. Genera nuovi dati per il file di input e caricali in Cloud Storage nella posizione prevista dal job Cloud Run:

   base64 /dev/urandom | head -c 100000 >input_file.txt
   gcloud storage cp input_file.txt gs://input-PROJECT_ID/input_file.txt

   Se hai creato un bucket Cloud Storage utilizzando Terraform, puoi recuperare il nome del bucket eseguendo il seguente comando:

   gcloud storage buckets list gs://input*

   L'esecuzione del job Cloud Run può richiedere alcuni minuti.

2. Verifica che il job Cloud Run sia stato eseguito come previsto visualizzando le esecuzioni del job:

   gcloud config set run/region us-central1
   gcloud run jobs executions list --job=parallel-job

   Nell'output dovresti vedere un messaggio che indica che l'esecuzione del job è andata a buon fine e che le attività 10/10 sono state completate.

Scopri di più su come attivare un flusso di lavoro con eventi o messaggi Pub/Sub.