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

Créer des tâches cibles HTTP

Les gestionnaires Cloud Tasks peuvent être exécutés sur n'importe quel point de terminaison HTTP doté d'une adresse IP externe, comme GKE, Compute Engine ou même un serveur Web sur site. Vous pouvez exécuter vos tâches sur n'importe lequel de ces services de manière fiable et configurable.

Cette page explique comment créer par programmation des tâches HTTP Target de base et les placer dans des files d'attente Cloud Tasks.

Pour les tâches qui ont des cibles HTTP (par opposition aux cibles App Engine explicites, qui sont moins courantes), il existe deux façons de créer des tâches :

Méthode CreateTask : vous devez créer explicitement un objet de tâche. Utilisez cette méthode si les tâches de votre file d'attente ont des configurations de routage différentes. Dans ce cas, vous spécifiez le routage au niveau de la tâche et ne pouvez pas utiliser le routage au niveau de la file d'attente. Cette approche utilise la méthode CreateTask.
Méthode BufferTask : utilisez cette méthode si votre file d'attente est configurée pour mettre en mémoire tampon les tâches devant un service. La file d'attente doit disposer d'un routage au niveau de la file d'attente. Cette approche utilise la méthode BufferTask.

Créer une tâche à l'aide de la méthode `CreateTask`

Cette section explique comment créer une tâche en construisant l'objet de tâche. Vous utilisez la méthode CreateTask.

Lorsque vous créez une tâche à l'aide de la méthode CreateTask, vous créez et définissez explicitement l'objet de la tâche. Vous devez spécifier le service et le gestionnaire qui traitent la tâche.

Vous pouvez éventuellement transmettre au gestionnaire des données spécifiques à la tâche. Vous pouvez également ajuster la configuration de la tâche, par exemple en planifiant une heure future d'exécution ou en limitant le nombre de nouvelles tentatives en cas d'échec de la tâche (voir Configuration avancée).

Les exemples suivants appellent la méthode CreateTask pour créer une tâche à l'aide des bibliothèques clientes Cloud Tasks.

C#


using Google.Cloud.Tasks.V2;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using System;

class CreateHttpTask
{
    public string CreateTask(
        string projectId = "YOUR-PROJECT-ID",
        string location = "us-central1",
        string queue = "my-queue",
        string url = "http://example.com/taskhandler",
        string payload = "Hello World!",
        int inSeconds = 0)
    {
        CloudTasksClient client = CloudTasksClient.Create();
        QueueName parent = new QueueName(projectId, location, queue);

        var response = client.CreateTask(new CreateTaskRequest
        {
            Parent = parent.ToString(),
            Task = new Task
            {
                HttpRequest = new HttpRequest
                {
                    HttpMethod = HttpMethod.Post,
                    Url = url,
                    Body = ByteString.CopyFromUtf8(payload)
                },
                ScheduleTime = Timestamp.FromDateTime(
                    DateTime.UtcNow.AddSeconds(inSeconds))
            }
        });

        Console.WriteLine($"Created Task {response.Name}");
        return response.Name;
    }
}

Go


// Command createHTTPtask constructs and adds a task to a Cloud Tasks Queue.
package main

import (
	"context"
	"fmt"

	cloudtasks "cloud.google.com/go/cloudtasks/apiv2"
	taskspb "cloud.google.com/go/cloudtasks/apiv2/cloudtaskspb"
)

// createHTTPTask creates a new task with a HTTP target then adds it to a Queue.
func createHTTPTask(projectID, locationID, queueID, url, message string) (*taskspb.Task, error) {

	// Create a new Cloud Tasks client instance.
	// See https://godoc.org/cloud.google.com/go/cloudtasks/apiv2
	ctx := context.Background()
	client, err := cloudtasks.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	// Build the Task queue path.
	queuePath := fmt.Sprintf("projects/%s/locations/%s/queues/%s", projectID, locationID, queueID)

	// Build the Task payload.
	// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2#CreateTaskRequest
	req := &taskspb.CreateTaskRequest{
		Parent: queuePath,
		Task: &taskspb.Task{
			// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2#HttpRequest
			MessageType: &taskspb.Task_HttpRequest{
				HttpRequest: &taskspb.HttpRequest{
					HttpMethod: taskspb.HttpMethod_POST,
					Url:        url,
				},
			},
		},
	}

	// Add a payload message if one is present.
	req.Task.GetHttpRequest().Body = []byte(message)

	createdTask, err := client.CreateTask(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("cloudtasks.CreateTask: %w", err)
	}

	return createdTask, nil
}

