Esta página se ha traducido con Cloud Translation API.

Crear tareas de destino HTTP

Los controladores de Cloud Tasks se pueden ejecutar en cualquier endpoint HTTP con una dirección IP externa, como GKE, Compute Engine o incluso un servidor web on-premise. Tus tareas se pueden ejecutar en cualquiera de estos servicios de forma fiable y configurable.

En esta página se muestra cómo crear mediante programación tareas de destino HTTP básicas y colocarlas en colas de Cloud Tasks. En la guía de inicio rápido se muestra cómo hacerlo con la CLI de Google Cloud.

En el caso de las tareas que tienen destinos HTTP (en lugar de destinos explícitos de App Engine, que son menos habituales), hay dos formas de crear tareas:

Método CreateTask: debes crear explícitamente un objeto de tarea. Usa este método si las tareas de tu cola tienen configuraciones de enrutamiento diferentes. En este caso, se especifica el enrutamiento a nivel de tarea y no se puede usar el enrutamiento a nivel de cola. Este enfoque usa el método CreateTask.
Método BufferTask: usa este método si tu cola está configurada para almacenar en búfer las tareas delante de un servicio. La cola debe tener un enrutamiento a nivel de cola. Este enfoque usa el método BufferTask.

Crear una tarea con el método `CreateTask`

En esta sección se explica cómo crear una tarea construyendo el objeto de tarea. Usas el método CreateTask.

Cuando creas una tarea con el método CreateTask, creas y defines explícitamente el objeto de tarea. Debes especificar el servicio y el controlador que procesan la tarea.

También puedes enviar datos específicos de la tarea al controlador. También puedes ajustar la configuración de la tarea, como programar una hora en el futuro para que se ejecute o limitar el número de veces que quieres que se vuelva a intentar la tarea si falla (consulta Configuración avanzada).

En los siguientes ejemplos se llama al método CreateTask para crear una tarea mediante las bibliotecas de cliente de 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());
    }
  }
}

Ten en cuenta el archivo 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();

Ten en cuenta el archivo 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());

Ten en cuenta el archivo 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,
        )
    )

Ten en cuenta el archivo 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

Crear una tarea con el método `BufferTask`

En esta sección se explica cómo crear una tarea enviando una solicitud HTTP. El método que usas se llama BufferTask.

Limitaciones

El método BufferTask está sujeto a las siguientes limitaciones:

Bibliotecas de cliente: el método BufferTask no se admite en las bibliotecas de cliente.
API RPC: el método BufferTask no se admite en la API RPC.
Ruta a nivel de tarea: este método no admite el enrutamiento a nivel de tarea. Como no hay ningún sitio donde añadir información de enrutamiento al crear una tarea de esta forma, debes usar el enrutamiento a nivel de cola (de lo contrario, la tarea no tendrá información de enrutamiento). Si tu cola aún no usa el enrutamiento a nivel de cola, consulta Configurar el enrutamiento a nivel de cola para tareas HTTP.

Llama al método `BufferTask`

En los siguientes ejemplos se muestra cómo crear una tarea enviando una solicitud HTTP POST al endpoint buffer de la API Cloud Tasks.

curl

El siguiente fragmento de código muestra un ejemplo de creación de tareas con el método BufferTask mediante curl:

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

Haz los cambios siguientes:

HTTP_METHOD: el método HTTP de tu solicitud. Por ejemplo, GET o POST.
PROJECT_ID: el ID de tu proyecto de Google Cloud . Para obtenerlo, ejecuta lo siguiente en tu terminal:
```
gcloud config get-value project
```
LOCATION: la ubicación de tu cola.
QUEUE_ID: el ID de tu cola.

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

Configurar una cuenta de servicio para la autenticación del controlador de destino HTTP

Cloud Tasks puede llamar a controladores de destino HTTP que requieran autenticación si tienes una cuenta de servicio con las credenciales adecuadas para acceder al controlador.

Puedes usar tu cuenta de servicio actual si le asignas los roles adecuados. Estas instrucciones explican cómo crear una cuenta de servicio específicamente para esta función. La cuenta de servicio que se use para la autenticación de Cloud Tasks debe estar en el mismo proyecto que tus colas de Cloud Tasks.

En la Google Cloud consola, ve a la página Cuentas de servicio.

Ir a Cuentas de servicio
Si es necesario, selecciona el proyecto adecuado.
Haz clic en Crear cuenta de servicio.
En la sección Detalles de la cuenta de servicio, asigna un nombre a la cuenta. La consola crea un nombre de cuenta de correo relacionado para la cuenta. Así es como se hace referencia a la cuenta. También puedes añadir una descripción de la cuenta. Haz clic en Crear y continuar.
En la sección Conceder a esta cuenta de servicio acceso al proyecto, haz clic en Seleccionar un rol. Busca y selecciona Cloud Tasks Enqueuer. Este rol da permiso a la cuenta de servicio para añadir tareas a la cola.
Haz clic en + Añadir otro rol.
Haz clic en Selecciona un rol. Busca y selecciona Usuario de cuenta de servicio. Este rol permite que la cuenta de servicio autorice a la cola para que cree tokens en su nombre con las credenciales de la cuenta de servicio.
Si tu controlador forma parte de Google Cloud, concede a la cuenta de servicio el rol asociado al acceso al servicio en el que se ejecuta tu controlador. Cada servicio de Google Cloud requiere un rol diferente. Por ejemplo, para acceder a un controlador en Cloud Run, concede el rol Invocador de Cloud Run. Puedes usar la cuenta de servicio que acabas de crear o cualquier otra cuenta de servicio de tu proyecto.
Haz clic en Hecho para terminar de crear la cuenta de servicio.

