Cette page a été traduite par l'API Cloud Translation.

Exécuter un job par lot à l'aide de Workflows

Batch est un service entièrement géré qui vous permet de planifier, mettre en file d'attente et exécuter des charges de travail de traitement par lot sur des instances de machines virtuelles (VM) Compute Engine. Batch provisionne les ressources et gère la capacité en votre nom, ce qui permet à vos charges de travail par lot de s'exécuter à grande échelle.

Workflows vous permet d'exécuter les services dont vous avez besoin dans un ordre que vous définissez et décrit à l'aide de la syntaxe Workflows.

Dans ce tutoriel, vous utilisez le connecteur Workflows pour Batch pour planifier et exécuter un job par lot qui exécute six tâches en parallèle sur deux VM Compute Engine. L'utilisation de lots et de workflows vous permet de combiner les avantages qu'ils offrent, et de provisionner et d'orchestrer efficacement l'ensemble du processus.

Objectifs

Au cours de ce tutoriel, vous allez :

Créer un dépôt Artifact Registry pour une image de conteneur Docker
Récupérez sur GitHub le code pour la charge de travail de traitement par lot,un exemple de programme qui génère des nombres premiers par lots de 10 000.
Créer l'image Docker de la charge de travail
Déployez et exécutez un workflow qui :
1. Crée un bucket Cloud Storage pour stocker les résultats du générateur de nombres premiers.
2. Planifie et exécute un job par lot qui exécute le conteneur Docker sous la forme de six tâches en parallèle sur deux VM Compute Engine.
3. Supprime le job par lot une fois celui-ci terminé.
Vérifiez que les résultats sont conformes aux attentes et que les lots de nombres premiers générés sont stockés dans Cloud Storage.

Vous pouvez exécuter la plupart des commandes suivantes dans la console Google Cloud, ou toutes les exécuter à l'aide de la Google Cloud CLI dans votre terminal ou dans Cloud Shell.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

Les contraintes de sécurité définies par votre organisation peuvent vous empêcher d'effectuer les étapes suivantes. Pour obtenir des informations de dépannage, consultez la page Développer des applications dans un environnement Google Cloud limité.

Console

Dans la console Google Cloud, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu d'en sélectionner un existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder au sélecteur de projet
Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.
Activez les API Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions et Workflows.

Activer les API
Créez un compte de service que votre workflow utilisera pour l'authentification auprès d'autres services Google Cloud et attribuez-lui les rôles appropriés:
1. Dans la console Google Cloud, accédez à la page Créer un compte de service.
  
  Accéder à la page "Créer un compte de service"
2. Sélectionnez votre projet.
3. Dans le champ Nom du compte de service, saisissez un nom. La console Google Cloud remplit le champ ID du compte de service en fonction de ce nom.
  
  Dans le champ Description du compte de service, saisissez une description. Exemple : Service account for tutorial.
4. Cliquez sur Créer et continuer.
5. Dans la liste Sélectionner un rôle, filtrez les rôles suivants à attribuer au compte de service géré par l'utilisateur que vous avez créé à l'étape précédente:
  - Éditeur de jobs par lot: permet de modifier des jobs par lot.
  - Rédacteur de journaux: permet d'écrire des journaux.
  - Administrateur Storage: pour contrôler les ressources Cloud Storage.
  Pour ajouter des rôles supplémentaires, cliquez sur Ajouter un autre rôle et ajoutez chaque rôle supplémentaire.
  
  Remarque :Le champ Rôle détermine les ressources auxquelles votre compte de service peut accéder dans votre projet. Vous pouvez révoquer ces rôles ou attribuer des rôles supplémentaires ultérieurement. Dans les environnements de production, n'accordez pas les rôles de propriétaire, d'éditeur ou de lecteur. Accordez plutôt un rôle prédéfini ou un rôle personnalisé qui répond à vos besoins.
