Migrer des files d'attente d'envoi vers Cloud Tasks

Cette page explique comment effectuer la migration du code de file d'attente d'envoi depuis les files d'attente de tâches vers Cloud Tasks. Cloud Tasks est désormais la méthode de travail privilégiée pour les files d'attente d'envoi App Engine.

Aperçu

Avec Cloud Tasks, vous accédez au même service qu'avec l'API RPC Task Queues. Cela signifie que vous n'avez pas besoin de recréer les files d'attente d'envoi existantes ni les tâches d'envoi. Cependant, vous devez effectuer la migration du code qui crée ou interagit avec les files d'attente d'envoi ou les tâches d'envoi afin d'utiliser l'API Cloud Tasks.

Vous pouvez créer et interagir avec les files d'attente d'envoi et les tâches d'envoi à l'aide des API REST et RPC Cloud Tasks, de la bibliothèque cliente Cloud Tasks pour Java, de l'outil de ligne de commande gcloud et de Google Cloud Console. Cette page fournit des exemples utilisant l'outil gcloud et la bibliothèque cliente Cloud Tasks pour Java.

Dans Cloud Tasks, toutes les files d'attente fonctionnent comme des files d'attente d'envoi. Dans la suite de ce guide et dans la documentation Cloud Tasks, le terme file d'attente équivaut au terme file d'attente d'envoi. De même, le terme tâche équivaut au terme tâche d'envoi.

Fonctionnalités actuellement non disponibles dans Cloud Tasks

Les fonctionnalités suivantes ne sont pas actuellement disponibles dans Cloud Tasks :

  • Tâches de mise en file d'attente dans les transactions Datastore
  • Utiliser la bibliothèque de tâches différées au lieu d'un service de nœuds de calcul
  • Utiliser des tâches dans des applications mutualisées
  • Simuler avec le serveur de développement local
  • Ajouter des tâches de manière asynchrone

Tarifs et quotas

La migration de vos files d'attente d'envoi vers Cloud Tasks peut avoir une incidence sur les tarifs et les quotas de votre application.

Prix

Cloud Tasks possède sa propre tarification. Comme pour les files d'attente de tâches, l'envoi de requêtes à votre application App Engine avec une tâche peut entraîner des frais pour votre application.

Quota

Les quotas Cloud Tasks sont différents de ceux des files d'attente de tâches. Comme pour les files d'attente de tâches, l'envoi de requêtes à votre application App Engine à partir de Cloud Tasks peut avoir un impact sur vos quotas de requêtes App Engine.

Avant la migration

Cette section explique ce que vous devez faire avant de migrer vos files d'attente d'envoi vers Cloud Tasks.

Migration des files d'attente de retrait

Utilisez le guide de migration des files d'attente de retrait pour migrer vos files d'attente de retrait avant d'utiliser ce guide pour migrer vos files d'attente d'envoi. La migration des files d'attente de retrait après celle des files d'attente d'envoi n'est pas recommandée, car l'utilisation obligatoire du fichier queue.yaml est susceptible de provoquer un comportement inattendu avec Cloud Tasks.

Protéger la configuration des files d'attente

Une fois le processus de migration vers Cloud Tasks lancé, la modification de votre fichier queue.yaml n'est pas recommandée et peut provoquer un comportement inattendu. Protégez la configuration de vos files d'attente contre les modifications effectuées par le fichier queue.yaml en procédant comme suit :

  1. Configurez le SDK Cloud pour omettre votre fichier queue.yaml dans les déploiements ultérieurs.

    Ajoutez votre fichier queue.yaml à un fichier .gcloudignore. Pour vérifier si vous disposez déjà d'un fichier .gcloudignore, vous pouvez exécuter la commande suivante dans votre terminal à partir du répertoire de premier niveau de votre application. Cette commande renvoie le nom du fichier s'il existe.

    ls -a | grep .gcloudignore

    Pour en savoir plus sur les fichiers .gcloudignore, consultez la page de référence .gcloudignore.

  2. Restreindre les autorisations sur votre fichier queue.yaml.

    Suivez les bonnes pratiques décrites dans notre guide sur la sécurisation de la configuration des files d'attente.

  3. En savoir plus sur Cloud Tasks et le fichier queue.yaml (facultatif).

    Lorsque vous utilisez l'API Cloud Tasks pour gérer la configuration de vos files d'attente, le déploiement d'un fichier queue.yaml remplace la configuration définie par Cloud Tasks, ce qui peut provoquer un comportement inattendu. Pour en savoir plus, consultez la section Utiliser la gestion des files d'attente et utiliser queue.yaml (comparaison).

