Crea ed esegui un job che utilizza volumi di archiviazione

Questo documento spiega come creare ed eseguire un job batch che utilizza uno o più volumi di archiviazione esterna. Le opzioni di archiviazione includono disco permanente nuovi o esistenti, nuovi SSD locali, bucket Cloud Storage esistenti e un file system di rete (NFS) esistente come una condivisione file di Filestore.

Prima di iniziare

Crea un job che utilizza volumi di archiviazione

Per impostazione predefinita, ogni VM di Compute Engine per un job ha un singolo disco permanente di avvio che contiene il sistema operativo. Facoltativamente, puoi creare un job che utilizza volumi di archiviazione aggiuntivi. In particolare, le VM di un job possono utilizzare uno o più dei seguenti tipi di volumi di archiviazione. Per ulteriori informazioni su tutti i tipi di volumi di archiviazione e le differenze e le limitazioni di ciascuno, consulta la documentazione sulle opzioni di archiviazione delle VM di Compute Engine.

Puoi consentire a un job di utilizzare ogni volume di archiviazione includendolo nella definizione del job e specificando il relativo percorso di montaggio (mountPath) negli elementi eseguibili. Per scoprire come creare un job che utilizza volumi di archiviazione, consulta una o più delle seguenti sezioni:

Usa un disco permanente

Un job che utilizza dischi permanenti ha le seguenti limitazioni:

  • Tutti i dischi permanenti: esamina le limitazioni per tutti i dischi permanenti.

  • Dischi permanenti nuovi o esistenti: ogni disco permanente in un job può essere nuovo (definito e creato con il job) o esistente (già creato nel progetto e specificato nel job). Per utilizzare un disco permanente, è necessario formattarlo e montarlo sulle VM del job, che devono trovarsi nella stessa località del disco permanente. Batch monta tutti i dischi permanenti che includi in un job e formatta tutti i nuovi dischi permanenti, ma devi formattare e smontare tutti i dischi permanenti esistenti che vuoi che il job utilizzi.

    Le opzioni di località, le opzioni di formato e le opzioni di montaggio supportate variano in base ai dischi permanenti nuovi ed esistenti come descritto nella seguente tabella:

    Nuovi dischi permanenti Dischi permanenti esistenti
    Opzioni formato

    Il disco permanente è formattato automaticamente con un file system di ext4.

    Devi formattare il disco permanente per utilizzare un file system ext4 prima di utilizzarlo per un job.

    Opzioni di montaggio

    Sono supportate tutte le opzioni.

    Sono supportate tutte le opzioni tranne la scrittura. Ciò è dovuto alle restrizioni della modalità multi-autore.

    Devi scollegare il disco permanente dalle VM a cui è collegato prima di utilizzarlo per un job.
    Opzioni per località

    Puoi creare solo dischi permanenti a livello di zona.

    Puoi selezionare qualsiasi località per il job. I dischi permanenti vengono creati nella zona in cui viene eseguito il progetto.

    Puoi selezionare dischi permanenti a livello di zona e di regione.


    Devi impostare la località del job (o, se specificato, solo le località consentite) su solo le località che contengono tutti i dischi permanenti del job. Ad esempio, per un disco permanente a livello di zona, la località del job deve essere la zona del disco; per un disco permanente a livello di regione, la località del job deve essere la regione del disco o, se specifichi le zone, una o entrambe le zone specifiche in cui si trova il disco permanente a livello di regione.

  • Modelli di istanza: se vuoi utilizzare un modello di istanza VM durante la creazione di questo job, devi collegare i disco permanente per questo job nel modello di istanza. In caso contrario, se non vuoi utilizzare un modello di istanza, devi collegare i disco permanente direttamente nella definizione del job.

Puoi creare un job che utilizzi un disco permanente utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud, l'API batch, Go, Java, Node.js o Python.

Console

Utilizzando la console Google Cloud, l'esempio seguente crea un job che esegue uno script per leggere un file da un disco permanente a livello di zona esistente, situato nella zona us-central1-a. Lo script di esempio presume che il job abbia un disco permanente a livello di zona esistente che contiene un file di testo denominato example.txt nella directory radice.