Java

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

public class CreateHttpTask {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String locationId = "us-central1";
    String queueId = "my-queue";
    createTask(projectId, locationId, queueId);
  }

  // Create a task with a HTTP target using the Cloud Tasks client.
  public static void createTask(String projectId, String locationId, String queueId)
      throws IOException {

    // Instantiates a client.
    try (CloudTasksClient client = CloudTasksClient.create()) {
      String url = "https://example.com/taskhandler";
      String payload = "Hello, World!";

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

      // Construct the task body.
      Task.Builder taskBuilder =
          Task.newBuilder()
              .setHttpRequest(
                  HttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(payload, Charset.defaultCharset()))
                      .setUrl(url)
                      .setHttpMethod(HttpMethod.POST)
                      .build());

      // Send create task request.
      Task task = client.createTask(queuePath, taskBuilder.build());
      System.out.println("Task created: " + task.getName());
    }
  }
}

Notez le fichier pom.xml :

<?xml version='1.0' encoding='UTF-8'?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example.tasks</groupId>
  <artifactId>cloudtasks-snippets</artifactId>
  <packaging>jar</packaging>
  <name>Google Cloud Tasks Snippets</name>

  <!--
    The parent pom defines common style checks and testing strategies for our samples.
    Removing or replacing it should not affect the execution of the samples in anyway.
  -->
  <parent>
    <groupId>com.google.cloud.samples</groupId>
    <artifactId>shared-configuration</artifactId>
    <version>1.2.0</version>
  </parent>

  <properties>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>


  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>libraries-bom</artifactId>
        <version>26.32.0</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.truth</groupId>
      <artifactId>truth</artifactId>
      <version>1.4.0</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Node.js

// Imports the Google Cloud Tasks library.
const {CloudTasksClient} = require('@google-cloud/tasks');

// Instantiates a client.
const client = new CloudTasksClient();

async function createHttpTask() {
  // TODO(developer): Uncomment these lines and replace with your values.
  // const project = 'my-project-id';
  // const queue = 'my-queue';
  // const location = 'us-central1';
  // const url = 'https://example.com/taskhandler';
  // const payload = 'Hello, World!';
  // const inSeconds = 180;

  // Construct the fully qualified queue name.
  const parent = client.queuePath(project, location, queue);

  const task = {
    httpRequest: {
      headers: {
        'Content-Type': 'text/plain', // Set content type to ensure compatibility your application's request parsing
      },
      httpMethod: 'POST',
      url,
    },
  };

  if (payload) {
    task.httpRequest.body = Buffer.from(payload).toString('base64');
  }

  if (inSeconds) {
    // The time when the task is scheduled to be attempted.
    task.scheduleTime = {
      seconds: parseInt(inSeconds) + Date.now() / 1000,
    };
  }

  // Send create task request.
  console.log('Sending task:');
  console.log(task);
  const request = {parent: parent, task: task};
  const [response] = await client.createTask(request);
  console.log(`Created task ${response.name}`);
}
createHttpTask();

Notez le fichier package.json :

{
  "name": "appengine-cloudtasks",
  "description": "Google App Engine Cloud Tasks example.",
  "license": "Apache-2.0",
  "author": "Google Inc.",
  "private": true,
  "engines": {
    "node": ">=16.0.0"
  },
  "files": [
    "*.js"
  ],
  "scripts": {
    "test": "c8 mocha -p -j 2 --timeout 30000",
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/tasks": "^5.0.0",
    "express": "^4.16.3"
  },
  "devDependencies": {
    "c8": "^10.0.0",
    "chai": "^4.5.0",
    "mocha": "^10.0.0",
    "uuid": "^10.0.0"
  }
}

PHP

use Google\Cloud\Tasks\V2\Client\CloudTasksClient;
use Google\Cloud\Tasks\V2\CreateTaskRequest;
use Google\Cloud\Tasks\V2\HttpMethod;
use Google\Cloud\Tasks\V2\HttpRequest;
use Google\Cloud\Tasks\V2\Task;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $locationId = 'The Location ID';
// $queueId = 'The Cloud Tasks Queue ID';
// $url = 'The full url path that the task request will be sent to.'
// $payload = 'The payload your task should carry to the task handler. Optional';

// Instantiate the client and queue name.
$client = new CloudTasksClient();
$queueName = $client->queueName($projectId, $locationId, $queueId);