Activer l'API Cloud Tasks

Pour activer l'API Cloud Tasks, cliquez sur Activer dans l'API Cloud Tasks dans la bibliothèque d'API. Si un bouton Gérer s'affiche au lieu du bouton Activer, cela signifie que vous avez précédemment activé l'API Cloud Tasks pour votre projet et que vous n'avez pas besoin de le faire à nouveau.

Authentifier votre application dans l'API Cloud Tasks

Vous devez authentifier votre application dans l'API Cloud Tasks. Cette section traite de l'authentification pour deux cas d'utilisation différents.

Pour développer ou tester votre application localement, nous vous recommandons d'utiliser un compte de service. Pour obtenir des instructions sur la configuration d'un compte de service et le connecter à votre application, consultez la section Obtenir et fournir manuellement les identifiants du compte de service.

Pour déployer votre application sur App Engine, vous n'avez pas besoin de fournir une nouvelle authentification. Les identifiants par défaut de l'application déduisent les informations d'authentification pour les applications App Engine.

Télécharger le SDK Cloud

Si ce n'est déjà fait, téléchargez et installez le SDK Cloud pour utiliser l'outil gcloud avec l'API Cloud Tasks. Exécutez la commande suivante à partir de votre terminal si vous avez déjà installé le SDK Cloud.

gcloud components update

Importer la bibliothèque cliente pour Java

Suivez les étapes ci-dessous pour utiliser la bibliothèque cliente Cloud Tasks pour Java avec votre application App Engine :

  1. Spécifiez la dépendance de la bibliothèque cliente Cloud Tasks dans votre fichier pom.xml :

    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
      <version>1.3.0</version>
    </dependency>
    
  2. Importez les dépendances de la bibliothèque cliente Cloud Tasks dans les fichiers chargés de la création et de la mise en file d'attente des tâches :

    import com.google.cloud.tasks.v2.AppEngineHttpRequest;
    import com.google.cloud.tasks.v2.CloudTasksClient;
    import com.google.cloud.tasks.v2.HttpMethod;
    import com.google.cloud.tasks.v2.QueueName;
    import com.google.cloud.tasks.v2.Task;
    

Créer et gérer des files d'attente

Cette section explique comment créer et gérer des files d'attente à l'aide de l'API Cloud Tasks.

Avec Cloud Tasks, vous n'utilisez pas de fichier queue.yaml pour créer ou gérer des files d'attente. À la place, utilisez l'API Cloud Tasks. L'utilisation d'un fichier queue.yaml et de l'API Cloud Tasks n'est pas recommandée, mais cela peut s'avérer inévitable lors de la migration des files d'attente de tâches vers Cloud Tasks en fonction de votre application. Pour en savoir plus sur les bonnes pratiques, consultez la page Utiliser la gestion des files d'attente et utiliser queue.yaml (comparaison).

Créer des files d'attente

Lisez cette section si votre application crée des files d'attente par programmation ou si vous souhaitez créer des files d'attente supplémentaires à partir de la ligne de commande.

Dans Cloud Tasks, les noms de files d'attente se présentent sous la forme projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID. La partie LOCATION_ID du nom de la file d'attente correspond à une région Google Cloud. La partie QUEUE_ID du nom de la file d'attente est équivalente au champ name de la file d'attente Task Queues. Le nom de la file d'attente est généré lors de la création de la file d'attente basée sur le projet, la région et le QUEUE_ID que vous avez spécifiés.

En règle générale, l'emplacement de la file d'attente (région) doit correspondre à la région de votre application. Les deux exceptions à cette règle concernent les applications utilisant la région europe-west et celles utilisant la région us-central. Dans Cloud Tasks, ces régions sont appelées respectivement europe-west1 et us-central1.

Vous pouvez spécifier une configuration facultative lors de la création d'une file d'attente, mais vous pouvez également la mettre à jour après sa création.

Vous n'avez pas besoin de recréer les files d'attente existantes. Effectuez plutôt la migration du code qui interagit avec vos files d'attente existantes en lisant les sections pertinentes de ce guide.

Réutiliser les noms de file d'attente

