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 esterni. Le opzioni di archiviazione esterna includono nuovi o esistenti disco permanente, nuovi SSD locali, bucket Cloud Storage esistenti e un file system di rete (NFS) esistente come Condivisione file Filestore.

Indipendentemente dal fatto che tu aggiunga volumi di archiviazione esterni, ogni La VM di Compute Engine per un job ha un disco di avvio, che fornisce spazio di archiviazione per l'immagine e le istruzioni del sistema operativo del job. Per informazioni sulla configurazione del disco di avvio per un job, consulta Panoramica dell'ambiente del sistema operativo VM.

Prima di iniziare

Crea un job che utilizza volumi di archiviazione

Facoltativamente, un job può utilizzare uno o più di ciascuno dei seguenti tipi di come volumi di archiviazione esterni. Per ulteriori informazioni su tutti i tipi di volumi di archiviazione differenze e restrizioni per ciascuno, consulta la documentazione Opzioni di archiviazione per le VM di Compute Engine.

Puoi consentire a un job di utilizzare ogni volume di archiviazione includendolo nella definizione del tuo job e specificandone percorso di montaggio (mountPath) nei tuoi runnable. Per scoprire come creare un job che utilizza volumi di archiviazione, consulta una o più delle seguenti sezioni:

Utilizza un disco permanente

Un job che utilizza dischi permanenti ha le seguenti restrizioni:

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

  • Dischi permanenti nuovi ed esistenti: ogni disco permanente in un job può essere nuovo (definito e creato con il job) o esistente (già sono stati creati nel progetto e specificati nel job). Per utilizzare un disco permanente, deve essere formattati e montati nel delle VM del job, che devono trovarsi nella stessa località del disco permanente. Il comando monta in batch tutti i dischi permanenti che includi in un job formatta i nuovi dischi permanenti, ma devi formattare e smontare i dischi permanenti esistenti che vuoi vengano utilizzati da un job.

    Le opzioni di località supportate, opzioni di formato, e opzioni di montaggio variano tra i dischi permanenti nuovi ed esistenti, come descritto in tabella:

    Nuovi dischi permanenti Dischi permanenti esistenti
    Opzioni formato

    Il disco permanente viene formattato automaticamente con una File system ext4:

    Devi formattare il disco permanente utilizzare un File system ext4 prima di utilizzarlo per un lavoro.

    Opzioni di montaggio

    Sono supportate tutte le opzioni.

    Sono supportate tutte le opzioni tranne la scrittura. Ciò è dovuto a limitazioni di modalità multi-writer.

    Devi dissociare il disco permanente da qualsiasi 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 tuo lavoro. L'impostazione permanente vengono creati i dischi nella zona in cui viene eseguito il progetto.

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


    Devi impostare la posizione del lavoro (o, se specificato, solo la posizione località consentite) alle solo località che contengono tutti i dati i dischi permanenti. Ad esempio, per un disco permanente a livello di zona, la località 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 specificando zone, una o entrambe le zone specifiche in cui a disco permanente di regione.

  • Modelli di istanza: se vuoi utilizza un modello di istanza VM durante la creazione di questo job, devi collegare i disco permanente per questo job nell'istanza modello. Altrimenti, se non vuoi utilizzare un modello di istanza, devi collegare eventuali disco permanente direttamente nella definizione del job.

Puoi creare un job che utilizza un disco permanente console Google Cloud, gcloud CLI, API Batch, Go, Java, Node.js, Python o C++.

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 che si trova nella zona us-central1-a. Lo script di esempio presuppone che il job dispone di un disco permanente a livello di zona esistente contenente un file di testo denominato example.txt nella directory principale.

(Facoltativo) Crea un disco permanente a livello di zona di esempio