// Create an Http Request Object.
$httpRequest = new HttpRequest();
// The full url path that the task request will be sent to.
$httpRequest->setUrl($url);
// POST is the default HTTP method, but any HTTP method can be used.
$httpRequest->setHttpMethod(HttpMethod::POST);
// Setting a body value is only compatible with HTTP POST and PUT requests.
if (!empty($payload)) {
    $httpRequest->setBody($payload);
}

// Create a Cloud Task object.
$task = new Task();
$task->setHttpRequest($httpRequest);

// Send request and print the task name.
$request = (new CreateTaskRequest())
    ->setParent($queueName)
    ->setTask($task);
$response = $client->createTask($request);
printf('Created task %s' . PHP_EOL, $response->getName());

Notez le fichier composer.json :

{
    "require": {
        "google/cloud-tasks": "^2.0"
    }
}

Python

import datetime
import json
from typing import Dict, Optional

from google.cloud import tasks_v2
from google.protobuf import duration_pb2, timestamp_pb2


def create_http_task(
    project: str,
    location: str,
    queue: str,
    url: str,
    json_payload: Dict,
    scheduled_seconds_from_now: Optional[int] = None,
    task_id: Optional[str] = None,
    deadline_in_seconds: Optional[int] = None,
) -> tasks_v2.Task:
    """Create an HTTP POST task with a JSON payload.
    Args:
        project: The project ID where the queue is located.
        location: The location where the queue is located.
        queue: The ID of the queue to add the task to.
        url: The target URL of the task.
        json_payload: The JSON payload to send.
        scheduled_seconds_from_now: Seconds from now to schedule the task for.
        task_id: ID to use for the newly created task.
        deadline_in_seconds: The deadline in seconds for task.
    Returns:
        The newly created task.
    """

    # Create a client.
    client = tasks_v2.CloudTasksClient()

    # Construct the task.
    task = tasks_v2.Task(
        http_request=tasks_v2.HttpRequest(
            http_method=tasks_v2.HttpMethod.POST,
            url=url,
            headers={"Content-type": "application/json"},
            body=json.dumps(json_payload).encode(),
        ),
        name=(
            client.task_path(project, location, queue, task_id)
            if task_id is not None
            else None
        ),
    )

    # Convert "seconds from now" to an absolute Protobuf Timestamp
    if scheduled_seconds_from_now is not None:
        timestamp = timestamp_pb2.Timestamp()
        timestamp.FromDatetime(
            datetime.datetime.utcnow()
            + datetime.timedelta(seconds=scheduled_seconds_from_now)
        )
        task.schedule_time = timestamp

    # Convert "deadline in seconds" to a Protobuf Duration
    if deadline_in_seconds is not None:
        duration = duration_pb2.Duration()
        duration.FromSeconds(deadline_in_seconds)
        task.dispatch_deadline = duration

    # Use the client to send a CreateTaskRequest.
    return client.create_task(
        tasks_v2.CreateTaskRequest(
            # The queue to add the task to
            parent=client.queue_path(project, location, queue),
            # The task itself
            task=task,
        )
    )

Notez le fichier requirements.txt :

google-cloud-tasks==2.18.0

Ruby

require "google/cloud/tasks"

# Create a Task with an HTTP Target
#
# @param [String] project_id Your Google Cloud Project ID.
# @param [String] location_id Your Google Cloud Project Location ID.
# @param [String] queue_id Your Google Cloud Tasks Queue ID.
# @param [String] url The full path to sent the task request to.
# @param [String] payload The request body of your task.
# @param [Integer] seconds The delay, in seconds, to process your task.
def create_http_task project_id, location_id, queue_id, url, payload: nil, seconds: nil
  # Instantiates a client.
  client = Google::Cloud::Tasks.cloud_tasks

  # Construct the fully qualified queue name.
  parent = client.queue_path project: project_id, location: location_id, queue: queue_id

  # Construct task.
  task = {
    http_request: {
      http_method: "POST",
      url:         url
    }
  }

  # Add payload to task body.
  task[:http_request][:body] = payload if payload

  # Add scheduled time to task.
  if seconds
    timestamp = Google::Protobuf::Timestamp.new
    timestamp.seconds = Time.now.to_i + seconds.to_i
    task[:schedule_time] = timestamp
  end

  # Send create task request.
  puts "Sending task #{task}"

  response = client.create_task parent: parent, task: task

  puts "Created task #{response.name}" if response.name
end

Créer une tâche à l'aide de la méthode `BufferTask`

Cette section explique comment créer une tâche en envoyant une requête HTTP. La méthode que vous utilisez s'appelle BufferTask.

Limites

La méthode BufferTask est soumise aux limites suivantes :