Facoltativo: se vuoi creare un disco permanente a livello di zona da utilizzare per eseguire lo script di esempio, procedi come segue prima di creare il job:

  1. Collega una nuova persistenza vuota denominata example-disk a una VM Linux nella zona us-central1-a, quindi esegui i comandi sulla VM per formattare e montare il disco. Per le istruzioni, consulta la pagina Aggiungere un disco permanente alla VM.

    Non disconnetterti ancora dalla VM.

  2. Per creare example.txt sul disco permanente, esegui i comandi seguenti sulla VM:

    1. Per modificare la directory di lavoro corrente con la directory principale del disco permanente, digita il seguente comando:

      cd VM_MOUNT_PATH

      Sostituisci VM_MOUNT_PATH con il percorso della directory in cui è stato montato il disco permanente nella VM nel passaggio precedente, ad esempio /mnt/disks/example-disk.

    2. Premi Enter.

    3. Per creare e definire un file denominato example.txt, digita questo comando:

      cat > example.txt

    4. Premi Enter.

    5. Digita il contenuto del file. Ad esempio, digita Hello world!.

    6. Per salvare il file, premi Ctrl+D (oppure Command+D su macOS).

    Al termine, puoi disconnetterti dalla VM.

  3. Scollega il disco permanente dalla VM.

    • Se non hai più bisogno della VM, puoi eliminare la VM, che rimuove automaticamente il disco permanente.

    • Altrimenti, scollega il disco permanente. Per le istruzioni, consulta la sezione Scollegare e ricollegare i dischi di avvio e scollegare il disco permanente example-disk anziché il disco di avvio della VM.

Per creare un job che utilizzi dischi permanenti a livello di zona utilizzando la console Google Cloud, segui questi passaggi:

  1. Nella console Google Cloud, vai alla pagina Elenco job

    Vai all'elenco Job

  2. Fai clic su Crea. Si apre la pagina Crea job batch.

  3. Nel campo Nome job, inserisci un nome per il job.

    Ad esempio, inserisci example-disk-job.

  4. Nel campo Regione, seleziona la località per questo job.

    Ad esempio, seleziona us-central1 (Iowa) (valore predefinito).

  5. Nel campo Zona, seleziona la zona che contiene i dischi permanenti a livello di zona esistenti che vuoi utilizzare per questo job.

    Ad esempio, seleziona us-central1-a (Iowa).

  6. Nel riquadro Nuovo eseguibile, aggiungi almeno uno script o un container affinché questo job possa essere eseguito.

    Ad esempio, per eseguire uno script che stampa il contenuto di un file denominato example.txt e che si trova nella directory radice del disco permanente utilizzato da questo job, procedi nel seguente modo:

    1. Seleziona la casella di controllo Script. Viene visualizzata una casella di testo.

    2. Inserisci nella casella di testo il seguente script:

      echo "Here is the content of the example.txt file in the persistent disk."