Vous devez attendre sept jours après la suppression d'une file d'attente pour en créer une autre avec le même ID dans le même projet et le même emplacement (région).

L'exemple suivant permet de créer deux files d'attente à l'aide de Cloud Tasks. La première file d'attente possède l'ID queue-blue et est configurée pour envoyer toutes les tâches à la version v2 du service task-module à une vitesse de 5/s. La deuxième file d'attente possède l'ID queue-red et distribue les tâches à une vitesse de 1/s. Les deux files d'attente sont créées sur le projet avec l'ID de projet your-project-id à l'emplacement us-central1. Il s'agit de l'équivalent Cloud Tasks pour la création de files d'attente dans Task Queues.

gcloud

L'outil gcloud déduit le projet et l'emplacement à partir de la configuration de l'outil gcloud.

gcloud tasks queues create queue-blue \
--max-dispatches-per-second=5 \
--routing-override=service:task-module,version:v2
gcloud tasks queues create queue-red \
--max-dispatches-per-second=1

bibliothèque cliente

import com.google.cloud.tasks.v2.AppEngineRouting;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;

public class CreateQueue {
  public static void createQueue(
      String projectId, String locationId, String queueBlueName, String queueRedName)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueBlueName = "queue-blue";
      // String queueRedName = "queue-red";

      LocationName parent = LocationName.of(projectId, locationId);

      Queue queueBlue =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueBlueName).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(5.0))
              .setAppEngineRoutingOverride(
                  AppEngineRouting.newBuilder().setVersion("v2").setService("task-module"))
              .build();

      Queue queueRed =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueRedName).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .build();

      Queue[] queues = new Queue[] {queueBlue, queueRed};
      for (Queue queue : queues) {
        Queue response = client.createQueue(parent, queue);
        System.out.println(response);
      }
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Créer une file d'attente Cloud Tasks.

Définir le taux de traitement de la file d'attente

Le tableau ci-dessous répertorie les champs qui diffèrent entre Task Queues et Cloud Tasks.

Champ Task Queues Champ Cloud Tasks Description
rate max_dispatches_per_second Fréquence maximale à laquelle les tâches sont distribuées depuis la file d'attente
max_concurrent_requests max_concurrent_dispatches Nombre maximal de tâches simultanées pouvant être distribuées à partir de la file d'attente
bucket_size max_burst_size

Cloud Tasks calcule une propriété get-only max_burst_size qui limite la vitesse de traitement des tâches de la file d'attente en fonction de la valeur de max_dispatches_per_second. Ce champ permet à la file d'attente d'atteindre un taux élevé de sorte que le traitement démarre peu de temps après la mise en file d'attente d'une tâche, tout en limitant l'utilisation des ressources lorsqu'un grand nombre de tâches sont placées en file d'attente pour une courte période.

Pour les files d'attente App Engine créées ou mises à jour à l'aide d'un fichier queue.xml/yaml, max_burst_size est initialement égal à bucket_size. Cependant, si la file d'attente est transmise ultérieurement à une commande update à l'aide d'une interface Cloud Tasks, max_burst_size sera réinitialisé en fonction de la valeur de max_dispatches_per_second, que max_dispatches_per_second soit mis à jour ou non.

total_storage_limit Obsolète dans Cloud Tasks Cloud Tasks n'est actuellement pas compatible avec la définition d'une limite de stockage personnalisée.

Vous pouvez définir la vitesse de traitement de la file d'attente lors de sa création ou la mettre à jour par la suite. L'exemple ci-dessous utilise Cloud Tasks pour définir la vitesse de traitement d'une file d'attente nommée queue-blue qui a déjà été créée. Si queue-blue a été créé ou configuré à l'aide d'un fichier queue.yaml, l'exemple ci-dessous réinitialise max_burst_size en fonction de la valeur max_dispatches_per_second de 20. Il s'agit de l'équivalent Cloud Tasks pour la définition de la vitesse de traitement des files d'attente dans Task Queues.

gcloud

gcloud tasks queues update queue-blue \
--max-dispatches-per-second=20 \
--max-concurrent-dispatches=10

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;
import com.google.cloud.tasks.v2.UpdateQueueRequest;

public class UpdateQueue {
  public static void updateQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "queue-blue";

      LocationName parent = LocationName.of(projectId, locationId);