Cloud Tasks debe tener su propia cuenta de servicio con el rol Cloud Tasks Service Agent asignado. De esta forma, puede generar tokens de encabezado basados en las credenciales asociadas a la cuenta de servicio de Cloud Tasks para autenticarse en el destino del controlador. La cuenta de servicio de Cloud Tasks con este rol asignado se crea automáticamente cuando habilitas la API Cloud Tasks, a menos que la hayas habilitado antes del 19 de marzo del 2019, en cuyo caso debes añadir el rol manualmente.

Usar tareas de destino HTTP con tokens de autenticación

Para autenticar la comunicación entre Cloud Tasks y un controlador de destino HTTP que requiera autenticación, Cloud Tasks crea un token de encabezado. Este token se basa en las credenciales de la cuenta de servicio Cloud Tasks Enqueuer, identificada por su dirección de correo. La cuenta de servicio que se usa para la autenticación debe formar parte del mismo proyecto en el que se encuentre tu cola de Cloud Tasks. La solicitud, con el token de encabezado, se envía de la cola al controlador mediante HTTPS. Puedes usar un token de ID o un token de acceso. Los tokens de ID se deben usar generalmente en cualquier controlador que se ejecute en Google Cloud, por ejemplo, en funciones o en Cloud Run. La principal excepción son las APIs de Google alojadas en *.googleapis.com, que requieren un token de acceso.

Puedes configurar la autenticación a nivel de cola o de tarea. Para configurar la autenticación a nivel de cola, consulta Crear colas de Cloud Tasks. Si la autenticación se configura a nivel de cola, esta configuración anula la configuración a nivel de tarea. Para configurar la autenticación a nivel de tarea, especifica un token de ID (OIDC) o un token de acceso (OAuth) en la propia tarea.

Método `CreateTask`

En los siguientes ejemplos se usa el método CreateTask con las bibliotecas de cliente de Cloud Tasks para crear una tarea que también incluye la creación de un token de encabezado. En los ejemplos se usan tokens de ID. Para usar un token de acceso, sustituye el parámetro OIDC por el parámetro de OAuth adecuado para el idioma al crear la solicitud.

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());
    }
  }
}

Ten en cuenta el archivo 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();

Ten en cuenta el archivo 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,
        )
    )

Ten en cuenta el archivo requirements.txt:

google-cloud-tasks==2.18.0

Método `BufferTask`

En los siguientes ejemplos se usan las credenciales predeterminadas de la aplicación para autenticar al usar el método BufferTask para crear una tarea.

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"

Haz los cambios siguientes:

HTTP_METHOD: el método HTTP de tu solicitud. Por ejemplo, GET o POST.
PROJECT_ID: el ID de tu proyecto de Google Cloud . Para obtenerlo, ejecuta lo siguiente en tu terminal:
```
gcloud config get-value project
```
LOCATION: la ubicación de tu cola.
QUEUE_ID: el ID de tu cola.
ACCESS_TOKEN: tu token de acceso. Para obtenerlo, ejecuta lo siguiente en tu terminal:
```
gcloud auth application-default login
```

gcloud auth application-default print-access-token

Python

En el siguiente ejemplo de código, proporcione el valor de su token de autenticación.

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

Proporcionar tus propios controladores de tareas de destino HTTP

Los controladores de tareas de destino HTTP son muy similares a los controladores de tareas de App Engine, con las siguientes excepciones:

Tiempos de espera: el tiempo de espera predeterminado de todos los controladores de tareas de destino HTTP es de 10 minutos, con un máximo de 30 minutos.
Lógica de autenticación: si vas a escribir tu propio código en el servicio de destino para validar el token, debes usar un token de ID. Para obtener más información sobre lo que implica, consulta OpenID Connect, en concreto la sección Validar un token de ID.

Encabezados: una solicitud de destino HTTP tiene encabezados definidos por la cola, que contienen información específica de la tarea que puede usar tu controlador. Son similares a los encabezados definidos en las solicitudes de tareas de App Engine, pero no idénticos. Estas cabeceras solo proporcionan información. No se deben usar como fuentes de identidad.

Si estos encabezados estaban presentes en una solicitud de un usuario externo a tu aplicación, se sustituirán por los internos. La única excepción son las solicitudes de administradores que hayan iniciado sesión en la aplicación, que pueden definir encabezados con fines de prueba.