Se vuoi creare un disco permanente a livello di zona da usare esegui lo script di esempio, segui questi passaggi prima di creare il job:

  1. Collega un nuovo permanente vuoto denominato example-disk a una VM Linux nel us-central1-a zona ed eseguire sulla VM i comandi da formattare e montare sul disco. Per istruzioni, vedi Aggiungi un disco permanente alla tua VM.

    Non disconnetterti ancora dalla VM.

  2. Per creare example.txt sul disco permanente, esegui questo comando sulla VM:

    1. Per modificare la directory di lavoro corrente nella directory radice del un disco permanente, digita il seguente comando:

      cd VM_MOUNT_PATH

      Sostituisci VM_MOUNT_PATH con il percorso di la directory in cui è stato montato il disco permanente su questa 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 (o Command+D su macOS).

    Al termine, puoi disconnetterti dalla VM.

  3. Scollega il disco permanente dalla VM.

Crea un job che utilizza il disco permanente a livello di zona esistente

Per creare un job che utilizza dischi permanenti a livello di zona esistenti usando Nella console Google Cloud, segui questi passaggi:

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

    Vai all'elenco dei job

  2. Fai clic su Crea. La Si apre la pagina Crea job batch. Nel riquadro a sinistra, La pagina Dettagli job è selezionata.

  3. Configura la pagina Dettagli job:

    1. (Facoltativo) Nel campo Nome job, personalizza il nome del job.

      Ad esempio, inserisci example-disk-job.

    2. Configura la sezione Dettagli attività:

      1. Nella finestra Nuovo eseguibile, aggiungi almeno uno script oppure container per l'esecuzione di questo job.

        Ad esempio, per eseguire uno script che stampi i contenuti di un file denominato example.txt e che si trova nella directory radice del disco permanente utilizzato da questo job, segui questi passaggi:

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

        2. Nella casella di testo, inserisci 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 di in cui prevedi di montare il disco permanente sulle VM questo job, ad esempio /mnt/disks/example-disk.

        3. Fai clic su Fine.

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

        Ad esempio, inserisci 1 (valore predefinito).

      3. Nel campo Parallelismo, inserisci il numero di attività da contemporaneamente.

        Ad esempio, inserisci 1 (valore predefinito).

  4. Configura la pagina Specifiche delle risorse:

    1. Nel riquadro a sinistra, fai clic su Specifiche della risorsa. Si apre la pagina Specifiche della risorsa.

    2. Seleziona la località per questo lavoro. Per usare un disco permanente a livello di zona esistente, le VM di un job devono devono trovarsi nella stessa zona.

      1. Nel campo Regione, seleziona una regione.

        Ad esempio, per utilizzare il disco permanente a livello di zona, Seleziona us-central1 (Iowa) (impostazione predefinita).

      2. Nel campo Zona, seleziona una zona.

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

  5. Configura la pagina Configurazioni aggiuntive:

    1. Nel riquadro a sinistra, fai clic su Configurazioni aggiuntive. Si apre la pagina Configurazioni aggiuntive.

    2. Per ogni disco permanente a livello di zona esistente su cui vuoi montare questo lavoro:

      1. Nella sezione Volume spazio di archiviazione, fai clic su Aggiungi nuovo volume. Viene visualizzata la finestra Nuovo volume.

      2. Nella finestra Nuovo volume:

        1. Nella sezione Tipo di volume, seleziona Persistent Disk (Disco permanente) (impostazione predefinita).

        2. Nell'elenco Disco, seleziona un disco permanente di zona esistente su cui vuoi montare per questo job. Il disco deve trovarsi nella stessa in questa zona.

          Ad esempio, seleziona il disco permanente a livello di zona esistente preparato, disponibile nel us-central1-a e contiene il file example.txt.

        3. (Facoltativo) Se vuoi rinominare questo disco permanente a livello di zona, procedi nel seguente modo:

          1. Seleziona Personalizza il nome del dispositivo.

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

        4. Nel campo Percorso di montaggio, inserisci il percorso di montaggio (MOUNT_PATH) per questo elemento un 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.

        5. Fai clic su Fine.

  6. (Facoltativo) Configura il altri campi per questo job.

  7. (Facoltativo) Per rivedere la configurazione del job, nel riquadro a sinistra fai clic su Anteprima.

  8. Fai clic su Crea.