      Queue queueBlue =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, queueId).toString())
              .setRateLimits(
                  RateLimits.newBuilder()
                      .setMaxDispatchesPerSecond(20.0)
                      .setMaxConcurrentDispatches(10))
              .build();

      UpdateQueueRequest request = UpdateQueueRequest.newBuilder().setQueue(queueBlue).build();

      Queue response = client.updateQueue(request);
      System.out.println(response);
    }
  }
}

Pour en savoir plus, consultez la section Définir des limites de débit.

Désactiver et reprendre les files d'attente

Cloud Tasks utilise le terme suspendre de la même manière que Task Queues utilise le terme désactiver. La suspension d'une file d'attente arrête l'exécution des tâches jusqu'à sa réactivation. Cependant, vous pouvez continuer à ajouter des tâches à une file d'attente suspendue. Cloud Tasks utilise le terme réactiver de la même manière que Task Queues.

L'exemple ci-dessous suspend une file d'attente avec l'ID queueName. Il s'agit de l'équivalent Cloud Tasks pour la désactivation des files d'attente dans Task Queues.

gcloud

gcloud tasks queues pause queueName

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class PauseQueue {
  public static void pauseQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.pauseQueue(queueName);
      System.out.println("Queue Paused.");
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Suspendre les files d'attente.

Supprimer des files d'attente

Une fois que vous supprimez une file d'attente, vous devez attendre sept jours avant de pouvoir en créer une autre portant le même nom. Envisagez de supprimer toutes les tâches d'une file d'attente et de la reconfigurer si vous ne pouvez pas attendre sept jours.

L'exemple ci-dessous montre comment supprimer la file d'attente avec l'ID foo. Il s'agit de l'équivalent Cloud Tasks pour la suppression des files d'attente dans Task Queues.

gcloud

gcloud tasks queues delete foo

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class DeleteQueue {
  public static void deleteQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.deleteQueue(queueName);
      System.out.println("Queue Deleted.");
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Supprimer les files d'attente.

Créer et gérer des tâches

Cette section explique comment créer et gérer des tâches à l'aide de l'API Cloud Tasks.

Créer des tâches

Le tableau ci-dessous répertorie les champs qui diffèrent entre Task Queues et Cloud Tasks.

Champ Task Queues Champ Cloud Tasks Description
NOUVEAU dans Cloud Tasks app_engine_http_request Crée une requête qui cible un service App Engine. Ces tâches sont appelées tâches App Engine.
method http_method Spécifie la méthode de requête, par exemple POST.
url relative_uri Indique le gestionnaire de tâches. Notez la différence dans la lettre finale : i pour URI (Uniform Resource Identifier plutôt que l pour URL (Uniform Resource Locator)
target app_engine_routing Spécifie service, version et instance App Engine pour une tâche App Engine. En l'absence de définition, le service, la version et l'instance par défaut sont utilisés.

L'exemple suivant crée une tâche qui est acheminée vers le gestionnaire /worker sur le service App Engine par défaut. Il s'agit de l'équivalent Cloud Tasks pour la création de tâches dans Task Queues.

gcloud

gcloud tasks create-app-engine-task --queue=default \
--method=POST --relative-uri=/worker?key=key

bibliothèque cliente

import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import java.nio.charset.Charset;

public class CreateTask {
  public static void createTask(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      String key = "key";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      // Construct the task body.
      Task taskParam =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker?key=" + key)
                      .setHttpMethod(HttpMethod.GET)
                      .build())
              .build();

      Task taskPayload =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(key, Charset.defaultCharset()))
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Send create task request.
      Task[] tasks = new Task[] {taskParam, taskPayload};
      for (Task task : tasks) {
        Task response = client.createTask(queueName, task);
        System.out.println(response);
      }
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Créer des tâches App Engine.

Spécifier le service cible et le routage

La spécification du service cible, de la version et de l'instance App Engine pour les tâches App Engine est facultative. Par défaut, les tâches App Engine sont acheminées vers le service, la version et l'instance qui sont utilisés par défaut au moment de la tentative de tâche.

Définissez la propriété app_engine_routing de la tâche lors de sa création pour spécifier d'autres service, version ou instance App Engine pour votre tâche.

Pour acheminer toutes les tâches d'une file d'attente donnée vers les mêmes service, version et instance App Engine, vous pouvez définir la propriété app_engine_routing_override sur la file d'attente.

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Configurer le routage.

Transmettre des données au gestionnaire

Comme pour Task Queues, vous pouvez transmettre des données au gestionnaire de deux manières à l'aide de Cloud Tasks. Vous pouvez transmettre des données en tant que paramètres de requête dans l'URI relatif ou des données dans le corps de la requête à l'aide des méthodes HTTP POST ou PUT.

Cloud Tasks utilise le terme corps de la même manière que Task Queues utilise le terme charge utile. Pour le corps, Cloud Tasks utilise par défaut le type de contenu octet-stream plutôt que le texte brut. Vous pouvez définir le type de contenu du corps en le spécifiant dans l'en-tête.

L'exemple suivant montre comment transmettre une clé au gestionnaire /worker de deux manières différentes. Il s'agit de l'équivalent Cloud Tasks pour la transmission des données au gestionnaire dans Task Queues.

console

gcloud tasks create-app-engine-task --queue=default --method=GET  \
--relative-uri=/worker?key=blue --routing=service:worker
gcloud tasks create-app-engine-task --queue=default --method=POST \
--relative-uri=/worker --routing=service:worker \
--body-content="{'key': 'blue'}"

bibliothèque cliente

import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import java.nio.charset.Charset;

public class CreateTask {
  public static void createTask(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      String key = "key";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      // Construct the task body.
      Task taskParam =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker?key=" + key)
                      .setHttpMethod(HttpMethod.GET)
                      .build())
              .build();

      Task taskPayload =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(key, Charset.defaultCharset()))
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Send create task request.
      Task[] tasks = new Task[] {taskParam, taskPayload};
      for (Task task : tasks) {
        Task response = client.createTask(queueName, task);
        System.out.println(response);
      }
    }
  }
}