Bibliothèques clientes : la méthode BufferTask n'est pas acceptée dans les bibliothèques clientes.
API RPC : la méthode BufferTask n'est pas compatible avec l'API RPC.
Routage au niveau des tâches : cette méthode n'est pas compatible avec le routage au niveau des tâches. Étant donné qu'il n'y a aucun endroit où ajouter des informations de routage lorsque vous créez une tâche de cette manière, vous devez utiliser le routage au niveau de la file d'attente (sinon, la tâche ne comporte aucune information de routage). Si votre file d'attente n'utilise pas déjà le routage au niveau de la file d'attente, consultez Configurer le routage au niveau de la file d'attente pour les tâches HTTP.

Appelez la méthode `BufferTask`.

Les exemples suivants montrent comment créer une tâche en envoyant une requête HTTP POST au point de terminaison buffer de l'API Cloud Tasks.

curl

L'extrait de code suivant montre un exemple de création de tâche à l'aide de la méthode BufferTask avec curl :

curl -X HTTP_METHOD\
"https://cloudtasks.googleapis.com/v2/projects/PROJECT_ID/locations/LOCATION/queues/QUEUE_ID/tasks:buffer" \

Remplacez les éléments suivants :

HTTP_METHOD : méthode HTTP de votre requête (par exemple, GET ou POST).
PROJECT_ID : ID de votre projet Google Cloud . Pour l'obtenir, exécutez la commande suivante dans votre terminal :
```
gcloud config get-value project
```
LOCATION : emplacement de votre file d'attente.
QUEUE_ID : ID de votre file d'attente.

Python

from google.cloud import tasks_v2beta3 as tasks

import requests


def send_task_to_http_queue(
    queue: tasks.Queue, body: str = "", token: str = "", headers: dict = {}
) -> int:
    """Send a task to an HTTP queue.
    Args:
        queue: The queue to send task to.
        body: The body of the task.
        auth_token: An authorization token for the queue.
        headers: Headers to set on the task.
    Returns:
        The matching queue, or None if it doesn't exist.
    """

    # Use application default credentials if not supplied in a header
    if token:
        headers["Authorization"] = f"Bearer {token}"

    endpoint = f"https://cloudtasks.googleapis.com/v2beta3/{queue.name}/tasks:buffer"
    response = requests.post(endpoint, body, headers=headers)

    return response.status_code

Configurer un compte de service pour l'authentification des gestionnaires HTTP Target

Cloud Tasks peut appeler des gestionnaires HTTP Target nécessitant une authentification si vous disposez d'un compte de service avec les identifiants appropriés pour accéder au gestionnaire.

Vous pouvez utiliser votre compte de service actuel si vous lui attribuez les rôles appropriés. Ces instructions concernent la création d'un compte de service spécifique pour cette fonction. Le compte de service nouveau ou existant utilisé pour l'authentification Cloud Tasks doit se trouver dans le même projet que vos files d'attente Cloud Tasks.

Dans la console Google Cloud , accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Si nécessaire, sélectionnez le projet approprié.
Cliquez sur Créer un compte de service.
Dans la section Détails du compte de service, attribuez un nom au compte. La console crée un nom de compte de messagerie associé pour le compte. C'est ainsi que vous référencez le compte. Vous pouvez également ajouter une description de l'objet du compte. Cliquez sur Créer et continuer.
Dans la section Autoriser ce compte de service à accéder au projet, cliquez sur Sélectionner un rôle. Recherchez et sélectionnez Empileur Cloud Tasks. Ce rôle donne au compte de service l'autorisation d'ajouter des tâches à la file d'attente.
Cliquez sur + Ajouter un autre rôle.
Cliquez sur Sélectionner un rôle. Recherchez et sélectionnez Utilisateur du compte de service. Ce rôle permet au compte de service d'autoriser la file d'attente à créer des jetons en son nom à l'aide des identifiants du compte de service.
Si votre gestionnaire fait partie de Google Cloud, attribuez au compte de service le rôle associé à l'accès au service sur lequel votre gestionnaire s'exécute. Chaque service au sein de Google Cloud nécessite un rôle différent. Par exemple, pour accéder à un gestionnaire sur Cloud Run, attribuez le rôle Demandeur Cloud Run. Vous pouvez utiliser le compte de service que vous venez de créer ou tout autre compte de service dans votre projet.
Cliquez sur OK pour terminer la création du compte de service.

