Créer des tâches HTTP Target

Avec cette version bêta de HTTP Targets, les gestionnaires Cloud Tasks peuvent désormais être exécutés sur n'importe quel point de terminaison HTTP doté d'une adresse IP publique, par exemple Cloud Functions, Cloud Run, 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 montre comment créer de façon automatisée des tâches HTTP Target et comment les placer dans des files d'attente Cloud Tasks. En général, vous créez des tâches sous la forme d'une requête HTTP. L'utilisation des bibliothèques clientes Google Cloud et d'un compte de service, comme dans les exemples suivants, peut vous aider à gérer les détails de communication avec le serveur Cloud Tasks et faciliter la création de tâches.

Tâches HTTP Target

Les exemples suivants créent des requêtes permettant de construire des tâches HTTP Target, y compris l'URL du gestionnaire de tâches.

C#

using Google.Cloud.Tasks.V2Beta3;
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;
    }
}

Python

"""Create a task for a given queue with an arbitrary payload."""

from google.cloud import tasks_v2beta3
from google.protobuf import timestamp_pb2

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

# TODO(developer): Uncomment these lines and replace with your values.
# project = 'my-project-id'
# queue = 'my-queue'
# location = 'us-central1'
# url = 'https://example.com/task_handler'
# payload = 'hello'

# Construct the fully qualified queue name.
parent = client.queue_path(project, location, queue)

# Construct the request body.
task = {
        'http_request': {  # Specify the type of request.
            'http_method': 'POST',
            'url': url  # The full url path that the task will be sent to.
        }
}
if payload is not None:
    # The API expects a payload of type bytes.
    converted_payload = payload.encode()

    # Add the payload to the request.
    task['http_request']['body'] = converted_payload

if in_seconds is not None:
    # Convert "seconds from now" into an rfc3339 datetime string.
    d = datetime.datetime.utcnow() + datetime.timedelta(seconds=in_seconds)

    # Create Timestamp protobuf.
    timestamp = timestamp_pb2.Timestamp()
    timestamp.FromDatetime(d)

    # Add the timestamp to the tasks.
    task['schedule_time'] = timestamp

# Use the client to build and send the task.
response = client.create_task(parent, task)

print('Created task {}'.format(response.name))
return response

Notez le fichier requirements.txt :

Flask==1.0.2
gunicorn==19.9.0
google-cloud-tasks==0.7.0

Java

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

public class CreateHttpTask {

  public static void main(String[] args) throws Exception {
    String projectId = System.getenv("PROJECT_ID");
    String queueName = System.getenv("QUEUE_ID");
    String location = System.getenv("LOCATION_ID");
    String url = System.getenv("URL");

    // Instantiates a client.
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // Variables provided by the system variables.
      // projectId = "my-project-id";
      // queueName = "my-queue";
      // location = "us-central1";
      // url = "https://example.com/taskhandler";
      String payload = "hello";

      // Construct the fully qualified queue name.
      String queuePath = QueueName.of(projectId, location, queueName).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"?>
<!--
Copyright 2018 Google LLC

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->
<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>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <groupId>com.example.task</groupId>
  <artifactId>tasks-samples</artifactId>

  <!--
    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.0.11</version>
    <relativePath></relativePath>
  </parent>

  <properties>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
    <failOnMissingWebXml>false</failOnMissingWebXml>
  </properties>

  <dependencies>
    <!-- Compile/runtime dependencies -->
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
      <version>0.88.0-beta</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.4.0</version>
        <executions>
          <execution>
              <id>HttpTask</id>
              <goals>
                  <goal>java</goal>
              </goals>
              <configuration>
                <mainClass>com.example.task.CreateHttpTask</mainClass>
                <cleanupDaemonThreads>false</cleanupDaemonThreads>
              </configuration>
          </execution>
          <execution>
              <id>WithToken</id>
              <goals>
                  <goal>java</goal>
              </goals>
              <configuration>
                <mainClass>com.example.task.CreateHttpTaskWithToken</mainClass>
                <cleanupDaemonThreads>false</cleanupDaemonThreads>
              </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

PHP

use Google\Cloud\Tasks\V2beta3\CloudTasksClient;
use Google\Cloud\Tasks\V2beta3\HttpMethod;
use Google\Cloud\Tasks\V2beta3\HttpRequest;
use Google\Cloud\Tasks\V2beta3\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 (isset($payload)) {
    $httpRequest->setBody($payload);
}

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

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

Notez le fichier composer.json :

{
    "require": {
        "google/cloud-tasks": "^1.0.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^5",
        "google/cloud-tools": "^0.8.5"
    }
}

Go

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

import (
	"context"
	"fmt"

	cloudtasks "cloud.google.com/go/cloudtasks/apiv2beta3"
	taskspb "google.golang.org/genproto/googleapis/cloud/tasks/v2beta3"
)

// createHTTPTask creates a new task in your with a HTTP target.
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/apiv2beta3
	ctx := context.Background()
	client, err := cloudtasks.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %v", err)
	}