Nommer des tâches

Il n'est pas nécessaire de spécifier le nom de la tâche. Si vous n'indiquez aucun nom de tâche, Cloud Tasks en crée un pour vous en générant un ID de tâche, et en déduisant le projet et l'emplacement (région) en fonction de la file d'attente que vous avez spécifiée lors de la création de la tâche.

Les noms de tâches se présentent sous la forme projects/PROJECT_ID/locations/LOCATION_ID/queues/QUEUE_ID/tasks/TASK_ID. La partie TASK_ID du nom de la tâche est équivalente au champ name de la tâche Task Queues.

Réutiliser des noms de tâches

Vous devez attendre avant de réutiliser le nom d'une tâche. Le temps d'attente avant de le faire diffère selon que la file d'attente de distribution de la tâche a été créée dans Cloud Tasks ou dans Task Queues.

Pour les tâches dans les files d'attente qui ont été créées à l'aide de Task Queues (y compris la file d'attente par défaut), vous devez attendre environ neuf jours après la suppression ou l'exécution de la tâche d'origine. Pour les tâches dans les files d'attente qui ont été créées à l'aide de Cloud Tasks, vous devez attendre environ une heure après la suppression ou l'exécution de la tâche d'origine.

L'exemple suivant montre comment créer une tâche avec le paramètre TASK_ID défini sur first-try et l'ajoute à la file d'attente par défaut. Il s'agit de l'équivalent Cloud Tasks pour la dénomination des tâches dans Task Queues.

gcloud

L'outil gcloud crée le nom de la tâche en déduisant le projet et l'emplacement à partir de votre configuration.

gcloud tasks create-app-engine-task first-try --queue=default \
--method=GET --relative-uri=/worker

bibliothèque cliente

Avec la bibliothèque cliente, vous devez spécifier le nom complet de la tâche si vous souhaitez indiquer le TASK_ID. Le projet et l'emplacement doivent correspondre au projet et à l'emplacement de la file d'attente à laquelle la tâche est ajoutée.

import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.cloud.tasks.v2.TaskName;

public class CreateTaskWithName {
  public static void createTaskWithName(
      String projectId, String locationId, String queueId, String taskId) throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "default";
      // String taskId = "first-try"

      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      Task.Builder taskBuilder =
          Task.newBuilder()
              .setName(TaskName.of(projectId, locationId, queueId, taskId).toString())
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/worker")
                      .setHttpMethod(HttpMethod.GET)
                      .build());

      // Send create task request.
      Task response = client.createTask(queueName, taskBuilder.build());
      System.out.println(response);
    }
  }
}

Réessayer d'effectuer les tâches en échec