Cloud Tasks lui-même doit posséder son propre compte de service doté du rôle Cloud Tasks Service Agent. Cela lui permet de générer des jetons d'en-tête basés sur les identifiants associés au compte de service Cloud Tasks pour s'authentifier auprès de votre cible de gestionnaire. Le compte de service Cloud Tasks auquel ce rôle est attribué est automatiquement créé lorsque vous activez l'API Cloud Tasks, sauf si vous l'avez activée avant le 19 mars 2019, auquel cas vous devez ajouter le rôle manuellement.

Utiliser des tâches HTTP Target avec des jetons d'authentification

Pour vous authentifier entre Cloud Tasks et un gestionnaire HTTP Target qui nécessite une authentification, Cloud Tasks crée un jeton d'en-tête. Ce jeton est basé sur les identifiants du compte de service Cloud Tasks Enqueuer, identifié par son adresse e-mail. Le compte de service utilisé pour l'authentification doit faire partie du même projet que celui dans lequel se trouve votre file d'attente Cloud Tasks. La requête avec le jeton d'en-tête est envoyée de la file d'attente au gestionnaire par HTTPS. Vous pouvez utiliser un jeton d'identité ou un jeton d'accès. Il est généralement recommandé d'utiliser des jetons d'identité pour tous les gestionnaires exécutés sur Google Cloud, par exemple sur Cloud Functions ou Cloud Run. La principale exception concerne les API Google hébergées sur *.googleapis.com : ces API attendent un jeton d'accès.

Vous pouvez configurer l'authentification au niveau de la file d'attente ou de la tâche. Pour configurer l'authentification au niveau de la file d'attente, consultez Créer des files d'attente Cloud Tasks. Si l'authentification est configurée au niveau de la file d'attente, cette configuration remplace celle au niveau de la tâche. Pour configurer l'authentification au niveau de la tâche, spécifiez un jeton d'identité (OIDC) ou un jeton d'accès (OAuth) dans la tâche elle-même.

Méthode `CreateTask`

Les exemples suivants utilisent la méthode CreateTask avec les bibliothèques clientes Cloud Tasks pour créer une tâche qui inclut également la création d'un jeton d'en-tête. Des jetons d'identité sont utilisés dans les exemples. Pour utiliser un jeton d'accès, remplacez le paramètre OIDC par le paramètre OAuth approprié au langage dans la construction de la requête.

Go

import (
	"context"
	"fmt"

	cloudtasks "cloud.google.com/go/cloudtasks/apiv2"
	taskspb "cloud.google.com/go/cloudtasks/apiv2/cloudtaskspb"
)

// createHTTPTaskWithToken constructs a task with a authorization token
// and HTTP target then adds it to a Queue.
func createHTTPTaskWithToken(projectID, locationID, queueID, url, email, message string) (*taskspb.Task, error) {
	// Create a new Cloud Tasks client instance.
	// See https://godoc.org/cloud.google.com/go/cloudtasks/apiv2
	ctx := context.Background()
	client, err := cloudtasks.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %w", err)
	}
	defer client.Close()

	// Build the Task queue path.
	queuePath := fmt.Sprintf("projects/%s/locations/%s/queues/%s", projectID, locationID, queueID)

	// Build the Task payload.
	// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2#CreateTaskRequest
	req := &taskspb.CreateTaskRequest{
		Parent: queuePath,
		Task: &taskspb.Task{
			// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2#HttpRequest
			MessageType: &taskspb.Task_HttpRequest{
				HttpRequest: &taskspb.HttpRequest{
					HttpMethod: taskspb.HttpMethod_POST,
					Url:        url,
					AuthorizationHeader: &taskspb.HttpRequest_OidcToken{
						OidcToken: &taskspb.OidcToken{
							ServiceAccountEmail: email,
						},
					},
				},
			},
		},
	}

	// Add a payload message if one is present.
	req.Task.GetHttpRequest().Body = []byte(message)

	createdTask, err := client.CreateTask(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("cloudtasks.CreateTask: %w", err)
	}

	return createdTask, nil
}

Java

import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.HttpRequest;
import com.google.cloud.tasks.v2.OidcToken;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.nio.charset.Charset;