	// 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/v2beta3#CreateTaskRequest
	req := &taskspb.CreateTaskRequest{
		Parent: queuePath,
		Task: &taskspb.Task{
			// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2beta3#HttpRequest
			PayloadType: &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: %v", err)
	}

	return createdTask, nil
}

Node.js

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

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

// 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';

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

const task = {
  httpRequest: {
    httpMethod: 'POST',
    url, //The full url path that the request will be sent to.
  },
};

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

if (inSeconds) {
  task.scheduleTime = {
    seconds: inSeconds + Date.now() / 1000,
  };
}

const request = {
  parent: parent,
  task: task,
};

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

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": ">=8"
  },
  "scripts": {
    "test": "mocha",
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/tasks": "^1.0.0",
    "body-parser": "^1.18.3",
    "express": "^4.16.3",
    "yargs": "^13.0.0"
  },
  "devDependencies": {
    "chai": "^4.2.0",
    "mocha": "^6.1.3",
    "uuid": "^3.3.2"
  }
}

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.new

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

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

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

  # 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, task

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

Configurer des comptes de service pour l'authentification des gestionnaires HTTP Target

Cloud Tasks peut appeler les gestionnaires HTTP Target nécessitant une authentification si le compte de service de votre projet dispose des identifiants appropriés pour accéder au gestionnaire.

  1. Identifiez un compte de service existant à utiliser pour l'appel de Cloud Tasks à votre gestionnaire HTTP Target, ou créez un compte de service à cette fin. Il s'agit du compte de service client.

  2. Si votre gestionnaire fait partie de GCP, mettez à jour votre compte de service client en lui attribuant le rôle IAM nécessaire. Chaque service au sein de GCP exige un rôle différent. Par exemple, Cloud Run exige le rôle Cloud Run Invoker (Demandeur Cloud Run), et ainsi de suite.

  3. Cloud Tasks lui-même doit disposer de son propre compte de service doté du rôle Cloud Tasks Service Agent (Agent de service Cloud Tasks). Cela lui permet de générer des jetons d'en-tête au nom de votre compte de service client en vue de l'authentification auprès de la cible de votre 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.

Tâches HTTP Target avec des jetons d'authentification

Dans le cadre de l'authentification entre Cloud Tasks et un gestionnaire HTTP Target, Cloud Tasks crée un jeton d'en-tête basé sur votre compte de service client, identifié par son adresse e-mail, et l'envoie via HTTPS au gestionnaire. Vous pouvez utiliser un jeton OIDC ou un jeton OAuth. OIDC est généralement utilisé, sauf pour les API Google hébergées sur *.googleapis.com. Ces API attendent en effet un jeton OAuth. Vous spécifiez OIDC ou OAuth dans la requête proprement dite.

Les exemples suivants créent des requêtes de tâches qui incluent également la création d'un jeton d'en-tête. Des jetons OIDC sont utilisés dans les exemples. Pour utiliser un jeton OAuth, remplacez le paramètre OIDC par le paramètre OAuth approprié au langage dans la construction de la requête.

Python

"""Create a task for a given queue with an arbitrary payload."""

from google.cloud import tasks_v2beta3
from google.protobuf import timestamp_pb2

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

# TODO(developer): Uncomment these lines and replace with your values.
# project = 'my-project-id'
# queue = 'my-queue'
# location = 'us-central1'
# url = 'https://example.com/task_handler'
# payload = 'hello'

# Construct the fully qualified queue name.
parent = client.queue_path(project, location, queue)

# Construct the request body.
task = {
        'http_request': {  # Specify the type of request.
            'http_method': 'POST',
            'url': url,  # The full url path that the task will be sent to.
            'oidc_token': {
                'service_account_email': service_account_email
            }
        }
}

if payload is not None:
    # The API expects a payload of type bytes.
    converted_payload = payload.encode()

    # Add the payload to the request.
    task['http_request']['body'] = converted_payload

if in_seconds is not None:
    # Convert "seconds from now" into an rfc3339 datetime string.
    d = datetime.datetime.utcnow() + datetime.timedelta(seconds=in_seconds)

    # Create Timestamp protobuf.
    timestamp = timestamp_pb2.Timestamp()
    timestamp.FromDatetime(d)

    # Add the timestamp to the tasks.
    task['schedule_time'] = timestamp

# Use the client to build and send the task.
response = client.create_task(parent, task)

print('Created task {}'.format(response.name))
return response

Notez le fichier requirements.txt :

Flask==1.0.2
gunicorn==19.9.0
google-cloud-tasks==0.7.0

Java

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

public class CreateHttpTaskWithToken {