cat MOUNT_PATH/example.txt

      Sostituisci MOUNT_PATH con il percorso alla posizione in cui prevedi di montare il disco permanente nelle VM per questo job, ad esempio /mnt/disks/example-disk.

    3. Fai clic su Fine.

  7. Nel campo Conteggio attività, inserisci il numero di attività per questo job.

    Ad esempio, inserisci 1.

  8. Nel campo Parallelismo, inserisci il numero di attività da eseguire in contemporanea.

    Ad esempio, inserisci 1 (valore predefinito).

  9. Per ogni disco permanente a livello di zona esistente che vuoi montare su questo job, segui questi passaggi:

    1. Fai clic su Aggiungi nuovo volume. Viene visualizzato il riquadro Nuovo volume.

    2. Nel riquadro Nuovo volume, procedi nel seguente modo:

    3. Nella sezione Tipo di volume, seleziona Disco permanente.

    4. Nel menu Disco, seleziona un disco permanente a livello di zona esistente che vuoi montare su questo job. Il disco deve trovarsi nella stessa zona di questo job.

      Ad esempio, seleziona il disco permanente a livello di zona esistente che hai preparato, che si trova nella zona us-central1-a e contiene il file example.txt.

    5. (Facoltativo) Se vuoi rinominare questo disco permanente a livello di zona, segui questi passaggi:

      1. Seleziona Personalizza il nome del dispositivo.

      2. Nel campo Nome dispositivo, inserisci il nuovo nome per il disco.

    6. Nel campo Percorso di montaggio, inserisci il percorso di montaggio (MOUNT_PATH) per questo disco permanente:

      Ad esempio, inserisci quanto segue:

      /mnt/disks/EXISTING_PERSISTENT_DISK_NAME

      Sostituisci EXISTING_PERSISTENT_DISK_NAME con il nome del disco. Se hai rinominato il disco permanente a livello di zona, utilizza il nuovo nome.

      Ad esempio, sostituisci EXISTING_PERSISTENT_DISK_NAME con example-disk.

    7. Fai clic su Fine.

  10. (Facoltativo) Configura gli altri campi per questo job.

    Ad esempio, utilizza i valori predefiniti per tutti gli altri campi.

  11. Fai clic su Crea.

    La pagina Elenco job mostra il job che hai creato.

gcloud

Utilizzando l'interfaccia a riga di comando gcloud, l'esempio seguente crea un job che collega e monta un disco permanente esistente e un nuovo disco permanente. Il job ha 3 attività che eseguono ciascuno uno script per creare un file nel nuovo disco permanente denominato output_task_TASK_INDEX.txt, dove TASK_INDEX è l'indice di ogni attività: 0, 1 e 2.

Per creare un job che utilizzi dischi permanenti utilizzando l'interfaccia a riga di comando gcloud, utilizza il comando gcloud batch jobs submit. Nel file di configurazione JSON del job, specifica i dischi permanenti nel campo instances e monta il disco permanente nel campo volumes.

  1. Crea un file JSON.

    • Se non utilizzi un modello di istanza per questo job, crea un file JSON con i seguenti contenuti:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Sostituisci quanto segue:

      • PROJECT_ID: l'ID progetto del progetto.
      • EXISTING_PERSISTENT_DISK_NAME: il nome di un disco permanente esistente.
      • EXISTING_PERSISTENT_DISK_LOCATION: la località di un disco permanente esistente. Per ogni disco permanente a livello di zona esistente, la località del job deve essere la zona del disco; per ogni disco permanente a livello di regione esistente, la località del job deve essere la regione del disco o, se specifichi le zone, una o entrambe le zone specifiche in cui si trova il disco permanente a livello di regione. Se non specifichi alcun disco permanente esistente, puoi selezionare una qualsiasi località. Scopri di più sul campo allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: le dimensioni del nuovo disco permanente in GB. Le dimensioni consentite dipendono dal tipo di disco permanente, ma il minimo è spesso di 10 GB (10) e il massimo è spesso di 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: il tipo di disco del nuovo disco permanente, pd-standard, pd-balanced, pd-ssd o pd-extreme.
      • NEW_PERSISTENT_DISK_NAME: il nome del nuovo disco permanente.

    • Se utilizzi un modello di istanza VM per questo job, crea un file JSON come mostrato in precedenza, ad eccezione del campo instances con il seguente codice:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      dove INSTANCE_TEMPLATE_NAME è il nome del modello di istanza per questo job. Per un job che utilizza dischi permanenti, questo modello di istanza deve definire e collegare i dischi permanenti che vuoi che il job utilizzi. In questo esempio, il modello deve definire e collegare un nuovo disco permanente denominato NEW_PERSISTENT_DISK_NAME, oltre a collegare un disco permanente esistente denominato EXISTING_PERSISTENT_DISK_NAME.

  2. Esegui questo comando:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.

    • LOCATION: la località del job.

    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Utilizzando l'API Batch, l'esempio seguente crea un job che collega e monta un disco permanente esistente e un nuovo disco permanente. Il job ha 3 attività che eseguono ciascuno uno script per creare un file nel nuovo disco permanente denominato output_task_TASK_INDEX.txt, dove TASK_INDEX è l'indice di ogni attività: 0, 1 e 2.