public class CreateHttpTaskWithToken {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String locationId = "us-central1";
    String queueId = "my-queue";
    String serviceAccountEmail =
        "java-docs-samples-testing@java-docs-samples-testing.iam.gserviceaccount.com";
    createTask(projectId, locationId, queueId, serviceAccountEmail);
  }

  // Create a task with a HTTP target and authorization token using the Cloud Tasks client.
  public static void createTask(
      String projectId, String locationId, String queueId, String serviceAccountEmail)
      throws IOException {

    // Instantiates a client.
    try (CloudTasksClient client = CloudTasksClient.create()) {
      String url =
          "https://example.com/taskhandler"; // The full url path that the request will be sent to
      String payload = "Hello, World!"; // The task HTTP request body

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

      // Add your service account email to construct the OIDC token.
      // in order to add an authentication header to the request.
      OidcToken.Builder oidcTokenBuilder =
          OidcToken.newBuilder().setServiceAccountEmail(serviceAccountEmail);

      // Construct the task body.
      Task.Builder taskBuilder =
          Task.newBuilder()
              .setHttpRequest(
                  HttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(payload, Charset.defaultCharset()))
                      .setHttpMethod(HttpMethod.POST)
                      .setUrl(url)
                      .setOidcToken(oidcTokenBuilder)
                      .build());

      // Send create task request.
      Task task = client.createTask(queuePath, taskBuilder.build());
      System.out.println("Task created: " + task.getName());
    }
  }
}

Notez le fichier pom.xml :

<?xml version='1.0' encoding='UTF-8'?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example.tasks</groupId>
  <artifactId>cloudtasks-snippets</artifactId>
  <packaging>jar</packaging>
  <name>Google Cloud Tasks Snippets</name>

  <!--
    The parent pom defines common style checks and testing strategies for our samples.
    Removing or replacing it should not affect the execution of the samples in anyway.
  -->
  <parent>
    <groupId>com.google.cloud.samples</groupId>
    <artifactId>shared-configuration</artifactId>
    <version>1.2.0</version>
  </parent>

  <properties>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>


  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>libraries-bom</artifactId>
        <version>26.32.0</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.google.truth</groupId>
      <artifactId>truth</artifactId>
      <version>1.4.0</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Node.js

// Imports the Google Cloud Tasks library.
const {CloudTasksClient} = require('@google-cloud/tasks');

// Instantiates a client.
const client = new CloudTasksClient();

async function createHttpTaskWithToken() {
  // TODO(developer): Uncomment these lines and replace with your values.
  // const project = 'my-project-id';
  // const queue = 'my-queue';
  // const location = 'us-central1';
  // const url = 'https://example.com/taskhandler';
  // const serviceAccountEmail = 'client@<project-id>.iam.gserviceaccount.com';
  // const payload = 'Hello, World!';

  // Construct the fully qualified queue name.
  const parent = client.queuePath(project, location, queue);

  const task = {
    httpRequest: {
      headers: {
        'Content-Type': 'text/plain', // Set content type to ensure compatibility your application's request parsing
      },
      httpMethod: 'POST',
      url,
      oidcToken: {
        serviceAccountEmail,
      },
    },
  };

  if (payload) {
    task.httpRequest.body = Buffer.from(payload).toString('base64');
  }

  console.log('Sending task:');
  console.log(task);
  // Send create task request.
  const request = {parent: parent, task: task};
  const [response] = await client.createTask(request);
  const name = response.name;
  console.log(`Created task ${name}`);
}
createHttpTaskWithToken();

Notez le fichier package.json :

{
  "name": "appengine-cloudtasks",
  "description": "Google App Engine Cloud Tasks example.",
  "license": "Apache-2.0",
  "author": "Google Inc.",
  "private": true,
  "engines": {
    "node": ">=16.0.0"
  },
  "files": [
    "*.js"
  ],
  "scripts": {
    "test": "c8 mocha -p -j 2 --timeout 30000",
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/tasks": "^5.0.0",
    "express": "^4.16.3"
  },
  "devDependencies": {
    "c8": "^10.0.0",
    "chai": "^4.5.0",
    "mocha": "^10.0.0",
    "uuid": "^10.0.0"
  }
}

Python

from typing import Optional

from google.cloud import tasks_v2


def create_http_task_with_token(
    project: str,
    location: str,
    queue: str,
    url: str,
    payload: bytes,
    service_account_email: str,
    audience: Optional[str] = None,
) -> tasks_v2.Task:
    """Create an HTTP POST task with an OIDC token and an arbitrary payload.
    Args:
        project: The project ID where the queue is located.
        location: The location where the queue is located.
        queue: The ID of the queue to add the task to.
        url: The target URL of the task.
        payload: The payload to send.
        service_account_email: The service account to use for generating the OIDC token.
        audience: Audience to use when generating the OIDC token.
    Returns:
        The newly created task.
    """

    # Create a client.
    client = tasks_v2.CloudTasksClient()

    # Construct the request body.
    task = tasks_v2.Task(
        http_request=tasks_v2.HttpRequest(
            http_method=tasks_v2.HttpMethod.POST,
            url=url,
            oidc_token=tasks_v2.OidcToken(
                service_account_email=service_account_email,
                audience=audience,
            ),
            body=payload,
        ),
    )

    # Use the client to build and send the task.
    return client.create_task(
        tasks_v2.CreateTaskRequest(
            parent=client.queue_path(project, location, queue),
            task=task,
        )
    )