Las solicitudes de destino HTTP siempre contienen los siguientes encabezados:

Header	Descripción
`X-CloudTasks-QueueName`	El nombre de la cola.
`X-CloudTasks-TaskName`	El nombre "corto" de la tarea o, si no se ha especificado ningún nombre al crearla, un ID único generado por el sistema. Este es el valor de `my-task-id` en el nombre completo de la tarea, es decir, task_name = `projects/my-project-id/locations/my-location/queues/my-queue-id/tasks/my-task-id`.
`X-CloudTasks-TaskRetryCount`	El número de veces que se ha intentado la ejecución de esta tarea. En el primer intento, este valor es `0`. Este número incluye los intentos en los que la tarea ha fallado debido a códigos de error 5XX y nunca ha llegado a la fase de ejecución.
`X-CloudTasks-TaskExecutionCount`	Número total de veces que la tarea ha recibido una respuesta del controlador. Como Cloud Tasks elimina la tarea una vez que se ha recibido una respuesta correcta, todas las respuestas anteriores del controlador han fallado. En esta cifra no se incluyen los fallos debidos a códigos de error 5XX.
`X-CloudTasks-TaskETA`	La hora programada de la tarea, especificada en segundos desde el 1 de enero de 1970.

Además, las solicitudes de Cloud Tasks pueden contener los siguientes encabezados:

Header	Descripción
`X-CloudTasks-TaskPreviousResponse`	El código de respuesta HTTP del reintento anterior.
`X-CloudTasks-TaskRetryReason`	El motivo por el que se vuelve a intentar realizar la tarea.

Añadir manualmente el rol Agente de servicio de Cloud Tasks

Puedes añadir manualmente el rol Agente de servicio de Cloud Tasks (roles/cloudtasks.serviceAgent) a tu cuenta de servicio de Cloud Tasks, que es el agente de servicio principal de Cloud Tasks.

Esto solo es necesario si habilitaste la API Cloud Tasks antes del 19 de marzo del 2019.

Consola

Busca y copia el número de tu proyecto Google Cloud en la página Bienvenido de la consola Google Cloud .
En la consola, ve a la página IAM. Google Cloud

Ir a IAM
Haz clic en Conceder acceso. Se abrirá el panel Dar acceso.
En la sección Añadir principales, añade una dirección de correo con este formato:
```
 service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com
 
```
Sustituye PROJECT_NUMBER por el Google Cloud número de tu proyecto.
En la sección Asignar roles, busca y selecciona Agente de servicio de Cloud Tasks.
Haz clic en Guardar.

gcloud

Para encontrar tu número de proyecto, sigue estos pasos:
```
gcloud projects describe PROJECT_ID --format='table(projectNumber)'
```
Sustituye PROJECT_ID por el ID del proyecto.
Copia el número.
Asigna el rol Cloud Tasks Service Agent a la cuenta de servicio de Cloud Tasks con el número de proyecto que has copiado:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com \
    --role roles/cloudtasks.serviceAgent
```
Haz los cambios siguientes:
- PROJECT_ID: tu ID de proyecto Google Cloud .
- PROJECT_NUMBER: tu Google Cloud número de proyecto.

Otras configuraciones

Puedes configurar varios atributos de las tareas. Para ver una lista completa, consulta la definición del recurso Task. Por ejemplo, puedes personalizar los siguientes atributos:

Nombres: si decides especificar un nombre para la tarea, Cloud Tasks puede usarlo para asegurarse de que no se duplique, aunque el procesamiento necesario para ello puede aumentar la latencia.
Programación: puedes programar una tarea para más adelante. Esta opción solo está disponible para CreateTask y no para BufferTask.

También puede configurar atributos de la cola, como las anulaciones de enrutamiento, los límites de frecuencia y los parámetros de reintento. Estas configuraciones se aplican a todas las tareas de una cola. Para obtener más información, consulta Configurar colas de Cloud Tasks.

Siguientes pasos

Consulta más información sobre las tareas de destino HTTP en la referencia de la API RPC.
Consulta más información sobre las tareas de destino HTTP en la referencia de la API REST.

Crear tareas de destino HTTP Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Crear una tarea con el método CreateTask

C#

Go

Java

Node.js

PHP

Python

Ruby

Crear una tarea con el método BufferTask

Limitaciones

Llama al método BufferTask

curl

Python

Configurar una cuenta de servicio para la autenticación del controlador de destino HTTP

Usar tareas de destino HTTP con tokens de autenticación

Método CreateTask

Go

Java

Node.js

Python

Método BufferTask

curl

Python

Proporcionar tus propios controladores de tareas de destino HTTP

Añadir manualmente el rol Agente de servicio de Cloud Tasks

Consola

gcloud

Otras configuraciones

Siguientes pasos

Crear tareas de destino HTTP

Crear una tarea con el método `CreateTask`

Crear una tarea con el método `BufferTask`

Llama al método `BufferTask`

Método `CreateTask`

Método `BufferTask`