Nella pagina Dettagli job viene visualizzato il job creato.

gcloud

Utilizzando gcloud CLI, l'esempio seguente crea un job che collega e monta un disco permanente esistente e un nuovo disco permanente. Il job prevede tre attività, ognuna delle quali esegue uno script per creare un file nella nuova 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 utilizza dischi permanenti usando il comando gcloud CLI, utilizza Comando gcloud batch jobs submit. Nel file di configurazione JSON del job, specifica i dischi permanenti nella instances e montare 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: il valore ID progetto del tuo progetto.
      • EXISTING_PERSISTENT_DISK_NAME: il nome di un disco permanente esistente.
      • EXISTING_PERSISTENT_DISK_LOCATION: il valore di un disco permanente esistente. Per ogni ambiente di zona disco permanente, la località del job deve essere la zona del disco. della ogni disco permanente a livello di regione esistente, la località del job deve essere la regione del disco o, se si specificano zone, uno o sia delle zone specifiche in cui in cui viene localizzato. Se non specifichi nessun valore permanente esistente i dischi permanenti, puoi selezionare qualsiasi località. Scopri di più sulle Campo allowedLocations:
      • NEW_PERSISTENT_DISK_SIZE: la dimensione del un nuovo disco permanente in GB. La dimensioni consentite dipendono dal tipo di disco permanente, ma il minimo è spesso 10 GB (10) e il massimo è spesso 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: il valore tipo di disco del nuovo disco permanente, pd-standard, pd-balanced, pd-ssd o pd-extreme. Il tipo di disco predefinito per non di avvio dei dischi permanenti è pd-standard.
      • NEW_PERSISTENT_DISK_NAME: il nome del nuovo disco permanente.

    • Se utilizzando un modello di istanza VM per questo job, creare un file JSON come mostrato in precedenza, ad eccezione della sostituzione del Campo instances con quanto segue:

      "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 dei dischi permanenti che vuoi utilizzare. Per questo esempio, il modello deve definire e collegare un nuovo disco permanente denominato NEW_PERSISTENT_DISK_NAME e e colleghi 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 lavoro.

    • 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. Il job prevede tre attività, ognuna delle quali esegue uno script per creare un file nella nuova un 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 utilizza dischi permanenti usando il comando API Batch, utilizza Metodo jobs.create. Nella richiesta, specifica i dischi permanenti nel instances e montare il disco permanente nel campo volumes.

  • Se non utilizzi un modello di istanza per questo job, effettua quanto segue: 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: il valore ID progetto del tuo progetto.
    • LOCATION: la località del lavoro.
    • JOB_NAME: il nome del job.
    • EXISTING_PERSISTENT_DISK_NAME: il nome di un disco permanente esistente.
    • EXISTING_PERSISTENT_DISK_LOCATION: il valore di un disco permanente esistente. Per ogni ambiente di zona disco permanente, la località del job deve essere la zona del disco. della ogni disco permanente a livello di regione esistente, la località del job deve essere la regione del disco o, se si specificano zone, uno o sia delle zone specifiche in cui in cui viene localizzato. Se non specifichi nessun valore permanente esistente i dischi permanenti, puoi selezionare qualsiasi località. Scopri di più sulle Campo allowedLocations:
    • NEW_PERSISTENT_DISK_SIZE: la dimensione del un nuovo disco permanente in GB. La dimensioni consentite dipendono dal tipo di disco permanente, ma il minimo è spesso 10 GB (10) e il massimo è spesso 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: il valore tipo di disco del nuovo disco permanente, pd-standard, pd-balanced, pd-ssd o pd-extreme. Il tipo di disco predefinito per non di avvio dei dischi permanenti è pd-standard.
    • NEW_PERSISTENT_DISK_NAME: il nome del nuovo disco permanente.

  • Se utilizzando un modello di istanza VM per questo job, creare un file JSON come mostrato in precedenza, ad eccezione della sostituzione del Campo instances con quanto segue:

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

    Dove si chiama INSTANCE_TEMPLATE_NAME del modello di istanza per questo job. Per un job che utilizza dischi permanenti, questo modello di istanza deve definire e collegare dei dischi permanenti che vuoi utilizzare. Per questo esempio, il modello deve definire e collegare un nuovo disco permanente denominato NEW_PERSISTENT_DISK_NAME e e colleghi un disco permanente esistente denominato EXISTING_PERSISTENT_DISK_NAME.