  public static void main(String[] args) throws Exception {
    String projectId = System.getenv("PROJECT_ID");
    String queueName = System.getenv("QUEUE_ID");
    String location = System.getenv("LOCATION_ID");
    String url = System.getenv("URL");

    // Instantiates a client.
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // Variables provided by the system variables.
      // projectId = "my-project-id";
      // queueName = "my-queue";
      // location = "us-central1";
      // url = "https://example.com/taskhandler";
      String payload = "hello";

      // Construct the fully qualified queue name.
      String queuePath = QueueName.of(projectId, location, queueName).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("<SERVICE_ACCOUNT_EMAIL>");

      // 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"?>
<!--
Copyright 2018 Google LLC

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->
<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>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <groupId>com.example.task</groupId>
  <artifactId>tasks-samples</artifactId>

  <!--
    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.0.11</version>
    <relativePath></relativePath>
  </parent>

  <properties>
    <maven.compiler.target>1.8</maven.compiler.target>
    <maven.compiler.source>1.8</maven.compiler.source>
    <failOnMissingWebXml>false</failOnMissingWebXml>
  </properties>

  <dependencies>
    <!-- Compile/runtime dependencies -->
    <dependency>
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-tasks</artifactId>
      <version>0.88.0-beta</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.4.0</version>
        <executions>
          <execution>
              <id>HttpTask</id>
              <goals>
                  <goal>java</goal>
              </goals>
              <configuration>
                <mainClass>com.example.task.CreateHttpTask</mainClass>
                <cleanupDaemonThreads>false</cleanupDaemonThreads>
              </configuration>
          </execution>
          <execution>
              <id>WithToken</id>
              <goals>
                  <goal>java</goal>
              </goals>
              <configuration>
                <mainClass>com.example.task.CreateHttpTaskWithToken</mainClass>
                <cleanupDaemonThreads>false</cleanupDaemonThreads>
              </configuration>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Go

import (
	"context"
	"fmt"

	cloudtasks "cloud.google.com/go/cloudtasks/apiv2beta3"
	taskspb "google.golang.org/genproto/googleapis/cloud/tasks/v2beta3"
)

// 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/apiv2beta3
	ctx := context.Background()
	client, err := cloudtasks.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %v", err)
	}

	// 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/v2beta3#CreateTaskRequest
	req := &taskspb.CreateTaskRequest{
		Parent: queuePath,
		Task: &taskspb.Task{
			// https://godoc.org/google.golang.org/genproto/googleapis/cloud/tasks/v2beta3#HttpRequest
			PayloadType: &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: %v", err)
	}

	return createdTask, nil
}

Node.js

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

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

// 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 email = 'client@<project-id>.iam.gserviceaccount.com'
// const payload = 'hello';

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

const task = {
  httpRequest: {
    httpMethod: 'POST',
    url, //The full url path that the request will be sent to.
    oidcToken: {
      serviceAccountEmail: email,
    },
  },
};

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

if (inSeconds) {
  task.scheduleTime = {
    seconds: inSeconds + Date.now() / 1000,
  };
}

const request = {
  parent: parent,
  task: task,
};

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

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": ">=8"
  },
  "scripts": {
    "test": "mocha",
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/tasks": "^1.0.0",
    "body-parser": "^1.18.3",
    "express": "^4.16.3",
    "yargs": "^13.0.0"
  },
  "devDependencies": {
    "chai": "^4.2.0",
    "mocha": "^6.1.3",
    "uuid": "^3.3.2"
  }
}

Fournir vos propres gestionnaires de tâches HTTP Target

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 OIDC. Pour plus d'informations sur ce sujet, consultez la page OpenID Connect, en particulier la section Valider un jeton d'ID.

Ajouter manuellement le rôle "Agent de service Cloud Tasks" à votre compte de service Cloud Tasks

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

Utiliser la console

  1. Recherchez le numéro de votre projet sur la page Paramètres du projet GCP.
  2. Copiez le numéro.
  3. Ouvrez la page Console d'administration IAM.
  4. Cliquez sur Ajouter. L'écran Add members (Ajouter des membres) s'ouvre.
  5. Dans la boîte de dialogue "New members" (Nouveaux membres), 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 projet déterminé ci-dessus.

  6. Dans la liste déroulante Select a role (Sélectionnez un rôle), choisissez Service Management -> Cloud Tasks Service Agent (Agent de service Cloud Tasks).

  7. Cliquez sur Save.

Utiliser gcloud

  1. Recherchez le numéro de votre projet :

    gcloud projects describe [project-id] --format='table(projectNumber)'
    

    Pour ce faire, remplacez [project-id] par l'ID du projet.

  2. Copiez le numéro.

  3. Attribuez au compte de service Cloud Tasks le rôle Cloud Tasks Service Agent (Agent 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
    

    Pour ce faire, remplacez [project-id] par l'ID du projet, et [project-number] par le numéro de projet déterminé ci-dessus.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Cloud Tasks