Vous pouvez définir la configuration d'une nouvelle tentative de la tâche mise en file d'attente lors de la création ou de la mise à jour de la file d'attente. Le tableau ci-dessous répertorie le champ Task Queues et le champ Cloud Tasks correspondant.

Champ Task Queues Champ Cloud Tasks
task_retry_limit max_attempts
task_age_limit max_retry_duration
min_backoff_seconds min_backoff
max_backoff_seconds max_backoff
max_doublings max_doublings

Paramètres de nouvelle tentative spécifiques à la tâche

Les paramètres de nouvelle tentative spécifiques à la tâche qui ont été configurés dans Task Queues fonctionnent dans Cloud Tasks, mais vous ne pouvez pas les modifier ni les définir sur de nouvelles tâches. Pour modifier les paramètres de nouvelle tentative d'une tâche comportant des paramètres de nouvelle tentative spécifiques à la tâche, vous devez recréer la tâche avec une file d'attente Cloud Tasks contenant les paramètres de nouvelle tentative souhaités.

L'exemple suivant illustre divers scénarios de nouvelles tentatives d'exécution :

  • Dans fooqueue, les tâches sont relancées jusqu'à sept fois et jusqu'à deux jours après la première tentative d'exécution. Une fois ces deux limites atteintes, la tâche échoue définitivement.
  • Dans barqueue, App Engine tente de relancer les tâches en augmentant l'intervalle de manière linéaire entre chaque tentative jusqu'à atteindre l'intervalle maximal et en réessayant indéfiniment à l'intervalle maximal (les intervalles entre les tentatives sont donc de 10 s, 20 s, 30 s, ..., 190 s, 200 s, 200 s, ...).
  • Dans bazqueue, l'intervalle de relance commence à 10 s, double deux fois, puis augmente de manière linéaire, avant de réessayer indéfiniment à l'intervalle maximal (les intervalles entre les requêtes sont de 10 s, 20 s, 40 s, 80 s, 160 s, 240 s, 300 s, 300 s, ...).

Il s'agit de l'équivalent Cloud Tasks pour la relance des tâches dans Task Queues.

gcloud

Lorsque vous définissez des options qui spécifient un nombre de secondes, vous devez inclure s après le nombre entier (par exemple, 200s et non 200).

gcloud tasks queues create fooqueue \
--max-attempts=7 \
--max-retry-duration=172800s  #2*60*60*24 seconds in 2 days
gcloud tasks queues create barqueue \
--min-backoff=10s \
--max-backoff=200s \
--max-doublings=0
gcloud tasks queues create bazqueue \
--min-backoff=10s \
--max-backoff=300s \
--max-doublings=3

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.LocationName;
import com.google.cloud.tasks.v2.Queue;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.RateLimits;
import com.google.cloud.tasks.v2.RetryConfig;
import com.google.protobuf.Duration;

public class RetryTask {
  public static void retryTask(
      String projectId, String locationId, String fooqueue, String barqueue, String bazqueue)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String fooqueue = "fooqueue";
      // String barqueue = "barqueue";
      // String bazqueue = "bazqueue";

      LocationName parent = LocationName.of(projectId, locationId);

      Duration retryDuration = Duration.newBuilder().setSeconds(2 * 60 * 60 * 24).build();
      Duration min = Duration.newBuilder().setSeconds(10).build();
      Duration max1 = Duration.newBuilder().setSeconds(200).build();
      Duration max2 = Duration.newBuilder().setSeconds(300).build();

      Queue foo =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, fooqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder().setMaxAttempts(7).setMaxRetryDuration(retryDuration))
              .build();

      Queue bar =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, barqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder()
                      .setMinBackoff(min)
                      .setMaxBackoff(max1)
                      .setMaxDoublings(0))
              .build();

      Queue baz =
          Queue.newBuilder()
              .setName(QueueName.of(projectId, locationId, bazqueue).toString())
              .setRateLimits(RateLimits.newBuilder().setMaxDispatchesPerSecond(1.0))
              .setRetryConfig(
                  RetryConfig.newBuilder()
                      .setMinBackoff(min)
                      .setMaxBackoff(max2)
                      .setMaxDoublings(3))
              .build();

      Queue[] queues = new Queue[] {foo, bar, baz};
      for (Queue queue : queues) {
        Queue response = client.createQueue(parent, queue);
        System.out.println(response);
      }
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Définir les paramètres de nouvelle tentative.

Supprimer les tâches d'une file d'attente

