Créer et exécuter des jobs par lot à l'aide de Terraform et de Cloud Scheduler

Ce tutoriel explique comment utiliser Terraform pour créer et exécuter des jobs par lot à l'aide d'une job Cron Cloud Scheduler.

Terraform est un outil Open Source qui vous permet de provisionner et de gérer l'infrastructure en spécifiant l'état souhaité dans les fichiers de configuration. Ces fichiers peuvent être traités comme du code et stockés dans des systèmes de contrôle des versions tels que GitHub.

Bien que Terraform ne dispose pas de ressources pour Batch, ce tutoriel vous explique comment utiliser Terraform pour créer des jobs par lot. Plus précisément, vous pouvez utiliser Terraform pour planifier et exécuter une job Cron Cloud Scheduler qui cible l'API Batch afin de créer et d'exécuter des tâches par lot. Cloud Scheduler est un service Google Cloud qui vous permet de programmer automatiquement des tâches Cron et est compatible avec Terraform.

Ce tutoriel est destiné aux utilisateurs de Batch qui gèrent déjà une infrastructure avec Terraform et qui souhaitent incorporer des jobs par lots dans Terraform.

Objectifs

Créer un répertoire Terraform et un fichier de configuration qui définit une job Cron Cloud Scheduler permettant de créer des tâches par lot
Déployez la configuration Terraform pour exécuter le job Cron.
Vérifiez que le job Cron crée des jobs par lot.
Mettez à jour la configuration Terraform pour suspendre la job Cron afin qu'elle arrête de créer des tâches par lot.

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.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Préparez votre environnement de développement (Cloud Shell ou une interface système locale) :
Cloud Shell

Pour utiliser un terminal en ligne avec gcloud CLI et Terraform déjà configurés, activez Cloud Shell.

En bas de cette page, une session Cloud Shell démarre et affiche une invite de ligne de commande. L'initialisation de la session peut prendre quelques secondes.
Shell local

Pour utiliser un environnement de développement local, procédez comme suit :
1. Installez Google Cloud CLI.
2. Pour initialiser gcloudCLI, exécutez la commande suivante :
```
gcloud init
```
3. Installez Terraform.
Créez ou sélectionnez 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 de sélectionner un projet 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.
- Créez un projet Google Cloud :
```
gcloud projects create PROJECT_ID
```
  Remplacez PROJECT_ID par le nom du projet Google Cloud que vous créez.
- Sélectionnez le projet Google Cloud que vous avez créé :
```
gcloud config set project PROJECT_ID
```
  Remplacez PROJECT_ID par le nom de votre projet Google Cloud.
Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API Batch, Compute Engine, Cloud Logging, Cloud Scheduler, and Resource Manager :
```
gcloud services enable batch.googleapis.com compute.googleapis.com logging.googleapis.com  cloudscheduler.googleapis.com cloudresourcemanager.googleapis.com
```
Assurez-vous que votre projet comporte au moins un compte de service disposant des autorisations requises pour ce tutoriel.

Remarque:Si vous utilisez un nouveau projet, cette étape n'est pas nécessaire sauf si votre organisation empêche l'attribution automatique de rôles pour les comptes de service par défaut. Par défaut, le compte de service Compute Engine par défaut reçoit automatiquement le rôle IAM Éditeur (roles/editor), qui dispose déjà de toutes les autorisations requises pour ce tutoriel.

Plus précisément, vous pouvez utiliser le même compte de service ou deux comptes de service distincts pour accorder les autorisations suivantes:
- Autorisez le job Cron à créer des jobs Batch et associez le compte de service à ces jobs.
- Autorisez les jobs Batch à créer des ressources et à y accéder.
Pour vous assurer que les comptes de service de ce tutoriel disposent des autorisations nécessaires pour utiliser Terraform afin de créer des jobs par lot via une job Cron Cloud Scheduler, demandez à votre administrateur d'attribuer les rôles IAM suivants au(x) compte(s) de service pour ce tutoriel:
- Compte de service pour la job Cron Cloud Scheduler :
  - Éditeur de tâches par lot (roles/batch.jobsEditor) sur le projet
  - Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service des jobs Batch (même s'il s'agit de lui-même)
