Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Esegui un job batch utilizzando Workflows

Batch è un servizio completamente gestito che consente di pianificare, inserire in coda ed eseguire carichi di lavoro di elaborazione batch su istanze di macchine virtuali (VM) Compute Engine. Batch esegue il provisioning delle risorse e gestisce la capacità per tuo conto, consentendo l'esecuzione dei carichi di lavoro batch su larga scala.

Workflows ti consente di eseguire i servizi di cui hai bisogno in un ordine definito da te e descritto utilizzando la sintassi di Workflows.

In questo tutorial utilizzerai il connettore Workflows per Batch per pianificare ed eseguire un job Batch che esegue sei attività in parallelo su due VM Compute Engine. L'utilizzo di Batch e Workflows consente di combinare i vantaggi che offrono ed eseguire il provisioning e l'orchestrazione dell'intero processo in modo efficiente.

Obiettivi

In questo tutorial, imparerai a:

Crea un repository Artifact Registry per un'immagine container Docker.
Recupera il codice per il carico di lavoro di elaborazione batch da GitHub: un programma di esempio che genera numeri primi in batch di 10.000.
Crea l'immagine Docker per il workload.
Esegui il deployment ed esegui un workflow che:
1. Crea un bucket Cloud Storage per archiviare i risultati del generatore di numeri primi.
2. Pianifica ed esegue un job batch che esegue il container Docker come sei attività in parallelo su due VM Compute Engine.
3. Facoltativamente, elimina il job batch dopo il completamento.
Verifica che i risultati siano quelli previsti e che i batch di numeri primi generati siano archiviati in Cloud Storage.

Puoi eseguire la maggior parte dei comandi seguenti nella console Google Cloud oppure eseguire tutti i comandi utilizzando Google Cloud CLI nel terminale o in Cloud Shell.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

I vincoli di sicurezza definiti dalla tua organizzazione potrebbero impedirti di completare i passaggi seguenti. Per informazioni sulla risoluzione dei problemi, vedi Sviluppare applicazioni in un ambiente Google Cloud vincolato.

Console

Nella console Google Cloud , nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud .

Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno già esistente. Una volta completata questa procedura, puoi eliminare il progetto e tutte le relative risorse.

Vai al selettore di progetti
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud . Scopri come verificare se la fatturazione è abilitata per un progetto.
Abilita le API Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions e Workflows.

Abilita le API
Crea un account di servizio che il workflow possa utilizzare per l'autenticazione con altri servizi Google Cloud e concedigli i ruoli appropriati:
1. Nella console Google Cloud , vai alla pagina Crea service account.
  
  Vai a Crea service account
2. Seleziona il progetto.
3. Nel campo Nome service account, inserisci un nome. La console Google Cloud compila il campo ID service account in base a questo nome.
  
  Nel campo Descrizione service account, inserisci una descrizione. Ad esempio, Service account for tutorial.
4. Fai clic su Crea e continua.
5. Nell'elenco Seleziona un ruolo, filtra i seguenti ruoli da concedere al account di servizio gestito dall'utente che hai creato nel passaggio precedente:
  - Editor di job batch: per modificare i job batch.
  - Logs Writer: per scrivere i log.
  - Amministratore spazio di archiviazione: per controllare le risorse Cloud Storage.
  Per i ruoli aggiuntivi, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo successivo.
  
  Nota: il campo Ruolo influisce sulle risorse a cui il account di servizio può accedere nel tuo progetto. Puoi revocare questi ruoli o concedere ruoli aggiuntivi in un secondo momento. In ambienti di produzione, non concedere i ruoli Proprietario, Editor o Visualizzatore. Concedi invece un ruolo predefinito o un ruolo personalizzato che soddisfi le tue esigenze.
6. Fai clic su Continua.
7. Per completare la creazione dell'account, fai clic su Fine.
Concedi il ruolo Utente service account IAM al account di servizio predefinito al account di servizio gestito dall'utente creato nel passaggio precedente. Dopo aver abilitato l'API Compute Engine, il account di servizio predefinito è il account di servizio Compute Engine predefinito (PROJECT_NUMBER-compute@), e l'autorizzazione viene in genere assegnata tramite il ruolo roles/iam.serviceAccountUser.

Attenzione: l'assegnazione del ruolo utente dell'account di servizio concede indirettamente all'utente il ruolo associato al service account predefinito. Ad esempio, se l'account di servizio predefinito ha il ruolo Editor, l'utente può "agire come" un editor. Per ridurre al minimo l'impatto di queste assegnazioni di ruolo, ti consigliamo di configurare il account di servizio predefinito in base al principio del privilegio minimo. Per saperne di più, consulta Disabilita le concessioni automatiche dei ruoli ai service account predefiniti.
1. Nella pagina Service account, fai clic sull'indirizzo email del account di servizio predefinito (PROJECT_NUMBER-compute@).
2. Fai clic sulla scheda Autorizzazioni.
3. Fai clic sul pulsante Concedi l'accesso.
4. Per aggiungere una nuova entità, inserisci l'indirizzo email del tuo account di servizio (SERVICE_ACCOUNT_NAME@PROJECT_ID.).
5. Nell'elenco Seleziona un ruolo, seleziona il ruolo Service Accounts > Service Account User.
6. Fai clic su Salva.