6. Cliquez sur Continuer.
7. Pour terminer la création du compte, cliquez sur OK.
Attribuez le rôle Utilisateur du compte de service IAM sur le compte de service par défaut au compte de service géré par l'utilisateur créé à l'étape précédente. Une fois l'API Compute Engine activée, le compte de service par défaut est celui par défaut de Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com). L'autorisation est généralement attribuée via le rôle roles/iam.serviceAccountUser.

Attention :L'attribution du rôle Utilisateur du compte de service attribue indirectement le rôle associé au compte de service par défaut à l'utilisateur. Par exemple, si le compte de service par défaut dispose du rôle Éditeur, l'utilisateur peut alors "agir en tant qu'éditeur". Pour minimiser l'impact de ces attributions de rôles, nous vous recommandons de configurer le compte de service par défaut selon le principe du moindre privilège. Pour en savoir plus, consultez la section Désactiver l'attribution automatique de rôles aux comptes de service par défaut.
1. Sur la page Comptes de service, cliquez sur l'adresse e-mail du compte de service par défaut (PROJECT_NUMBER-compute@developer.gserviceaccount.com).
2. Cliquez sur l'onglet Autorisations.
3. Cliquez sur le bouton Accorder l'accès .
4. Pour ajouter un compte principal, saisissez l'adresse e-mail de votre compte de service (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com).
5. Dans la liste Sélectionner un rôle, sélectionnez le rôle Comptes de service > Utilisateur du compte de service.
6. Cliquez sur Enregistrer.

gcloud

Dans la console Google Cloud, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de la console Google Cloud, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Activez les API Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions et Workflows.

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

Créez un compte de service que votre workflow utilisera pour l'authentification auprès d'autres services Google Cloud et attribuez-lui les rôles appropriés.
1. Créez le compte de service :
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Remplacez SERVICE_ACCOUNT_NAME par le nom du compte de service.
2. Attribuez des rôles au compte de service géré par l'utilisateur que vous avez créé à l'étape précédente. Exécutez la commande suivante une fois pour chacun des rôles IAM suivants:
  - roles/batch.jobsEditor: permet de modifier des jobs par lot.
  - roles/logging.logWriter: permet d'écrire des journaux.
  - roles/storage.admin: permet de contrôler les ressources Cloud Storage.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=ROLE
```
  Remplacez les éléments suivants :
  - PROJECT_ID: ID du projet dans lequel vous avez créé le compte de service.
  - ROLE : rôle à accorder
  Remarque :L'option --role affecte les ressources auxquelles votre compte de service peut accéder dans votre projet. Vous pouvez révoquer ces rôles ou attribuer des rôles supplémentaires ultérieurement. Dans les environnements de production, n'accordez pas les rôles de propriétaire, d'éditeur ou de lecteur. Accordez plutôt un rôle prédéfini ou un rôle personnalisé qui répond à vos besoins.
Attribuez le rôle Utilisateur du compte de service IAM sur le compte de service par défaut au compte de service géré par l'utilisateur que vous avez créé à l'étape précédente. Une fois l'API Compute Engine activée, le compte de service par défaut est le compte de service Compute Engine par défaut (PROJECT_NUMBER-compute@developer.gserviceaccount.com). L'autorisation est généralement attribuée via le rôle roles/iam.serviceAccountUser.

Attention :L'attribution du rôle Utilisateur du compte de service attribue indirectement le rôle associé au compte de service par défaut à l'utilisateur. Par exemple, si le compte de service par défaut dispose du rôle Éditeur, l'utilisateur peut alors "agir en tant qu'éditeur". Pour minimiser l'impact de ces attributions de rôles, nous vous recommandons de configurer le compte de service par défaut selon le principe du moindre privilège. Pour en savoir plus, consultez la section Désactiver l'attribution automatique de rôles aux comptes de service par défaut.
```
PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
gcloud iam service-accounts add-iam-policy-binding \
  $PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountUser
```

Créer un dépôt Artifact Registry

Créez un dépôt pour stocker votre image de conteneur Docker.

Console

Dans la console Google Cloud, accédez à la page Dépôts.

Accédez aux dépôts.
Cliquez sur Créer un dépôt.
Saisissez containers comme nom de dépôt.
Dans le champ Format, choisissez Docker.
Pour Type d'emplacement, sélectionnez Région.
Dans la liste Région, sélectionnez us-central1.
Cliquez sur Créer.

gcloud

Exécutez la commande ci-dessous.

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

Vous avez créé un dépôt Artifact Registry nommé containers dans la région us-central1. Pour en savoir plus sur les régions compatibles, consultez la page Emplacements Artifact Registry.

Obtenir les exemples de code

Google Cloud stocke le code source de l'application pour ce tutoriel dans GitHub. Vous pouvez cloner ce dépôt ou télécharger les exemples.

Clonez le dépôt de l'exemple d'application sur votre ordinateur local :
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
Vous pouvez également télécharger les exemples dans le fichier main.zip et les extraire.
Accédez au répertoire qui contient l'exemple de code :
```
cd batch-samples/primegen
```

Vous disposez maintenant du code source de l'application dans votre environnement de développement.

Créer l'image Docker à l'aide de Cloud Build

Le fichier Dockerfile contient les informations nécessaires à la création d'une image Docker à l'aide de Cloud Build. Exécutez la commande suivante pour le compiler:

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

Remplacez PROJECT_ID par l'ID de votre projet Google Cloud.

Une fois la compilation terminée, un résultat semblable aux lignes suivantes doit s'afficher:

DONE
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID: a54818cc-5d14-467b-bfda-5fc9590af68c
CREATE_TIME: 2022-07-29T01:48:50+00:00
DURATION: 48S
SOURCE: gs://project-name_cloudbuild/source/1659059329.705219-17aee3a424a94679937a7200fab15bcf.tgz
IMAGES: us-central1-docker.pkg.dev/project-name/containers/primegen-service:v1
STATUS: SUCCESS

À l'aide d'un Dockerfile, vous avez créé une image Docker nommée primegen-service et l'avez transférée vers un dépôt Artifact Registry nommé containers.

Déployer un workflow qui planifie et exécute un job par lot

Le workflow suivant planifie et exécute un job par lot qui exécute un conteneur Docker sous la forme de six tâches en parallèle sur deux VM Compute Engine. Le résultat est la génération de six lots de nombres premiers, stockés dans un bucket Cloud Storage.

Console

Dans la console Google Cloud, accédez à la page Workflows.

Accéder à "Workflows"
Cliquez sur Créer.
Saisissez un nom pour le nouveau workflow, par exemple batch-workflow.
Dans la liste Région, sélectionnez us-central1.
Sélectionnez le compte de service que vous avez créé précédemment.
Cliquez sur Suivant.

Dans l'éditeur de workflow, saisissez la définition suivante pour votre workflow:

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Cliquez sur Deploy (Déployer).

gcloud

Créez un fichier de code source pour votre workflow:
```
touch batch-workflow.JSON_OR_YAML
```
Remplacez JSON_OR_YAML par yaml ou json selon le format de votre workflow.

Dans un éditeur de texte, copiez le workflow suivant dans votre fichier de code source:

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Déployez le workflow en saisissant la commande suivante :

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

Remplacez SERVICE_ACCOUNT_NAME par le nom du compte de service que vous avez créé précédemment.

Exécuter le workflow

L'exécution d'un workflow exécute la définition actuelle du workflow associé au workflow.

Console

Dans la console Google Cloud, accédez à la page Workflows.

Accéder à "Workflows"
Sur la page Workflows, cliquez sur le workflow par lot pour accéder à sa page d'informations.
Sur la page Détails du workflow, cliquez sur Exécuter.
Cliquez à nouveau sur Exécuter.

L'exécution du workflow devrait prendre quelques minutes.

Remarque :Si vous rencontrez une erreur IAM permission denied for service account au cours de l'étape createBucket, cela est probablement dû à un retard de propagation. Attendez une minute ou deux, puis réessayez d'exécuter le workflow.
Affichez les résultats du workflow dans le volet Output (Résultat).

Le résultat doit ressembler à ce qui suit :
```
{
  "bucket": "project-name-job-primegen-TIMESTAMP",
  "jobId": "job-primegen-TIMESTAMP"
}
```

gcloud

Exécutez le workflow :
```
gcloud workflows run batch-workflow \
  --location=us-central1
