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. Esegui il provisioning delle risorse in batch e gestisce la capacità consentendo l'esecuzione su larga scala dei carichi di lavoro batch.

Workflows ti consente di eseguire i servizi di cui hai bisogno in un ordine definito da te 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. Utilizzo di entrambe le modalità Batch e Workflows consente di combinare i vantaggi offerti ed efficiente il provisioning e l'orchestrazione dell'intero processo.

Obiettivi

In questo tutorial, imparerai a:

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

Puoi eseguire la maggior parte dei comandi seguenti nella console Google Cloud o eseguire tutti i comandi utilizzando l'interfaccia a riga di comando Google Cloud nel terminale o in Cloud Shell.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

• Artifact Registry
• Batch
• Cloud Build
• Workflows

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

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

1. Nella pagina del selettore progetti della console Google Cloud, seleziona oppure creare un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno esistente. Dopo il giorno puoi completare questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associati al progetto.

   Vai al selettore progetti

2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verifica se la fatturazione è abilitata su un progetto.

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

   Abilita le API

4. Crea un account di servizio per il flusso di lavoro da utilizzare per l'autenticazione con altri servizi Google Cloud e assegnagli i ruoli appropriati:

   1. Nella console Google Cloud, vai alla pagina Crea account di servizio.

      Vai a Crea account di servizio

   2. Seleziona il progetto.

   3. Nel campo Nome account di servizio, inserisci un nome. La console Google Cloud compila il campo ID account di servizio in base a questo nome.

      Nel campo Descrizione account di servizio, 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 all'account di servizio gestito dall'utente che hai creato nel passaggio precedente:

      • Editor job batch: per modificare job batch.
      • Logs Writer: per scrivere i log.
      • Amministratore Storage: per controllare le risorse Cloud Storage.

      Per altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni altro ruolo.

      Nota: il campo Ruolo influisce sulle risorse a cui può accedere il tuo account di servizio nel progetto. Puoi revocare questi ruoli o concederne altri in un secondo momento. Negli 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.

5. Concedi il ruolo Utente account di servizio IAM nell'impostazione predefinita l'account di servizio all'account di servizio gestito dall'utente creato nella precedente passaggio. Dopo aver abilitato l'API Compute Engine, l'account di servizio predefinito è l'account di servizio predefinito di Compute Engine. ([e-mail]), e l'autorizzazione viene generalmente assegnata tramite Ruolo roles/iam.serviceAccountUser.

   Attenzione: l'assegnazione del parametro Ruolo Utente account di servizio concede indirettamente il ruolo associato all'account di servizio predefinito a per l'utente. 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 ruoli, ti consigliamo di configurare l'account di servizio predefinito in base al principio del privilegio minimo. Per ulteriori informazioni, vedi Disabilita le concessioni automatiche di ruoli agli account di servizio predefiniti.

   1. Nella pagina Account di servizio, fai clic sull'indirizzo email dell'account di servizio predefinito ([e-mail]).

   2. Fai clic sulla scheda Autorizzazioni.

   3. Fai clic sul pulsante Concedi accesso.

   4. Per aggiungere un nuovo principale, inserisci l'indirizzo email del tuo account di servizio (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com).

   5. Nell'elenco Seleziona un ruolo, seleziona Account di servizio > Utente account di servizio.

   6. Fai clic su Salva.

gcloud

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

2. Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verifica se la fatturazione è abilitata su un progetto.

3. Abilita Artifact Registry, Batch, Cloud Build API di Workflows e esecuzioni di flussi di lavoro di Compute Engine.

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

4. Crea un account di servizio da utilizzare per l'autenticazione con altri servizi Google Cloud e concedi i ruoli appropriati.

   1. Crea l'account di servizio:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Sostituisci SERVICE_ACCOUNT_NAME con il nome di l'account di servizio.

   2. Concedi i ruoli all'account di servizio gestito dall'utente che hai creato nel passaggio precedente. Esegui questo 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 di Cloud Storage.

      gcloud projects add-iam-policy-binding PROJECT_ID \
        --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
        --role=ROLE

      Sostituisci quanto segue:

      • PROJECT_ID: l'ID progetto in cui hai creato l'account di servizio
      • ROLE: il ruolo da concedere
      Nota: il flag --role influisce sulle risorse a cui può accedere il tuo account di servizio nel progetto. Puoi revocare questi ruoli o concedere altri ruoli in seguito. Negli ambienti di produzione, non concedere i ruoli Proprietario, Editor o Visualizzatore. Concedi invece ruolo predefinito o ruolo personalizzato che soddisfa le e alle esigenze aziendali.