gcloud

Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud . Scopri come verificare se la fatturazione è abilitata per un progetto.

Abilita le API Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions e Workflows.

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

Crea un account di servizio che il tuo workflow possa utilizzare per l'autenticazione con altri servizi Google Cloud e concedigli i ruoli appropriati.
1. Crea l'account di servizio:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Sostituisci SERVICE_ACCOUNT_NAME con un nome per il account di servizio.
2. Concedi ruoli al account di servizio gestito dall'utente che hai creato nel passaggio precedente. Esegui il seguente comando una volta per ciascuno dei seguenti ruoli IAM:
  - roles/batch.jobsEditor: per modificare i job batch.
  - roles/logging.logWriter: per scrivere i log.
  - roles/storage.admin: per controllare le risorse Cloud Storage.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID. \
  --role=ROLE
```
  Sostituisci quanto segue:
  - PROJECT_ID: l'ID progetto in cui hai creato il account di servizio
  - ROLE: il ruolo da concedere
  Nota: il flag --role influisce sulle risorse a cui il tuo account di servizio può accedere nel progetto. Puoi revocare questi ruoli o concedere ruoli aggiuntivi in un secondo momento. In ambienti di produzione, non concedere i ruoli Proprietario, Editor o Visualizzatore. Concedi invece un ruolo predefinito o un ruolo personalizzato che soddisfi le tue esigenze.
Concedi il ruolo Utente account di servizio IAM nell'account di servizio predefinito all'account di servizio gestito dall'utente che hai creato nel passaggio precedente. Dopo aver abilitato l'API Compute Engine, il service account predefinito è il account di servizio predefinito di Compute Engine (PROJECT_NUMBER-compute@) e l'autorizzazione viene in genere assegnata tramite il ruolo roles/iam.serviceAccountUser.

Attenzione: l'assegnazione del ruolo utente dell'account di servizio concede indirettamente all'utente il ruolo associato al service account predefinito. Ad esempio, se l'account di servizio predefinito ha il ruolo Editor, l'utente può "agire come" un editor. Per ridurre al minimo l'impatto di queste assegnazioni di ruolo, ti consigliamo di configurare il account di servizio predefinito in base al principio del privilegio minimo. Per saperne di più, consulta Disabilita la concessione automatica dei ruoli ai service account predefiniti.
```
PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
gcloud iam service-accounts add-iam-policy-binding \
  $PROJECT_NUMBER-compute@ \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID. \
  --role=roles/iam.serviceAccountUser