```
L'exécution du workflow devrait prendre quelques minutes.

Remarque :Si vous rencontrez une erreur IAM permission denied for service account au cours de l'étape createBucket, cela est probablement dû à un retard de propagation. Attendez une minute ou deux, puis réessayez d'exécuter le workflow.
Vous pouvez vérifier l'état d'une exécution de longue durée.

Pour obtenir l'état de la dernière exécution terminée, exécutez la commande suivante:

gcloud workflows executions describe-last

Les résultats doivent ressembler à ce qui suit:

name: projects/PROJECT_NUMBER/locations/us-central1/workflows/batch-workflow/executions/EXECUTION_ID
result: '{"bucket":"project-name-job-primegen-TIMESTAMP","jobId":"job-primegen-TIMESTAMP"}'
startTime: '2022-07-29T16:08:39.725306421Z'
state: SUCCEEDED
status:
  currentSteps:
  - routine: main
    step: returnResult
workflowRevisionId: 000001-9ba

Lister les objets dans le bucket de sortie

Vous pouvez vérifier que les résultats sont conformes à vos attentes en répertoriant les objets présents dans votre bucket de sortie Cloud Storage.

Console

Dans la console Google Cloud, accédez à la page Buckets Cloud Storage.

Accéder à la page "Buckets"
Dans la liste des buckets, cliquez sur le nom du bucket dont vous souhaitez afficher le contenu.

Les résultats devraient être semblables à ce qui suit, avec six fichiers au total, chacun contenant un lot de 10 000 nombres premiers:
```
primes-1-10000.txt
primes-10001-20000.txt
primes-20001-30000.txt
primes-30001-40000.txt
primes-40001-50000.txt
primes-50001-60000.txt
```

gcloud

Récupérez le nom de votre bucket de sortie :
```
gsutil ls
```
Le résultat ressemble à ce qui suit :
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Listez les objets d'un bucket :

gsutil ls -r gs://PROJECT_ID-job-primegen-TIMESTAMP/**

Remplacez TIMESTAMP par l'horodatage renvoyé par la commande précédente.

Le résultat doit ressembler à ce qui suit, avec six fichiers au total, chacun contenant un lot de 10 000 nombres premiers:

gs://project-name-job-primegen-TIMESTAMP/primes-1-10000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-10001-20000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-20001-30000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-30001-40000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-40001-50000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-50001-60000.txt

Effectuer un nettoyage

Si vous avez créé un projet pour ce tutoriel, supprimez-le. Si vous avez utilisé un projet existant et que vous souhaitez le conserver sans les modifications du présent tutoriel, supprimez les ressources créées pour ce tutoriel.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources créées dans ce tutoriel

Supprimez le job par lot:

Commencez par récupérer le nom du job:

gcloud batch jobs list --location=us-central1

La sortie devrait ressembler à ce qui suit :

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

Où job-primegen-TIMESTAMP est le nom de la tâche par lot.

Supprimez la tâche:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

Supprimez le workflow:
```
gcloud workflows delete WORKFLOW_NAME
```

Supprimez le dépôt de conteneurs:

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

Cloud Build utilise Cloud Storage pour stocker les ressources de compilation. Pour supprimer un bucket Cloud Storage, consultez la page Supprimer des buckets.

Exécuter un job par lot à l'aide de Workflows

Objectifs

Coûts

Avant de commencer

Console

gcloud

Créer un dépôt Artifact Registry

Console

gcloud

Obtenir les exemples de code

Créer l'image Docker à l'aide de Cloud Build

Déployer un workflow qui planifie et exécute un job par lot

Console

YAML

JSON

gcloud

YAML

JSON

Exécuter le workflow

Console

gcloud

Lister les objets dans le bucket de sortie

Console

gcloud

Effectuer un nettoyage

Supprimer le projet

Supprimer les ressources créées dans ce tutoriel

Étapes suivantes