Vai

Per creare un job batch che utilizza dati nuovi o esistenti i dischi permanenti usando Librerie client di Cloud per Go, utilizza il Funzione CreateJob e includere quanto segue:

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

Java

Per creare un job batch che utilizza dati nuovi o esistenti i dischi permanenti usando Librerie client di Cloud per Java, utilizza CreateJobRequest corso e includere quanto segue:

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

Node.js

Per creare un job batch che utilizza dati nuovi o esistenti i dischi permanenti usando Librerie client Cloud per Node.js, utilizza Metodo createJob e includere quanto segue:

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

Python

Per creare un job batch che utilizza dati nuovi o esistenti i dischi permanenti usando Librerie client Cloud per Python, utilizza Funzione CreateJob e includere quanto segue:

  • Per collegare i dischi permanenti alle VM per un job, includi uno dei seguenti elementi:
  • Per montare i dischi permanenti nel job, utilizza la classe Volume corso con l'attributo device_name e mount_path. Per i nuovi dischi permanenti, utilizza anche Attributo mount_options per consentire la scrittura.

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

C++

Per creare un job batch che utilizza dati nuovi o esistenti i dischi permanenti usando Librerie client di Cloud per C++, utilizza Funzione CreateJob e includere quanto segue:

  • Per collegare i dischi permanenti alle VM per un job, includi uno dei seguenti elementi:
    • Se non utilizzi un modello di istanza VM per questo job, utilizza il metodo set_remote_path.
    • Se utilizzi un modello di istanza VM per questo job, utilizza set_instance_template.
  • Per montare i dischi permanenti nel job, utilizza il campo volumes con i campi deviceName e mountPath. Per i nuovi dischi permanenti, usa il campo mountOptions per abilitare la scrittura.

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

Usa un SSD locale

Un job che utilizza SSD locali ha le seguenti restrizioni:

Puoi creare un job che utilizza un SSD locale usando gcloud CLI o API Batch. L'esempio seguente descrive come creare un job che crea, allega e monta un SSD locale. Il lavoro prevede anche tre attività che ognuno esegua 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 gcloud CLI, utilizza Comando gcloud batch jobs submit. Nel file di configurazione JSON del job, crea e collega gli SSD locali nella 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 valore di un tipo di macchina, che può essere predefinita o personalizzato, delle VM del job. La numero consentito di SSD locali dipende dal tipo di macchina delle VM del 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, questo valore deve essere un multiplo di 375 GB. Per Ad esempio, per 2 SSD locali, imposta questo valore su 750 GB.

    • Se utilizzando un modello di istanza VM per questo job, creare un file JSON come mostrato in precedenza, ad eccezione della sostituzione del Campo instances con quanto segue:

      "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 utilizzare per il job. Per questo esempio, il modello deve definire e collegare un SSD locale denominato 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 lavoro.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizza gli SSD locali utilizzando API Batch, utilizza Metodo jobs.create. Nella richiesta, crea e collega gli SSD locali instances e montare le unità SSD locali nel campo volumes.

  • Se non utilizzi un modello di istanza per questo job, effettua quanto segue: 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: il valore ID progetto del tuo progetto.
    • LOCATION: la località del lavoro.
    • JOB_NAME: il nome del job.
    • MACHINE_TYPE: il valore di un tipo di macchina, che può essere predefinita o personalizzato, delle VM del job. La numero consentito di SSD locali dipende dal tipo di macchina delle VM del 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, questo valore deve essere un multiplo di 375 GB. Per Ad esempio, per 2 SSD locali, imposta questo valore su 750 GB.

  • Se utilizzando un modello di istanza VM per questo job, creare un file JSON come mostrato in precedenza, ad eccezione della sostituzione del Campo instances con quanto segue:

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

    Dove si chiama INSTANCE_TEMPLATE_NAME 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 utilizzare per il job. Per questo esempio, il modello deve definire e collegare un SSD locale denominato LOCAL_SSD_NAME.