Per creare un job che utilizzi dischi permanenti utilizzando l'API Batch, utilizza il metodo jobs.create. Nella richiesta, specifica i dischi permanenti nel campo instances e monta il disco permanente nel campo volumes.

  • Se non utilizzi un modello di istanza per questo job, effettua la seguente richiesta:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto del progetto.
    • LOCATION: la località del job.
    • JOB_NAME: il nome del job.
    • EXISTING_PERSISTENT_DISK_NAME: il nome di un disco permanente esistente.
    • EXISTING_PERSISTENT_DISK_LOCATION: la località di un disco permanente esistente. Per ogni disco permanente a livello di zona esistente, la località del job deve essere la zona del disco; per ogni disco permanente a livello di regione esistente, la località del job deve essere la regione del disco o, se specifichi le zone, una o entrambe le zone specifiche in cui si trova il disco permanente a livello di regione. Se non specifichi alcun disco permanente esistente, puoi selezionare qualsiasi località. Scopri di più sul campo allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: le dimensioni del nuovo disco permanente in GB. Le dimensioni consentite dipendono dal tipo di disco permanente, ma il minimo è spesso di 10 GB (10) e il massimo è spesso di 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: il tipo di disco del nuovo disco permanente, pd-standard, pd-balanced, pd-ssd o pd-extreme.
    • NEW_PERSISTENT_DISK_NAME: il nome del nuovo disco permanente.

  • Se utilizzi un modello di istanza VM per questo job, crea un file JSON come mostrato in precedenza, ad eccezione del campo instances con il seguente codice:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Dove INSTANCE_TEMPLATE_NAME è il nome del modello di istanza per questo job. Per un job che utilizza dischi permanenti, questo modello di istanza deve definire e collegare i dischi permanenti che vuoi che il job utilizzi. In questo esempio, il modello deve definire e collegare un nuovo disco permanente denominato NEW_PERSISTENT_DISK_NAME, oltre a collegare un disco permanente esistente denominato EXISTING_PERSISTENT_DISK_NAME.

Go

Per creare un job batch che utilizzi dischi nuovi o esistenti utilizzando le librerie client Cloud per Go, utilizza la funzione CreateJob e includi quanto segue:

Per un esempio di codice di un caso d'uso simile, consulta Utilizzare un bucket Cloud Storage.

Java

Per creare un job batch che utilizzi dischi nuovi o esistenti utilizzando le librerie client Cloud per Java, utilizza la classe CreateJobRequest e includi quanto segue:

Per un esempio di codice di un caso d'uso simile, consulta Utilizzare un bucket Cloud Storage.

Node.js

Per creare un job batch che utilizzi dischi permanenti nuovi o esistenti utilizzando le librerie client Cloud per Node.js, utilizza il metodo createJob e includi quanto segue:

Per un esempio di codice di un caso d'uso simile, consulta Utilizzare un bucket Cloud Storage.

Python

Per creare un job batch che utilizzi dischi nuovi o esistenti utilizzando le librerie client Cloud per Python, utilizza la funzione CreateJob e includi quanto segue:

  • Per collegare i dischi permanenti alle VM per un job, includi una delle seguenti opzioni:
  • Per montare i dischi permanenti sul job, utilizza la classe Volume con gli attributi device_name e mount_path. Per i nuovi dischi permanenti, utilizza anche l'attributo mount_options per abilitare la scrittura.

Per un esempio di codice di un caso d'uso simile, consulta Utilizzare un bucket Cloud Storage.

Utilizza un SSD locale

Un job che utilizza SSD locali ha le seguenti limitazioni:

Puoi creare un job che utilizzi un SSD locale utilizzando l'interfaccia a riga di comando gcloud o l'API Batch. L'esempio seguente descrive come creare un job che crea, collega e monta un SSD locale. Il job include anche tre attività che eseguono uno script per creare un file nell'SSD locale denominato output_task_TASK_INDEX.txt, dove TASK_INDEX è l'indice di ogni attività: 0, 1 e 2.