Notez le fichier requirements.txt :

google-cloud-tasks==2.18.0

Méthode `BufferTask`

Les exemples suivants utilisent les identifiants par défaut de l'application pour s'authentifier lors de l'utilisation de la méthode BufferTask pour créer une tâche.

curl

curl -X HTTP_METHOD\
"https://cloudtasks.googleapis.com/v2/projects/PROJECT_ID/locations/LOCATION/queues/QUEUE_ID/tasks:buffer" \
    -H "Authorization: Bearer ACCESS_TOKEN"

Remplacez les éléments suivants :

HTTP_METHOD : méthode HTTP de votre requête (par exemple, GET ou POST).
PROJECT_ID : ID de votre projet Google Cloud . Pour l'obtenir, exécutez la commande suivante dans votre terminal :
```
gcloud config get-value project
```
LOCATION : emplacement de votre file d'attente.
QUEUE_ID : ID de votre file d'attente.
ACCESS_TOKEN : votre jeton d'accès. Pour l'obtenir, exécutez la commande suivante dans votre terminal :
```
gcloud auth application-default login
```

gcloud auth application-default print-access-token

Python

Dans l'exemple de code suivant, indiquez la valeur de votre jeton d'authentification.

from google.cloud import tasks_v2beta3 as tasks

import requests


def send_task_to_http_queue(
    queue: tasks.Queue, body: str = "", token: str = "", headers: dict = {}
) -> int:
    """Send a task to an HTTP queue.
    Args:
        queue: The queue to send task to.
        body: The body of the task.
        auth_token: An authorization token for the queue.
        headers: Headers to set on the task.
    Returns:
        The matching queue, or None if it doesn't exist.
    """

    # Use application default credentials if not supplied in a header
    if token:
        headers["Authorization"] = f"Bearer {token}"

    endpoint = f"https://cloudtasks.googleapis.com/v2beta3/{queue.name}/tasks:buffer"
    response = requests.post(endpoint, body, headers=headers)

    return response.status_code

Fournir vos propres gestionnaires de tâches cibles HTTP

Les gestionnaires de tâches HTTP Target ressemblent beaucoup aux gestionnaires de tâches App Engine, aux exceptions près suivantes :

Délais avant expiration : pour tous les gestionnaires de tâches HTTP Target, le délai avant expiration par défaut est de 10 minutes, avec un maximum de 30 minutes.
Logique d'authentification : si vous écrivez votre propre code dans le service ciblé pour valider le jeton, vous devez utiliser un jeton d'identité. Pour plus d'informations sur ce sujet, consultez la page OpenID Connect, en particulier la section Valider un jeton d'ID.

En-têtes : une requête HTTP Target comporte des en-têtes définis par la file d'attente, qui contiennent des informations propres à la tâche, que votre gestionnaire peut utiliser. Ils sont semblables aux en-têtes définis dans les requêtes de tâches App Engine, mais pas identiques. Ces en-têtes fournissent des informations uniquement. Ils ne doivent pas être utilisés comme sources d'identité.

Si ces en-têtes étaient présents dans une requête d'utilisateur externe adressée à votre application, ils sont remplacés par des en-têtes internes. La seule exception concerne les requêtes des administrateurs connectés à l'application, qui sont autorisés à définir des en-têtes à des fins de test.

Les requêtes HTTP Target contiennent toujours les en-têtes suivants :

En-tête	Description
`X-CloudTasks-QueueName`	Nom de la file d'attente.
`X-CloudTasks-TaskName`	Nom "court" de la tâche ou, si aucun nom n'a été spécifié lors de la création, identifiant unique généré par le système. Il s'agit de la valeur `my-task-id` dans le nom complet de la tâche, par exemple task_name = `projects/my-project-id/locations/my-location/queues/my-queue-id/tasks/my-task-id`.
`X-CloudTasks-TaskRetryCount`	Nombre de fois où une tâche a fait l'objet de nouvelles tentatives d'exécution. Pour la première tentative, cette valeur est définie sur `0`. Ce chiffre inclut les tentatives lorsque la tâche a échoué en raison de codes d'erreur 5XX et n'a jamais atteint la phase d'exécution.
`X-CloudTasks-TaskExecutionCount`	Nombre total de fois où la tâche a reçu une réponse du gestionnaire. Étant donné que Cloud Tasks supprime la tâche une fois la réponse reçue, toutes les réponses précédentes du gestionnaire sont des échecs. Ce chiffre n'inclut pas les échecs dus à des codes d'erreur 5XX.
`X-CloudTasks-TaskETA`	Heure de planification de la tâche spécifiée en secondes depuis le 1er janvier 1970.