usa un bucket Cloud Storage

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

  • Opzione consigliata: monta un bucket direttamente sulle VM del job specificando bucket nella definizione del job, come mostrato in questa sezione. Quando il job viene eseguito, il bucket viene montato automaticamente sulle VM per il tuo job utilizzando FUSE Cloud Storage.
  • Crea un lavoro con attività che accedono direttamente a un nel bucket Cloud Storage mediante lo strumento a riga di comando gsutil, oppure librerie client per l'API Cloud Storage. Per scoprire come accedere a un del bucket Cloud Storage direttamente da una VM, consulta 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, vedi Crea bucket e Elenca bucket.

Puoi creare un job che utilizza un bucket Cloud Storage utilizzando console Google Cloud, gcloud CLI, API Batch, Go, Java, Node.js, Python o C++.

L'esempio seguente descrive come creare un job che monta un nel bucket Cloud Storage. Il job include anche 3 attività che vengono eseguite 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 utilizza un bucket Cloud Storage mediante Nella console Google Cloud, segui questi passaggi:

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

    Vai all'elenco dei job

  2. Fai clic su Crea. La Si apre la pagina Crea job batch. Nel riquadro a sinistra, La pagina Dettagli job è selezionata.

  3. Configura la pagina Dettagli job:

    1. (Facoltativo) Nel campo Nome job, personalizza il nome del job.

      Ad esempio, inserisci example-bucket-job.

    2. Configura la sezione Dettagli attività:

      1. Nella finestra Nuovo eseguibile, aggiungi almeno uno script oppure container per l'esecuzione di questo job.

        Ad esempio, procedi nel seguente modo:

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

        2. Nella casella di testo, inserisci il seguente script:

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

          Sostituisci MOUNT_PATH con di montaggio usato dagli eseguibili di questo job per accedere a nel bucket Cloud Storage esistente. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso che scegli. Ad esempio, se vuoi rappresentare questo bucket con una directory denominata my-bucket, imposta percorso di montaggio in /mnt/disks/my-bucket.

        3. Fai clic su Fine.

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

        Ad esempio, inserisci 3.

      3. Nel campo Parallelismo, inserisci il numero di attività da contemporaneamente.

        Ad esempio, inserisci 1 (valore predefinito).

  4. Configura la pagina Configurazioni aggiuntive:

    1. Nel riquadro a sinistra, fai clic su Configurazioni aggiuntive. Si apre la pagina Configurazioni aggiuntive.

    2. Per ogni bucket Cloud Storage su cui vuoi montare questo lavoro:

      1. Nella sezione Volume spazio di archiviazione, fai clic su Aggiungi nuovo volume. Viene visualizzata la finestra Nuovo volume.

      2. Nella finestra Nuovo volume:

        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 in il job è eseguibile.

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

        4. Fai clic su Fine.

  5. (Facoltativo) Configura il altri campi per questo job.

  6. (Facoltativo) Per rivedere la configurazione del job, nel riquadro a sinistra fai clic su Anteprima.

  7. Fai clic su Crea.