gcloud

Per creare un job che utilizza gli SSD locali utilizzando l'interfaccia a riga di comando gcloud, utilizza il comando gcloud batch jobs submit. Nel file di configurazione JSON del job, crea e collega gli SSD locali nel campo instances e monta gli SSD locali nel campo volumes.

  1. Crea un file JSON.

    • Se non utilizzi un modello di istanza per questo job, crea un file JSON con i seguenti contenuti:

      {
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

      Sostituisci quanto segue:

      • MACHINE_TYPE: il tipo di macchina, che può essere predefinita o personalizzata, delle VM del job. Il numero consentito di SSD locali dipende dal tipo di macchina per le VM del tuo job.
      • LOCAL_SSD_NAME: il nome di un SSD locale creato per questo job.
      • LOCAL_SSD_SIZE: la dimensione di tutti gli SSD locali in GB. Ogni SSD locale ha una dimensione di 375 GB, pertanto questo valore deve essere un multiplo di 375 GB. Ad esempio, per 2 SSD locali, imposta questo valore su 750 GB.

    • Se utilizzi un modello di istanza VM per questo job, crea un file JSON come mostrato in precedenza, ad eccezione del campo instances con il seguente codice:

      "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],

      dove INSTANCE_TEMPLATE_NAME è il nome del modello di istanza per questo job. Per un job che utilizza SSD locali, questo modello di istanza deve definire e collegare gli SSD locali che vuoi che il job utilizzi. In questo esempio, il modello deve definire e collegare un'unità SSD locale denominata LOCAL_SSD_NAME.

  2. Esegui questo comando:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.
    • LOCATION: la località del job.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizzi SSD locali tramite l'API Batch, utilizza il metodo jobs.create. Nella richiesta, crea e collega gli SSD locali nel campo instances e monta gli SSD locali nel campo volumes.

  • Se non utilizzi un modello di istanza per questo job, effettua la seguente richiesta:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID progetto del progetto.
    • LOCATION: la località del job.
    • JOB_NAME: il nome del job.
    • MACHINE_TYPE: il tipo di macchina, che può essere predefinita o personalizzata, delle VM del job. Il numero consentito di SSD locali dipende dal tipo di macchina per le VM del tuo job.
    • LOCAL_SSD_NAME: il nome di un SSD locale creato per questo job.
    • LOCAL_SSD_SIZE: la dimensione di tutti gli SSD locali in GB. Ogni SSD locale ha una dimensione di 375 GB, pertanto questo valore deve essere un multiplo di 375 GB. Ad esempio, per 2 SSD locali, imposta questo valore su 750 GB.

  • Se utilizzi un modello di istanza VM per questo job, crea un file JSON come mostrato in precedenza, ad eccezione del campo instances con il seguente codice:

    "instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...

    Dove INSTANCE_TEMPLATE_NAME è il nome del modello di istanza per questo job. Per un job che utilizza SSD locali, questo modello di istanza deve definire e collegare gli SSD locali che vuoi che il job utilizzi. In questo esempio, il modello deve definire e collegare un'unità SSD locale denominata LOCAL_SSD_NAME.

Utilizza un bucket Cloud Storage

Per creare un job che utilizzi un bucket Cloud Storage esistente, seleziona uno dei seguenti metodi:

  • Consigliato: monta un bucket direttamente sulle VM del job specificando il bucket nella definizione del job, come mostrato in questa sezione. Quando viene eseguito, il bucket viene montato automaticamente sulle VM per il job mediante FUSE Cloud Storage.
  • Crea un job con attività che accedono direttamente a un bucket Cloud Storage utilizzando lo strumento a riga di comando gsutil o le librerie client per l'API Cloud Storage. Per informazioni su come accedere a un bucket Cloud Storage direttamente da una VM, consulta la documentazione di Compute Engine per Scrittura e lettura dei dati dai bucket Cloud Storage.

Prima di creare un job che utilizza un bucket, crea un bucket o identifica un bucket esistente. Per ulteriori informazioni, consulta Creare bucket ed Elencare bucket.

Puoi creare un job che utilizza un bucket Cloud Storage utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud, l'API batch, Go, Java, Node.js o Python.

L'esempio seguente descrive come creare un job che monta un bucket Cloud Storage. Il job ha anche 3 attività, ciascuna delle quali esegue uno script per creare un file nel bucket denominato output_task_TASK_INDEX.txt, dove TASK_INDEX è l'indice di ogni attività: 0, 1 e 2.

Console

Per creare un job che utilizzi un bucket Cloud Storage utilizzando la console Google Cloud, procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina Elenco job

    Vai all'elenco Job

  2. Fai clic su Crea. Si apre la pagina Crea job batch.

  3. Nel campo Nome job, inserisci example-bucket-job.

  4. Nel campo Regione, seleziona la località per questo job.

    Ad esempio, seleziona us-central1 (Iowa) (valore predefinito).

  5. Nel campo Zona, seleziona any (valore predefinito).

  6. Nella sezione Modello di provisioning delle VM, seleziona Standard (impostazione predefinita).

  7. Fai clic su Generico.

  8. Nel campo Serie, seleziona E2 (valore predefinito).

  9. Nel campo Tipo di macchina, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

  10. Nel riquadro Nuovo eseguibile, procedi nel seguente modo:

    1. Seleziona la casella di controllo Script. Viene visualizzata una casella di testo.

    2. Inserisci nella casella di testo il seguente script:

      echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

      Dove MOUNT_PATH è il percorso di montaggio utilizzato dai eseguibili di questo job per accedere a un bucket Cloud Storage esistente. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo bucket con una directory denominata my-bucket, imposta il percorso di montaggio su /mnt/disks/my-bucket.

    3. Fai clic su Fine.

  11. Nel campo Conteggio attività, inserisci 3.

  12. Nel campo Parallelismo, inserisci 1 (valore predefinito).

  13. Nella sezione Risorse per le attività, specifica la quantità di risorse VM necessarie per ogni attività, seguendo questi passaggi:

    1. Nel campo Core, inserisci 1 (valore predefinito).

    2. Nel campo Memoria, inserisci 0.5 (valore predefinito).

  14. Fai clic su Aggiungi nuovo volume. Viene visualizzato il riquadro Nuovo volume.

  15. Nel riquadro Nuovo volume, procedi nel seguente modo:

    1. Nella sezione Tipo di volume, seleziona Bucket Cloud Storage.

    2. Nel campo Nome bucket di archiviazione, inserisci il nome di un bucket esistente.

      Ad esempio, inserisci il bucket specificato nel runtime eseguibile del job.

    3. Nel campo Percorso di montaggio, inserisci il percorso di montaggio del bucket (MOUNT_PATH), che hai specificato nel passaggio precedente.

    4. Fai clic su Fine.

  16. Fai clic su Crea.

La pagina Elenco job mostra il job che hai creato.

gcloud

Per creare un job che utilizza un bucket Cloud Storage utilizzando l'interfaccia a riga di comando gcloud, utilizza il comando gcloud batch jobs submit. Nel file di configurazione JSON del job, monta il bucket nel campo volumes.

Ad esempio, per creare un job che restituisca file in Cloud Storage:

  1. Crea un file JSON con il seguente contenuto:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • BUCKET_PATH: il percorso della directory dei bucket a cui vuoi accedere questo job, che deve iniziare con il nome del bucket. Ad esempio, per un bucket denominato BUCKET_NAME, il percorso BUCKET_NAME rappresenta la directory principale del bucket e il percorso BUCKET_NAME/subdirectory rappresenta la sottodirectory subdirectory.
    • MOUNT_PATH: il percorso di montaggio utilizzato dai eseguibili del job per accedere a questo bucket. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo bucket con una directory denominata my-bucket, imposta il percorso di montaggio su /mnt/disks/my-bucket.

  2. Esegui questo comando:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.
    • LOCATION: la località del job.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizzi un bucket Cloud Storage utilizzando l'API Batch, utilizza il metodo jobs.create e monta il bucket nel campo volumes.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • LOCATION: la località del job.
  • JOB_NAME: il nome del job.
  • BUCKET_PATH: il percorso della directory dei bucket a cui vuoi accedere questo job, che deve iniziare con il nome del bucket. Ad esempio, per un bucket denominato BUCKET_NAME, il percorso BUCKET_NAME rappresenta la directory principale del bucket e il percorso BUCKET_NAME/subdirectory rappresenta la sottodirectory subdirectory.
  • MOUNT_PATH: il percorso di montaggio utilizzato dai eseguibili del job per accedere a questo bucket. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo bucket con una directory denominata my-bucket, imposta il percorso di montaggio su /mnt/disks/my-bucket.

Go

Go

Per scoprire di più, consulta la documentazione di riferimento per le API Go in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	batchpb "google.golang.org/genproto/googleapis/cloud/batch/v1"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Volumes:       []*batchpb.Volume{volume},
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// In this case, we tell the system to use "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

Per scoprire di più, consulta la documentazione di riferimento per le API Java in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.GCS;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithMountedBucket {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .addVolumes(volume)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());
    }
  }
}