En outre, les requêtes Cloud Tasks peuvent contenir les en-têtes suivants :

En-tête	Description
`X-CloudTasks-TaskPreviousResponse`	Code de réponse HTTP de la tentative précédente.
`X-CloudTasks-TaskRetryReason`	Raison de la nouvelle tentative d'exécution de la tâche.

Ajouter manuellement le rôle "Agent de service Cloud Tasks"

Vous pouvez ajouter manuellement le rôle Agent de service Cloud Tasks (roles/cloudtasks.serviceAgent) à votre compte de service Cloud Tasks, qui est l'agent de service principal pour Cloud Tasks.

Cela n'est nécessaire que si vous avez activé l'API Cloud Tasks avant le 19 mars 2019.

Console

Recherchez et copiez le numéro de votre projet Google Cloud sur la page Bienvenue de la console Google Cloud .
Dans la console Google Cloud , accédez à la page IAM.

Accéder à IAM
Cliquez sur Accorder l'accès. Le volet Accorder l'accès s'affiche.
Dans la section Ajouter des comptes principaux, ajoutez une adresse e-mail au format suivant :
```
 service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com
 
```
Remplacez PROJECT_NUMBER par le numéro de votre projet Google Cloud .
Dans la section Attribuer des rôles, recherchez et sélectionnez Agent de service Cloud Tasks.
Cliquez sur Enregistrer.

gcloud

Recherchez le numéro de votre projet :
```
gcloud projects describe PROJECT_ID --format='table(projectNumber)'
```
Remplacez PROJECT_ID par l'ID du projet.
Copiez le numéro.
Attribuez le rôle Cloud Tasks Service Agent au compte de service Cloud Tasks en utilisant le numéro de projet que vous avez copié :
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com \
    --role roles/cloudtasks.serviceAgent
```
Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet Google Cloud .
- PROJECT_NUMBER : numéro de votre projet Google Cloud.

Autres configurations

Vous pouvez configurer plusieurs attributs de tâches. Pour obtenir la liste complète, consultez la définition de la ressource Task. Par exemple, vous pouvez personnaliser les attributs suivants :

Nommage : si vous choisissez de nommer la tâche, Cloud Tasks peut utiliser ce nom pour assurer la déduplication de la tâche, bien que le traitement nécessaire puisse augmenter la latence.
Programmation : vous pouvez programmer une tâche pour une date ultérieure. Cette fonctionnalité est disponible pour CreateTask uniquement, et non pour BufferTask.

Vous pouvez également configurer des attributs de file d'attente tels que les remplacements de routage, les limites de débit et les paramètres de nouvelle tentative. Ces configurations s'appliquent à toutes les tâches d'une file d'attente. Pour en savoir plus, consultez Configurer des files d'attente Cloud Tasks.

Étapes suivantes

Apprenez-en davantage sur les tâches HTTP Target dans la documentation de référence de l'API RPC.
Apprenez-en plus sur les tâches HTTP Target dans la documentation de référence de l'API REST.

Créer des tâches cibles HTTP Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Créer une tâche à l'aide de la méthode CreateTask

C#

Go

Java

Node.js

PHP

Python

Ruby

Créer une tâche à l'aide de la méthode BufferTask

Limites

Appelez la méthode BufferTask.

curl

Python

Configurer un compte de service pour l'authentification des gestionnaires HTTP Target

Utiliser des tâches HTTP Target avec des jetons d'authentification

Méthode CreateTask

Go

Java

Node.js

Python

Méthode BufferTask

curl

Python

Fournir vos propres gestionnaires de tâches cibles HTTP

Ajouter manuellement le rôle "Agent de service Cloud Tasks"

Console

gcloud

Autres configurations

Étapes suivantes

Créer des tâches cibles HTTP

Créer une tâche à l'aide de la méthode `CreateTask`

Créer une tâche à l'aide de la méthode `BufferTask`

Appelez la méthode `BufferTask`.

Méthode `CreateTask`

Méthode `BufferTask`