Lorsque vous supprimez une tâche, vous devez attendre neuf jours avant de pouvoir créer une tâche portant le même nom si elle se trouve dans une file d'attente créée à l'aide d'un fichier queue.yaml ou une heure si elle se trouve dans une file d'attente créée à l'aide de Cloud Tasks.

L'exemple suivant montre comment supprimer la tâche associée à l'ID de tâche foo de la file d'attente associée à l'ID de file d'attente queue1. Il s'agit de l'équivalent Cloud Tasks pour la suppression de tâches dans Task Queues.

gcloud

Le projet et l'emplacement de la tâche sont obtenus à partir du projet par défaut SDK Cloud.

gcloud tasks delete foo --queue=queue1

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.TaskName;

public class DeleteTask {
  public static void deleteTask(String projectId, String locationId, String queueId, String taskId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "queue1";
      // String taskId = "foo";

      // Construct the fully qualified queue name.
      String taskName = TaskName.of(projectId, locationId, queueId, taskId).toString();

      client.deleteTask(taskName);
      System.out.println("Task Deleted.");
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Supprimer une tâche d'une file d'attente.

Supprimer les tâches

L'exemple suivant montre comment supprimer toutes les tâches de la file d'attente avec l'ID de file d'attente foo. Il s'agit de l'équivalent Cloud Tasks pour la suppression des tâches dans Task Queues.

gcloud

Le projet et l'emplacement de la file d'attente sont obtenus à partir du projet par défaut SDK Cloud.

gcloud tasks queues purge foo

bibliothèque cliente

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.QueueName;

public class PurgeQueue {
  public static void purgeQueue(String projectId, String locationId, String queueId)
      throws Exception {
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // TODO(developer): Uncomment these lines and replace with your values.
      // String projectId = "your-project-id";
      // String locationId = "us-central1";
      // String queueId = "foo";

      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, queueId).toString();

      client.purgeQueue(queueName);
      System.out.println("Queue Purged.");
    }
  }
}

Pour en savoir plus sur Cloud Tasks, consultez la page de référence Purger toutes les tâches d'une file d'attente.

Exemple de tâches dans le cloud Java 8

L'exemple suivant est une configuration de base pour créer une file d'attente et y placer une tâche avec Cloud Tasks. Il suppose que le développeur a créé un fichier pom.xml pour spécifier la dépendance Cloud Tasks, comme décrit dans la section Importer la bibliothèque cliente. Il s'agit de l'équivalent Cloud Tasks d'un exemple de file d'attente de tâches Java 8 dans Task Queues.

Le fichier responsable de la création et de la mise en file d'attente crée une tâche et l'ajoute à la file d'attente par défaut à l'aide de la bibliothèque cliente Cloud Tasks pour Java :

import com.google.cloud.tasks.v2.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(
    name = "TaskEnqueue",
    description = "Enqueue a task targeted at endpoint '/cloudtasks/worker'",
    urlPatterns = "/cloudtasks/enqueue")
public class Enqueue extends HttpServlet {

  // TODO(developer): Replace these variables before running the sample.
  static final String projectId = "my-project-id";
  static final String locationId = "us-central1";

  // Function creates Cloud Tasks from form submissions.
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    String key = request.getParameter("key");

    try (CloudTasksClient client = CloudTasksClient.create()) {
      // Construct the fully qualified queue name.
      String queueName = QueueName.of(projectId, locationId, "default").toString();

      // Construct the task body.
      Task task =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setRelativeUri("/cloudtasks/worker?key=" + key)
                      .setHttpMethod(HttpMethod.POST)
                      .build())
              .build();

      // Add the task to the default queue.
      Task taskResponse = client.createTask(queueName, task);
      System.out.println("Task created: " + taskResponse.getName());
    }

    response.sendRedirect("/");
  }
}

Le fichier qui définit le nœud de calcul gère la tâche :

import java.io.IOException;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(
    name = "TaskWorker",
    description = "Endpoint to process Cloud Task requests",
    urlPatterns = "/cloudtasks/worker"
)
public class Worker extends HttpServlet {

  private static final Logger log = Logger.getLogger(Worker.class.getName());

  // Worker function to process POST requests from Cloud Tasks targeted at the
  // '/cloudtasks/worker' endpoint.
  protected void doPost(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
    String key = request.getParameter("key");
    log.info("Worker is processing " + key);
  }
}

Étape suivante