Nella pagina Dettagli job viene visualizzato il job creato.

gcloud

Per creare un job che utilizza un bucket Cloud Storage mediante gcloud CLI, utilizza Comando gcloud batch jobs submit. Nel file di configurazione JSON del job, monta il bucket 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 del bucket a cui vuoi accedere il job, che deve iniziare con il nome nel bucket. Ad esempio, per un bucket denominato BUCKET_NAME, il percorso BUCKET_NAME rappresenta la directory radice del bucket e il percorso BUCKET_NAME/subdirectory rappresenta la sottodirectory subdirectory.
    • MOUNT_PATH: il percorso di montaggio del job per accedere a questo bucket. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso a tua scelta. Per 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 lavoro.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizza un bucket Cloud Storage mediante API Batch, utilizza Metodo jobs.create e montare 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: il valore ID progetto del tuo progetto.
  • LOCATION: la località del lavoro.
  • JOB_NAME: il nome del job.
  • BUCKET_PATH: il percorso della directory del 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 radice del bucket e il percorso BUCKET_NAME/subdirectory rappresenta la sottodirectory subdirectory.
  • MOUNT_PATH: il percorso di montaggio del job per accedere a questo bucket. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso a tua scelta. Ad esempio, se vuoi rappresentare questo bucket con una denominata my-bucket, imposta il percorso di montaggio su /mnt/disks/my-bucket.

Vai

Go

Per ulteriori informazioni, consulta API Go Batch documentazione di riferimento.

Per eseguire l'autenticazione in modalità batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 ulteriori informazioni, consulta API Java Batch documentazione di riferimento.

Per eseguire l'autenticazione in modalità batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 ulteriori informazioni, consulta API Node.js Batch documentazione di riferimento.

Per eseguire l'autenticazione in modalità batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 ulteriori informazioni, consulta API Python Batch documentazione di riferimento.

Per eseguire l'autenticazione in modalità batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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)

C++

C++

Per ulteriori informazioni, consulta API C++ Batch documentazione di riferimento.

Per eseguire l'autenticazione in modalità batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id, std::string const& bucket_name) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it, and then override the GCS remote path.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Utilizza un file system di rete

Puoi creare un job che utilizza un file system di rete (NFS) esistente, ad esempio un Condivisione file Filestore, utilizzando la console Google Cloud, gcloud CLI API Batch.

Prima di creare un job che utilizza una NFS, assicurati che il firewall della rete è configurato correttamente per consentire il traffico tra e NFS del job. Per ulteriori informazioni, vedi Configurazione delle regole firewall per Filestore.