Node.js

Node.js

Per scoprire di più, consulta la documentazione di riferimento per le API Node.js in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_NAME';

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  'echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// You can also run a script from a file. Just remember, that needs to be a script that's
// already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
// exclusive.
// runnable.script.path = '/tmp/test.sh'
task.runnables = [runnable];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = task;

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.logsPolicy.destination = batch.LogsPolicy.Destination.CLOUD_LOGGING;

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const response = await batchClient.createJob(request);
  console.log(response);
}

callCreateJob();

Python

Python

Per scoprire di più, consulta la documentazione di riferimento per le API Python in batch.

Per eseguire l'autenticazione in batch, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

from google.cloud import batch_v1

def create_script_job_with_bucket(project_id: str, region: str, job_name: str, bucket_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        bucket_name: name of the bucket to be mounted for your Job.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = '/mnt/share'
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
    resources.memory_mib = 16
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script", "mount": "bucket"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

Utilizzare un file system di rete

Puoi creare un job che utilizzi un file system di rete (NFS) esistente, ad esempio una condivisione di file Filestore, utilizzando la console Google Cloud, l'interfaccia a riga di comando gcloud o l'API batch.

Prima di creare un job che utilizza un NFS, assicurati che il firewall della tua rete sia configurato correttamente per consentire il traffico tra le VM del job e l'NFS. Per ulteriori informazioni, consulta la pagina sulla configurazione delle regole firewall per Filestore.

L'esempio seguente descrive come creare un job che specifichi e monta un NFS. Il job include anche tre attività che eseguono ciascuno uno script per creare un file nell'NFS denominato output_task_TASK_INDEX.txt dove TASK_INDEX è l'indice di ogni attività: 0, 1 e 2.

Console

Per creare un job che utilizzi un bucket Cloud Storage utilizzando la console Google Cloud, procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina Elenco job

    Vai all'elenco Job

  2. Fai clic su Crea. Si apre la pagina Crea job batch.

  3. Nel campo Nome job, inserisci example-nfs-job.

  4. Nel campo Regione, seleziona la località per questo job.

    Ad esempio, seleziona us-central1 (Iowa) (valore predefinito).

  5. Nel campo Zona, seleziona any (valore predefinito).

  6. Nella sezione Modello di provisioning delle VM, seleziona Standard (impostazione predefinita).

  7. Fai clic su Generico.

  8. Nel campo Serie, seleziona E2 (valore predefinito).

  9. Nel campo Tipo di macchina, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

  10. Nel riquadro Nuovo eseguibile, procedi nel seguente modo:

    1. Seleziona la casella di controllo Script. Viene visualizzata una casella di testo.

    2. Inserisci nella casella di testo il seguente script:

      echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt

      Dove MOUNT_PATH è il percorso di montaggio utilizzato dal job per accedere a questo NFS. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo NFS con una directory denominata my-nfs, imposta il percorso di montaggio su /mnt/disks/my-nfs.

    3. Fai clic su Fine.

  11. Nel campo Conteggio attività, inserisci 3.

  12. Nel campo Parallelismo, inserisci 1 (valore predefinito).

  13. Nella sezione Risorse per le attività, specifica la quantità di risorse VM necessarie per ogni attività, seguendo questi passaggi:

    1. Nel campo Core, inserisci 1 (valore predefinito).

    2. Nel campo Memoria, inserisci 0.5 (valore predefinito).

  14. Fai clic su Aggiungi nuovo volume. Viene visualizzato il riquadro Nuovo volume.

  15. Nel riquadro Nuovo volume, procedi nel seguente modo:

    1. Nella sezione Tipo di volume, seleziona File system di rete.

    2. Nel campo File server, inserisci l'indirizzo IP del server in cui si trova l'NFS specificato nel comando eseguibile.

      Ad esempio, se il tuo NFS è una condivisione file di Filestore, specifica l'indirizzo IP della VM che ospita la condivisione file di Filestore, che puoi ottenere descrivendo la VM Filestore.

    3. Nel campo Percorso remoto, inserisci un percorso che possa accedere all'NFS specificato nel passaggio precedente.

      Il percorso della directory NFS deve iniziare con / seguito dalla directory radice dell'NFS.

    4. Nel campo Montaggio percorso, inserisci il percorso di montaggio al valore NFS (MOUNT_PATH), specificato nel passaggio precedente.

    5. Fai clic su Fine.

  16. Fai clic su Crea.

La pagina Elenco job mostra il job che hai creato.

gcloud

Per creare un job che utilizzi un NFS utilizzando l'interfaccia a riga di comando gcloud, utilizza il comando gcloud batch jobs submit. Nel file di configurazione JSON del job, monta l'NFS nel campo volumes.

  1. Crea un file JSON con il seguente contenuto:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • NFS_IP_ADDRESS: l'indirizzo IP dell'NFS. Ad esempio, se il file NFS è una condivisione file di Filestore, specifica l'indirizzo IP della VM che ospita la condivisione file di Filestore, che puoi ottenere descrivendo la VM Filestore.
    • NFS_PATH: il percorso della directory NFS a cui vuoi accedere questo job, che deve iniziare con un / seguito dalla directory radice dell'NFS. Ad esempio, per una condivisione file di Filestore denominata FILE_SHARE_NAME, il percorso /FILE_SHARE_NAME rappresenta la directory principale della condivisione file e il percorso /FILE_SHARE_NAME/subdirectory rappresenta la sottodirectory subdirectory.
    • MOUNT_PATH: il percorso di montaggio utilizzato dai eseguibili del job per accedere a questo NFS. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo NFS con una directory denominata my-nfs, imposta il percorso di montaggio su /mnt/disks/my-nfs.

  2. Esegui questo comando:

    gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.
    • LOCATION: la località del job.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizzi un NFS utilizzando l'API batch, utilizza il metodo jobs.create e monta l'NFS nel campo volumes.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

   {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del progetto.
  • LOCATION: la località del job.
  • JOB_NAME: il nome del job.
  • NFS_IP_ADDRESS: l'indirizzo IP del file system di rete. Ad esempio, se il file NFS è una condivisione file di Filestore, specifica l'indirizzo IP della VM che ospita la condivisione file di Filestore, che puoi ottenere descrivendo la VM Filestore.
  • NFS_PATH: il percorso della directory NFS a cui vuoi accedere questo job, che deve iniziare con un / seguito dalla directory radice dell'NFS. Ad esempio, per una condivisione file di Filestore denominata: FILE_SHARE_NAME, il percorso /FILE_SHARE_NAME rappresenta la directory principale della condivisione file e il percorso /FILE_SHARE_NAME/subdirectory rappresenta una sottodirectory.
  • MOUNT_PATH: il percorso di montaggio utilizzato dai eseguibili del job per accedere a questo NFS. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso scelto. Ad esempio, se vuoi rappresentare questo NFS con una directory denominata my-nfs, imposta il percorso di montaggio su /mnt/disks/my-nfs.

Passaggi successivi