```

Crea un repository Artifact Registry

Crea un repository per archiviare l'immagine container Docker.

Console

Nella console Google Cloud , vai alla pagina Repository.

Vai a Repository
Fai clic su Crea repository.
Inserisci containers come nome del repository.
In Formato, scegli Docker.
Per Tipo di località, scegli Regione.
Nell'elenco Regione, seleziona us-central1.
Fai clic su Crea.

gcloud

Esegui questo comando:

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

Hai creato un repository Artifact Registry denominato containers nella regione us-central1. Per saperne di più sulle regioni supportate, consulta Località di Artifact Registry.

Scarica gli esempi di codice

Google Cloud memorizza il codice sorgente dell'applicazione per questo tutorial in GitHub. Puoi clonare il repository o scaricare gli esempi.

Clona il repository dell'app di esempio sulla tua macchina locale:
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
In alternativa, puoi scaricare gli esempi nel file main.zip ed estrarli.
Passa alla directory che contiene il codice campione:
```
cd batch-samples/primegen
```

Ora hai il codice sorgente dell'applicazione nel tuo ambiente di sviluppo.

Crea l'immagine Docker utilizzando Cloud Build

Il Dockerfile contiene le informazioni necessarie per creare un'immagine Docker utilizzando Cloud Build. Esegui questo comando per crearlo:

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

Sostituisci PROJECT_ID con il tuo ID progetto Google Cloud.

Al termine della build, dovresti vedere un output simile al seguente:

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

Utilizzando un Dockerfile, hai creato un'immagine Docker denominata primegen-service e ne hai eseguito il push in un repository Artifact Registry denominato containers.

Esegui il deployment di un flusso di lavoro che pianifica ed esegue un job batch

Il seguente flusso di lavoro pianifica ed esegue un job Batch che esegue un container Docker come sei attività in parallelo su due VM Compute Engine. Il risultato è la generazione di sei batch di numeri primi, archiviati in un bucket Cloud Storage.

Console

Nella Google Cloud console, vai alla pagina Workflows.

Vai a Workflow
Fai clic su Crea.
Inserisci un nome per il nuovo flusso di lavoro, ad esempio batch-workflow.
Nell'elenco Regione, seleziona us-central1.
Seleziona il service account che hai creato in precedenza.
Fai clic su Avanti.

Nell'editor del flusso di lavoro, inserisci la seguente definizione per il tuo flusso di lavoro:

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

Fai clic su Esegui il deployment.

gcloud

Crea un file di codice sorgente per il tuo workflow:
```
touch batch-workflow.JSON_OR_YAML
```
Sostituisci JSON_OR_YAML con yaml o json a seconda del formato del workflow.

In un editor di testo, copia il seguente workflow nel file del codice sorgente:

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

Esegui il deployment del flusso di lavoro inserendo questo comando:

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

Sostituisci SERVICE_ACCOUNT_NAME con il nome del account di servizio che hai creato in precedenza.

Esegui il flusso di lavoro

L'esecuzione di un workflow esegue la definizione attuale del workflow associata al workflow.

Console

Nella Google Cloud console, vai alla pagina Workflows.

Vai a Workflow
Nella pagina Flussi di lavoro, fai clic sul workflow batch-workflow per accedere alla pagina dei dettagli.
Nella pagina Dettagli workflow, fai clic su Esegui.
Fai di nuovo clic su Esegui.

L'esecuzione del flusso di lavoro dovrebbe richiedere alcuni minuti.

Nota :se riscontri un errore IAM permission denied for service account nel passaggio createBucket, è probabile che sia dovuto a un ritardo di propagazione. Attendi un minuto o due e poi prova a eseguire di nuovo il flusso di lavoro.
Visualizza i risultati del flusso di lavoro nel riquadro Output.

I risultati dovrebbero essere simili ai seguenti:
```
{
  "bucket": "project-name-job-primegen-TIMESTAMP",
  "jobId": "job-primegen-TIMESTAMP"
}
```

gcloud

Esegui il workflow:
```
gcloud workflows run batch-workflow \
  --location=us-central1
```
L'esecuzione del flusso di lavoro dovrebbe richiedere alcuni minuti.

Nota: se riscontri un errore IAM permission denied for service account nel passaggio createBucket, è probabile che sia dovuto a un ritardo di propagazione. Attendi un minuto o due e poi prova a eseguire di nuovo il flusso di lavoro.
Puoi <x0A>controllare lo stato di un'esecuzione di lunga durata.

Per ottenere lo stato dell'ultima esecuzione completata, esegui questo comando:

gcloud workflows executions describe-last

I risultati dovrebbero essere simili ai seguenti:

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

Elenca gli oggetti nel bucket di output

Puoi verificare che i risultati siano quelli previsti elencando gli oggetti nel bucket di output di Cloud Storage.

Console

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

Vai a Bucket
Nell'elenco dei bucket, fai clic sul nome del bucket di cui vuoi visualizzare i contenuti.

I risultati dovrebbero essere simili ai seguenti, con sei file in totale, ciascuno contenente un gruppo di 10.000 numeri primi:
```
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 il nome del bucket di output:
```
gcloud storage ls
```
L'output è simile al seguente:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Elenca gli oggetti nel bucket di output:

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

Sostituisci TIMESTAMP con il timestamp restituito dal comando precedente.

L'output dovrebbe essere simile al seguente, con sei file in totale, ognuno dei quali elenca un gruppo di 10.000 numeri primi:

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

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, eliminalo. Se hai utilizzato un progetto esistente e vuoi conservarlo senza le modifiche aggiunte in questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud , vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID progetto, quindi fai clic su Chiudi per eliminare il progetto.

Elimina le risorse create in questo tutorial

Elimina il job Batch:

Innanzitutto, recupera il nome del job:

gcloud batch jobs list --location=us-central1

L'output dovrebbe essere simile al seguente:

NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
STATE: SUCCEEDED

Dove job-primegen-TIMESTAMP è il nome del job Batch.

Elimina il job:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

Elimina il workflow:
```
gcloud workflows delete WORKFLOW_NAME
```

Elimina il repository del container:

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

Cloud Build utilizza Cloud Storage per archiviare le risorse di build. Per eliminare un bucket Cloud Storage, consulta Eliminare i bucket.

Esegui un job batch utilizzando Workflows Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Console

gcloud

Crea un repository Artifact Registry

Console

gcloud

Scarica gli esempi di codice

Crea l'immagine Docker utilizzando Cloud Build

Esegui il deployment di un flusso di lavoro che pianifica ed esegue un job batch

Console

YAML

JSON

gcloud

YAML

JSON

Esegui il flusso di lavoro

Console

gcloud

Elenca gli oggetti nel bucket di output

Console

gcloud

Esegui la pulizia

Elimina il progetto

Elimina le risorse create in questo tutorial

Passaggi successivi

Esegui un job batch utilizzando Workflows