L'esempio seguente descrive come creare un job che specifichi e monta un NFS. Il job ha anche 3 attività in cui ognuna esegue uno script per creare un file in 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 utilizza una NFS utilizzando la console Google Cloud, procedi nel seguente modo:

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

    Vai all'elenco dei job

  2. Fai clic su Crea. La Si apre la pagina Crea job batch. Nel riquadro a sinistra, La pagina Dettagli job è selezionata.

  3. Configura la pagina Dettagli job:

    1. (Facoltativo) Nel campo Nome job, personalizza il nome del job.

      Ad esempio, inserisci example-nfs-job.

    2. Configura la sezione Dettagli attività:

      1. Nella finestra Nuovo eseguibile, aggiungi almeno uno script oppure container per l'esecuzione di questo job.

        Ad esempio, procedi nel seguente modo:

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

        2. Nella casella di testo, inserisci il seguente script:

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

          Sostituisci MOUNT_PATH con percorso di montaggio utilizzato dal job eseguibile per accedere a questa NFS. Il percorso deve iniziare con /mnt/disks/ seguito da un una directory o un percorso che scegli. 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.

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

        Ad esempio, inserisci 3.

      3. Nel campo Parallelismo, inserisci il numero di attività da contemporaneamente.

        Ad esempio, inserisci 1 (valore predefinito).

  4. Configura la pagina Configurazioni aggiuntive:

    1. Nel riquadro a sinistra, fai clic su Configurazioni aggiuntive. Si apre la pagina Configurazioni aggiuntive.

    2. Per ogni bucket Cloud Storage su cui vuoi montare questo lavoro:

      1. Nella sezione Volume spazio di archiviazione, fai clic su Aggiungi nuovo volume. Viene visualizzata la finestra Nuovo volume.

      2. Nella finestra Nuovo volume:

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

        2. Nel campo File server, inserisci l'indirizzo IP del server in cui le NFS specificate nel job sono eseguibili in cui viene localizzato.

          Ad esempio, se la tua NFS è un condivisione file Filestore, devi specificare l'indirizzo IP di Filestore un'istanza, che puoi ottenere descrivi l'istanza Filestore.

        3. Nel campo Percorso remoto, inserisci un percorso a cui è possibile accedere alla funzione NFS specificata nel passaggio precedente.

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

        4. Nel campo Percorso di montaggio, inserisci il percorso di montaggio su NFS (MOUNT_PATH), che hai specificato in al passaggio precedente.

    3. Fai clic su Fine.

  5. (Facoltativo) Configura il altri campi per questo job.

  6. (Facoltativo) Per rivedere la configurazione del job, nel riquadro a sinistra fai clic su Anteprima.

  7. Fai clic su Crea.

Nella pagina Dettagli job viene visualizzato il job creato.

gcloud

Per creare un job che utilizza una NFS utilizzando gcloud CLI, utilizza Comando gcloud batch jobs submit. Nel file di configurazione JSON del job, monta la NFS nella 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: il valore Indirizzo IP della NFS. Ad esempio, se NFS è una condivisione file di Filestore, quindi specifica l'indirizzo IP del server di archiviazione un'istanza, che puoi ottenere descrivi l'istanza Filestore.
    • NFS_PATH: il percorso della directory NFS a cui vuoi accedere questo job, che deve iniziare con un / seguito dalla directory radice della NFS. Ad esempio, per un Condivisione file Filestore denominata FILE_SHARE_NAME, il percorso /FILE_SHARE_NAME rappresenta la radice directory della condivisione file e il percorso /FILE_SHARE_NAME/subdirectory rappresenta la sottodirectory subdirectory.
    • MOUNT_PATH: il percorso di montaggio del job i runnable usano per accedere a questa NFS. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso a tua scelta. Ad esempio, se vuoi rappresentare questo NFS con un 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 lavoro.
    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Per creare un job che utilizza una NFS utilizzando API Batch, utilizza Metodo jobs.create e montare la 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: il valore ID progetto del tuo progetto.
  • LOCATION: la località del lavoro.
  • JOB_NAME: il nome del job.
  • NFS_IP_ADDRESS: il valore Indirizzo IP del file system di rete. Ad esempio, se NFS è una condivisione file di Filestore, quindi specifica l'indirizzo IP del server di archiviazione un'istanza, che puoi ottenere descrivi l'istanza Filestore.
  • NFS_PATH: il percorso della directory NFS a cui vuoi accedere questo job, che deve iniziare con un / seguito dalla directory radice della NFS. Ad esempio, per un Condivisione file Filestore denominata FILE_SHARE_NAME, il percorso /FILE_SHARE_NAME rappresenta la radice directory della condivisione file e il percorso /FILE_SHARE_NAME/subdirectory rappresenta una sottodirectory.
  • MOUNT_PATH: il percorso di montaggio del job i runnable usano per accedere a questa NFS. Il percorso deve iniziare con /mnt/disks/ seguito da una directory o da un percorso a tua scelta. Ad esempio, se vuoi rappresentare questo NFS con un denominata my-nfs, imposta il percorso di montaggio su /mnt/disks/my-nfs.

Passaggi successivi