5. Concedi il ruolo Utente account di servizio IAM nell'impostazione predefinita l'account di servizio all'account di servizio gestito dall'utente che hai creato passaggio precedente. Dopo aver attivato l'API Compute Engine, l'account di servizio predefinito è l'account di servizio predefinito Compute Engine ([e-mail]) e l'autorizzazione viene in genere assegnata tramite il ruolo roles/iam.serviceAccountUser.

   Attenzione: l'assegnazione del parametro Ruolo Utente account di servizio concede indirettamente il ruolo associato all'account di servizio predefinito a per l'utente. 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 ruoli, ti consigliamo di configurare l'account di servizio predefinito in base al principio del privilegio minimo. Per ulteriori informazioni, consulta Disattivare le concessioni automatiche dei ruoli agli account di servizio predefiniti.

   PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
   gcloud iam service-accounts add-iam-policy-binding \
     $[e-mail] \
     --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
     --role=roles/iam.serviceAccountUser

Crea un repository Artifact Registry

Creare un repository per archiviare l'immagine container Docker.

Console

1. Nella console Google Cloud, vai alla pagina Repository.

   Vai a Repositories

2. Fai clic su Crea repository.

3. Inserisci containers come nome del repository.

4. In Formato, scegli Docker.

5. Per Tipo di località, scegli Regione.

6. Nell'elenco Regione, seleziona us-central1.

7. 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 nel Regione us-central1. Per ulteriori informazioni sulle regioni supportate, vedi Località di Artifact Registry.

Ottieni gli esempi di codice

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

1. Clona il repository dell'app di esempio sulla tua macchina locale:

   git clone https://github.com/GoogleCloudPlatform/batch-samples.git
   

   In alternativa, puoi scarica gli esempi nel file main.zip ed estrarlo.

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

   cd batch-samples/primegen
   

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

Crea l'immagine Docker utilizzando Cloud Build

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 Google Cloud dell'ID progetto.

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 ha eseguito il push dell'immagine in un repository Artifact Registry denominato containers.

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

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

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Fai clic su Crea.

3. Inserisci un nome per il nuovo flusso di lavoro, ad esempio batch-workflow.

4. Nell'elenco Regione, seleziona us-central1.

5. Seleziona l'account di servizio che hai creato in precedenza.

6. Fai clic su Avanti.

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

8. Fai clic su Esegui il deployment.

gcloud

1. Crea un file di codice sorgente per il flusso di lavoro:

   touch batch-workflow.JSON_OR_YAML

   Sostituisci JSON_OR_YAML con yaml o json a seconda del formato del flusso di lavoro.

2. In un editor di testo, copia il seguente flusso di lavoro nel file di 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}"
             }
           }
         }
       ]
     }
   }
   

3. Esegui il deployment del flusso di lavoro inserendo il seguente comando:

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

   Sostituisci SERVICE_ACCOUNT_NAME con il nome di l'account di servizio creato in precedenza.

Esegui il flusso di lavoro

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

Console

1. Nella console Google Cloud, vai alla pagina Flussi di lavoro.

   Vai a Flussi di lavoro

2. Nella pagina Flussi di lavoro, fai clic sul pulsante batch-workflow per accedere alla relativa pagina dei dettagli.

3. Nella pagina Dettagli flusso di lavoro, fai clic su Esegui.

4. 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 si tratti di un ritardo nella propagazione. Attendi un paio di minuti e poi riprova a eseguire il flusso di lavoro.

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

1. Esegui il flusso di lavoro:

   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 si tratti di un ritardo nella propagazione. Attendi un paio di minuti e poi riprova a eseguire il flusso di lavoro.

2. Puoi controllare lo stato di un'esecuzione di lunga durata.

3. 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 Cloud Storage.

Console

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

   Vai a Bucket

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

   I risultati dovrebbero essere simili al seguente, con sei file in totale, ciascuno contenente un batch 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

1. Recupera il nome del bucket di output:

   gcloud storage ls

   L'output è simile al seguente:

   gs://PROJECT_ID-job-primegen-TIMESTAMP/

2. Elenca gli oggetti nel bucket di output:

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

   Sostituisci TIMESTAMP con il timestamp restituito da il comando precedente.

   L'output dovrebbe essere simile al seguente, con sei file in totale, e ognuno 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, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai 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, quando lo elimini elimini anche tutto il lavoro 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 per il futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se prevedi di esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti può aiutarti a evitare di superare i limiti di quota.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina le risorse create in questo tutorial

1. Elimina il job batch:

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

   2. Elimina il job:

      gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

2. Elimina il flusso di lavoro:

   gcloud workflows delete WORKFLOW_NAME

3. Elimina il repository di container:

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

4. Cloud Build utilizza Cloud Storage per archiviare le risorse di compilazione. Per eliminare un bucket Cloud Storage, consulta Elimina i bucket.

Passaggi successivi

• Scopri di più su Batch.
• Scopri di più su Workflows.
• Scopri di più sui connettori di Workflows.