- Compte de service pour les jobs Batch :
  - Auteur du signalement de l'agent par lot (roles/batch.agentReporter) au niveau du projet
  - Rédacteur de journaux (roles/logging.logWriter) sur le projet
Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Votre administrateur peut également accorder aux comptes de service pour ce tutoriel les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.
Assurez-vous de disposer des autorisations nécessaires pour ce tutoriel.

Remarque:Si vous avez créé ce projet, cette étape n'est pas nécessaire. En tant que créateur du projet, le rôle IAM Propriétaire (roles/owner) vous est automatiquement attribué, qui dispose déjà de toutes les autorisations requises pour ce tutoriel.

Plus précisément, vous devez disposer des autorisations nécessaires pour effectuer les opérations suivantes:
- Créez une job Cron et associez-y le compte de service.
- Affichez et supprimez les job Cron et les jobs Batch.
Afin d'obtenir les autorisations dont vous avez besoin pour utiliser Terraform afin de créer des jobs Batch via une job Cron Cloud Scheduler, demandez à votre administrateur de vous attribuer les rôles IAM suivants:
- Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service pour la job Cron Cloud Scheduler
- Administrateur Cloud Scheduler (roles/cloudscheduler.admin) pour le projet
- Éditeur de tâches par lot (roles/batch.jobsEditor) sur le projet
- Lecteur de journaux (roles/logging.viewer) sur le projet

Créer le répertoire Terraform et le fichier de configuration

Créez un répertoire pour Terraform et un fichier de configuration qui définit les ressources que vous souhaitez créer ou mettre à jour à l'aide de Terraform. L'exemple de fichier de configuration utilisé pour ce tutoriel définit une job Cron Cloud Scheduler nommée batch-job-invoker. Lorsque cette option est activée, la tâche Cron batch-job-invoker s'exécute toutes les cinq minutes pour créer une instance du job Batch défini.

Pour créer un répertoire et un fichier de configuration Terraform (.tf) dans ce répertoire, saisissez la commande suivante, puis appuyez sur Enter:
```
mkdir terraform && cd terraform && cat > main.tf
```
Cette commande crée le répertoire terraform, vous y accède et commence à définir un nouveau fichier de configuration main.tf sur la ligne suivante.

Copiez et collez la configuration Terraform suivante:

# define variables
variable "project_id" {
  type        = string
  description = "The project name to use."
  default = "PROJECT_ID"
}

variable "project_number" {
  type        = string
  description = "The project number to use."
  default = "PROJECT_NUMBER"
}

variable "region" {
  type        = string
  description = "The region where resources are created."
  default = "us-central1"
}

variable "cloud_scheduler_service_account_email" {
  type        = string
  description = "The service account email."
  default = "CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL"
}

variable "batch_service_account_email" {
  type        = string
  description = "The service account email."
  default = "BATCH_SERVICE_ACCOUNT_EMAIL"
}

# define a Cloud Scheduler cron job which triggers Batch jobs
resource "google_cloud_scheduler_job" "batch-job-invoker" {
  paused           = false # this cron job is enabled
  name             = "batch-job-invoker"
  project          = var.project_id
  region           = var.region
  schedule         = "*/5 * * * *" # when enabled, run every 5 minutes
  time_zone        = "America/Los_Angeles"
  attempt_deadline = "180s"

  retry_config {
    max_doublings        = 5
    max_retry_duration   = "0s"
    max_backoff_duration = "3600s"
    min_backoff_duration = "5s"
  }

  # when this cron job runs, create and run a Batch job
  http_target {
    http_method = "POST"
    uri = "https://batch.googleapis.com/v1/projects/${var.project_number}/locations/${var.region}/jobs"
    headers = {
      "Content-Type" = "application/json"
      "User-Agent"   = "Google-Cloud-Scheduler"
    }
    # Batch job definition
    body = base64encode(<<EOT
    {
      "taskGroups":[
        {
          "taskSpec": {
            "runnables":{
              "script": {
                "text": "echo Hello world! This job was created using Terraform and Cloud Scheduler."
              }
            }
          }
        }
      ],
      "allocationPolicy": {
        "serviceAccount": {
          "email": "${var.batch_service_account_email}"
        }
      },
      "labels": {
        "source": "terraform_and_cloud_scheduler_tutorial"
      },
      "logsPolicy": {
        "destination": "CLOUD_LOGGING"
      }
    }
    EOT
    )
    oauth_token {
      scope                 = "https://www.googleapis.com/auth/cloud-platform"
      service_account_email = var.cloud_scheduler_service_account_email
    }
  }
}

Remplacez les éléments suivants :

PROJECT_ID: ID de projet de votre projet.
PROJECT_NUMBER: numéro de votre projet
CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL: adresse e-mail du compte de service que vous avez préparé pour la job Cron Cloud Scheduler.

Par exemple, pour utiliser le compte de service Compute Engine par défaut, spécifiez les éléments suivants:
```
PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
BATCH_SERVICE_ACCOUNT_EMAIL: adresse e-mail du compte de service que vous avez préparé pour les tâches Batch.

Par exemple, pour utiliser le compte de service Compute Engine par défaut, spécifiez les éléments suivants:
```
PROJECT_NUMBER-compute@developer.gserviceaccount.com
```

Cette configuration Terraform définit certaines variables d'entrée et une job Cron qui contacte la méthode API permettant de créer un job par lot.

Pour enregistrer et fermer le fichier, appuyez sur Ctrl+D (ou Command+D sous macOS).

Déployer la configuration Terraform pour créer le job Cron

Déployez la configuration Terraform en initialisant Terraform, en générant les modifications planifiées et en appliquant ces modifications. Après avoir déployé la configuration Terraform, vous pouvez décrire les ressources de votre projet pour vérifier que Terraform a bien créé la job Cron batch-job-invoker.

Initialisez Terraform dans le répertoire:

terraform init

Le résultat ressemble à ce qui suit :

...
Terraform has been successfully initialized!

You may now begin working with Terraform. Try running "terraform plan" to see
any changes that are required for your infrastructure. All Terraform commands
should now work.

If you ever set or change modules or backend configuration for Terraform,
rerun this command to reinitialize your working directory. If you forget, other
commands will detect it and remind you to do so if necessary.

Générez le plan d'exécution Terraform en fonction de l'état actuel de votre projet et du fichier de configuration:

terraform plan

Le résultat ressemble à ce qui suit, qui indique que l'objectif est de créer la job Cron batch-job-invoker:

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

  # google_cloud_scheduler_job.batch-job-invoker will be created
  + resource "google_cloud_scheduler_job" "batch-job-invoker" {
      + id        = (known after apply)
      + name      = "batch-job-invoker"
      + paused    = false
      + project   = "PROJECT_ID"
      + region    = "us-central1"
      + schedule  = "*/5 * * * *"
      + state     = (known after apply)
      + time_zone = "America/Los_Angeles"

      + http_target {
          + body        = "..."
          + headers     = {
              + "Content-Type" = "application/json"
              + "User-Agent"   = "Google-Cloud-Scheduler"
            }
          + http_method = "POST"
          + uri         = "https://batch.googleapis.com/v1/projects/PROJECT_NUMBER/locations/us-central1/jobs"

          + oauth_token {
              + scope                 = "https://www.googleapis.com/auth/cloud-platform"
              + service_account_email = "CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL"
            }
        }

      + retry_config {
          + max_backoff_duration = "3600s"
          + max_doublings        = 5
          + max_retry_duration   = "0s"
          + min_backoff_duration = "5s"
          + retry_count          = (known after apply)
        }
    }

Plan: 1 to add, 0 to change, 0 to destroy.

───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

Pour appliquer le plan permettant de créer la job Cron batch-job-invoker, procédez comme suit:
1. Saisissez la commande suivante :
```
terraform apply
```
  Le résultat est semblable à la commande terraform plan précédente, sauf qu'elle se termine par une invite de confirmation.
2. Pour confirmer et appliquer le plan, saisissez yes.
  
  Le résultat ressemble à ce qui suit :
```
google_cloud_scheduler_job.batch-job-invoker: Creating...
google_cloud_scheduler_job.batch-job-invoker: Creation complete after 0s [id=projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker]

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.
```

Pour vérifier que la job Cron batch-job-invoker existe et qu'elle est activée, décrivez-la:

gcloud scheduler jobs describe batch-job-invoker --location us-central1

Le résultat ressemble à ce qui suit :

attemptDeadline: 180s
httpTarget:
  body: ...
  headers:
    Content-Type: application/json
    User-Agent: Google-Cloud-Scheduler
  httpMethod: POST
  oauthToken:
    scope: https://www.googleapis.com/auth/cloud-platform
    serviceAccountEmail: CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL
  uri: https://batch.googleapis.com/v1/projects/PROJECT_NUMBER/locations/us-central1/jobs
lastAttemptTime: '...'
name: projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker
retryConfig:
  maxBackoffDuration: 3600s
  maxDoublings: 5
  maxRetryDuration: 0s
  minBackoffDuration: 5s
schedule: '*/5 * * * *'
scheduleTime: '...'
state: ENABLED
status: {}
timeZone: America/Los_Angeles
userUpdateTime: '...'

Dans la sortie, vérifiez que le champ state est défini sur ENABLED.

Vérifier que le job Cron crée un job par lot

Vérifiez que la job Cron batch-job-invoker crée correctement des tâches par lot.

Attendez cinq minutes que la job Cron'exécute automatiquement ou déclenchez-job Cron immédiatement:
```
gcloud scheduler jobs run batch-job-invoker --location us-central1
```
Répertoriez les jobs Batch créés par la job Cron batch-job-invoker:
```
gcloud batch jobs list \
--filter labels.source=\"terraform_and_cloud_scheduler_tutorial\" \
--sort-by ~createTime
```
- L'option --filter labels.source=\"terraform_and_cloud_scheduler_tutorial\" filtre la liste pour n'inclure que les tâches par lot portant un libellé avec la clé source et la valeur terraform_and_cloud_scheduler_tutorial.
- L'option --sort-by ~createTime trie la liste de la plus récente à la plus ancienne.

Mettre à jour la configuration Terraform pour suspendre la job Cron

Une fois que vous avez atteint le nombre souhaité de jobs par lot, mettez à jour et déployez la configuration Terraform pour suspendre la job Cron batch-job-invoker. Si vous souhaitez mettre à jour d'autres propriétés de la job Cron ou de futures tâches par lot, ce même processus s'applique.

Mettez à jour le fichier de configuration Terraform pour suspendre la job Cron en définissant le champ paused sur true:

sed -i 's/paused           = false # this cron job is enabled/paused           = true # this cron job is paused/g' main.tf

Générez le plan d'exécution Terraform en fonction de l'état actuel de votre projet et du fichier de configuration:

terraform plan

Le résultat ressemble à ce qui suit, qui indique que l'objectif est de remplacer la valeur false du champ paused par true:

google_cloud_scheduler_job.batch-job-invoker: Refreshing state... [id=projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker]

Terraform used the selected providers to generate the following execution plan. Resource actions are indicated with the following symbols:
  ~ update in-place

Terraform will perform the following actions:

  # google_cloud_scheduler_job.batch-job-invoker will be updated in-place
  ~ resource "google_cloud_scheduler_job" "batch-job-invoker" {
        id               = "projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker"
        name             = "batch-job-invoker"
      ~ paused           = false -> true
        # (6 unchanged attributes hidden)

      ~ http_target {
          ~ headers     = {
              + "User-Agent"   = "Google-Cloud-Scheduler"
                # (1 unchanged element hidden)
            }
            # (3 unchanged attributes hidden)

            # (1 unchanged block hidden)
        }

        # (1 unchanged block hidden)
    }

Plan: 0 to add, 1 to change, 0 to destroy.

────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Note: You didn't use the -out option to save this plan, so Terraform can't guarantee to take exactly these actions if you run "terraform apply" now.

Pour appliquer le plan permettant de mettre à jour la job Cron batch-job-invoker, procédez comme suit:

Saisissez la commande suivante :
```
terraform apply
```
Le résultat est semblable à la commande terraform plan précédente, sauf qu'elle se termine par une invite de confirmation.

Pour confirmer et appliquer le plan, saisissez yes.

Le résultat ressemble à ce qui suit :

google_cloud_scheduler_job.batch-job-invoker: Modifying... [id=projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker]
google_cloud_scheduler_job.batch-job-invoker: Modifications complete after 1s [id=projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker]

Apply complete! Resources: 0 added, 1 changed, 0 destroyed.

Pour vérifier que la job Cron batch-job-invoker est suspendue, décrivez-la:

gcloud scheduler jobs describe batch-job-invoker --location us-central1

Le résultat ressemble à ce qui suit :

attemptDeadline: 180s
httpTarget:
  body: ...
  headers:
    Content-Type: application/json
    User-Agent: Google-Cloud-Scheduler
  httpMethod: POST
  oauthToken:
    scope: https://www.googleapis.com/auth/cloud-platform
    serviceAccountEmail: CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL
  uri: https://batch.googleapis.com/v1/projects/PROJECT_NUMBER/locations/us-central1/jobs
lastAttemptTime: '...'
name: projects/PROJECT_ID/locations/us-central1/jobs/batch-job-invoker
retryConfig:
  maxBackoffDuration: 3600s
  maxDoublings: 5
  maxRetryDuration: 0s
  minBackoffDuration: 5s
schedule: '*/5 * * * *'
scheduleTime: '...'
state: PAUSED
status: {}
timeZone: America/Los_Angeles
userUpdateTime: '...'

Dans la sortie, vérifiez que le champ state est défini sur PAUSED.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

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.
Supprimez un projet Google Cloud :
```
gcloud projects delete PROJECT_ID
```
Accédez au répertoire parent, puis supprimez le répertoire Terraform et tous ses fichiers.
```
cd .. && rm -r terraform
```

Supprimer des ressources individuelles

Supprimez la job Cron batch-job-invoker.

Remarque :Pour ce tutoriel, il est plus simple d'utiliser la commande terraform destroy suivante, qui supprime toutes les ressources gérées par le fichier de configuration Terraform. Toutefois, si un fichier de configuration Terraform contient d'autres ressources que vous ne souhaitez pas supprimer, mettez plutôt à jour la configuration Terraform.
```
terraform destroy
```
Pour supprimer tous les jobs Batch de ce tutoriel, procédez comme suit:
1. Répertoriez tous les jobs Batch créés par la job Cron batch-job-invoker:
```
gcloud batch jobs list \
--filter labels.source=\"terraform_and_cloud_scheduler_tutorial\" \
--sort-by ~createTime
```
  Notez le nom de chaque job que vous devez supprimer.
2. Supprimez un job par lot de ce tutoriel:
```
gcloud batch jobs delete JOB_NAME --location us-central1
```
  Remplacez JOB_NAME par le nom d'un job par lot.
  
  Répétez cette étape pour tous les jobs par lot.
Si vous avez créé un compte de service pour ce tutoriel, supprimez-le:
```
gcloud iam service-accounts delete SERVICE_ACCOUNT_EMAIL
```
Remplacez SERVICE_ACCOUNT_EMAIL par l'adresse e-mail d'un compte de service que vous avez créé pour ce tutoriel. Plus précisément, vous avez utilisé les comptes de service suivants:
- CLOUD_SCHEDULER_SERVICE_ACCOUNT_EMAIL : compte de service pour Cloud Scheduler.
- BATCH_SERVICE_ACCOUNT_EMAIL : compte de service pour Batch.
Si vous avez créé deux comptes de service distincts, répétez cette étape.
Accédez au répertoire parent, puis supprimez le répertoire Terraform et tous ses fichiers.
```
cd .. && rm -r terraform
```

Étapes suivantes

Découvrez comment utiliser Terraform avec Google Cloud :
- Documentation Terraform pour Google Cloud
- Documentation Google Cloud sur Terraform
En savoir plus sur les tâches Cron Cloud Scheduler
Apprenez-en plus sur les tâches par lot.

Créer et exécuter des jobs par lot à l'aide de Terraform et de Cloud Scheduler

Objectifs

Coûts

Avant de commencer

Cloud Shell

Shell local

Créer le répertoire Terraform et le fichier de configuration

Déployer la configuration Terraform pour créer le job Cron

Vérifier que le job Cron crée un job par lot

Mettre à jour la configuration Terraform pour suspendre la job Cron

Effectuer un nettoyage

Supprimer le projet

Supprimer des ressources individuelles

Étapes suivantes