Esta página foi traduzida pela API Cloud Translation.

Criar tarefas de destino HTTP

Os gerenciadores do Cloud Tasks podem ser executados em qualquer endpoint HTTP com um endereço IP externo, como GKE, Compute Engine ou até mesmo um servidor da Web local. Execute sua tarefas em qualquer um desses serviços de forma confiável e configurável.

Nesta página, mostramos como criar tarefas básicas de destino HTTP de forma programática e colocá-las em filas do Cloud Tasks. O guia de início rápido mostra como fazer isso usando a Google Cloud CLI.

Para tarefas com destinos HTTP (em vez de destinos explícitos do App Engine, que são menos comuns), há duas maneiras de criar tarefas:

Método CreateTask:você precisa criar um objeto de tarefa de maneira explícita. Use esse método se as tarefas na sua fila tiverem configurações de roteamento diferentes. Nesse caso, você especifica o roteamento no nível da tarefa e não pode usar o roteamento no nível da fila. Essa abordagem usa o método CreateTask.
Método BufferTask:use esse método se a fila estiver configurada para armazenar tarefas em buffer na frente de um serviço. A fila precisa ter roteamento no nível da fila. Essa abordagem usa o método BufferTask.

Criar uma tarefa usando o método `CreateTask`

Esta seção discute a criação de uma tarefa construindo o objeto de tarefa. Use o método CreateTask.

Ao criar uma tarefa usando o método CreateTask, você cria e define explicitamente o objeto de tarefa. É preciso especificar o serviço e o gerenciador que processam a tarefa.

Se quiser, passe dados específicos da tarefa para o manipulador. Também é possível ajustar a configuração da tarefa, como agendar um horário para que ela seja executada ou limitar o número de vezes que a tarefa será repetida se falhar (consulte Configuração avançada).

Os exemplos a seguir chamam o método CreateTask para criar uma tarefa usando as bibliotecas de cliente do 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());
    }
  }
}

Observe o arquivo 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();

Observe o arquivo 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());

Observe o arquivo 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,
        )
    )

Observe o arquivo 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

Criar uma tarefa usando o método `BufferTask`

Esta seção explica como criar uma tarefa enviando uma solicitação HTTP. O método usado é chamado de BufferTask.

Limitações

O método BufferTask está sujeito às seguintes limitações:

Bibliotecas de cliente:o método BufferTask não é compatível com bibliotecas de cliente.
API RPC:o método BufferTask não é compatível com a API RPC.
Roteamento no nível da tarefa:esse método não oferece suporte ao roteamento no nível da tarefa. Como não há onde adicionar informações de roteamento ao criar uma tarefa dessa forma, você precisa usar o roteamento no nível da fila. Caso contrário, a tarefa não terá informações de roteamento. Se a fila ainda não usar o roteamento no nível da fila, consulte Configurar o roteamento no nível da fila para tarefas HTTP.

Chame o método `BufferTask`

Os exemplos a seguir mostram como criar uma tarefa enviando uma solicitação HTTP POST ao endpoint buffer da API Cloud Tasks.

curl

O snippet de código a seguir mostra um exemplo de criação de tarefas usando o método BufferTask com curl:

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

Substitua:

HTTP_METHOD: o método HTTP da sua solicitação, por exemplo, GET ou POST.
PROJECT_ID: o ID do seu projeto do Google Cloud . Para isso, execute o seguinte no terminal:
```
gcloud config get-value project
```
LOCATION: o local da fila.
QUEUE_ID: o ID da fila.

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 uma conta de serviço para autenticação do gerenciador de destino HTTP

O Cloud Tasks pode chamar gerenciadores de destino HTTP que exigem autenticação se você tiver uma conta de serviço com as credenciais apropriadas para acessar o gerenciador.

Você pode usar sua conta de serviço atual se conceder a ela os papéis apropriados. Estas instruções abrangem a criação de uma nova conta de serviço especificamente para essa função. A conta de serviço nova ou atual usada para a autenticação do Cloud Tasks precisa estar no mesmo projeto que as filas do Cloud Tasks.

No console Google Cloud , acesse a página Contas de serviço.

Acessar a página "Contas de serviço"
Se necessário, selecione o projeto apropriado.
Clique em Criar conta de serviço.
Dê um nome à sua conta de serviço. Anote o endereço de e-mail relacionado que é gerado no console. Você vai procurar esse e-mail em uma etapa posterior. Para copiar o e-mail, clique em Copiar para a área de transferência . Você também pode adicionar uma descrição da finalidade da conta.
Clique em Criar e continuar.
Na lista Selecionar um papel, pesquise e selecione Enfileirador do Cloud Tasks (Beta). Esse papel concede à conta de serviço permissão para adicionar tarefas à fila.
Se você estiver usando um gerenciador de Google Cloud , clique em + Adicionar outro papel para conceder à conta de serviço o papel associado ao acesso ao serviço em que o gerenciador está sendo executado. Cada serviço no Google Cloud requer uma função diferente. Por exemplo, para acessar um gerenciador no Cloud Run, conceda o papel Chamador do Cloud Run.
Para concluir a criação da conta de serviço, clique em Concluído.
Para permitir que o Cloud Tasks crie tokens de autenticação usando a conta de serviço que você acabou de criar, conceda o papel Usuário da conta de serviço (roles/iam.serviceAccountUser) ao agente de serviço principal do Cloud Tasks na conta de serviço que você acabou de criar.
1. No console Google Cloud , acesse a página Contas de serviço.
  
  Acesse as Contas de serviço
2. Na linha da conta de serviço que você acabou de criar, marque a caixa de seleção e clique em Gerenciar acesso.
3. No painel Gerenciar acesso, clique em Adicionar principal.
4. Na lista Novos principais, pesquise e selecione o agente de serviço do Cloud Tasks, que terá um endereço de e-mail no formato service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com.
5. Na lista Selecionar um papel, pesquise e selecione o papel Usuário da conta de serviço.
6. Clique em Salvar.

Usar tarefas de destino HTTP com tokens de autenticação

Para autenticar entre o Cloud Tasks e um gerenciador de destino HTTP que requer essa autenticação, o Cloud Tasks cria um token de cabeçalho. Esse token é baseado nas credenciais na conta de serviço Cloud Tasks Enqueuer, identificada pelo endereço de e-mail. A conta de serviço usada para autenticação precisa fazer parte do mesmo projeto em que a fila do Cloud Tasks reside. A solicitação, com o token de cabeçalho, é enviada da fila para o gerenciador por HTTPS. É possível usar um token de ID ou um token de acesso. Os tokens de ID geralmente precisam ser usados em qualquer gerenciador em execução no Google Cloud, por exemplo, em funções do Cloud Run ou no Cloud Run. A principal exceção é para APIs do Google hospedadas em *.googleapis.com: essas APIs esperam um token de acesso.

É possível configurar a autenticação no nível da fila ou da tarefa. Para configurar a autenticação no nível da fila, consulte Como limitar o acesso a filas únicas. Se a autenticação for configurada no nível da fila, essa configuração vai substituir a configuração no nível da tarefa. Para configurar a autenticação no nível da tarefa, especifique um token de ID (OIDC) ou um token de acesso (OAuth) na tarefa em si.

Método `CreateTask`

Os exemplos a seguir usam o método CreateTask com as bibliotecas de cliente do Cloud Tasks para criar uma tarefa que também inclui a criação de um token de cabeçalho. Os tokens de ID são usados nos exemplos. Para usar um token de acesso, substitua o parâmetro OIDC pelo parâmetro OAuth apropriado da linguagem ao criar uma solicitação.

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

Observe o arquivo 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();

Observe o arquivo 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,
        )
    )

Observe o arquivo requirements.txt:

google-cloud-tasks==2.18.0

Método `BufferTask`

Os exemplos a seguir usam as credenciais padrão do aplicativo para autenticar ao usar o método BufferTask para criar uma tarefa.

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"

Substitua:

HTTP_METHOD: o método HTTP da sua solicitação, por exemplo, GET ou POST.
PROJECT_ID: o ID do seu projeto do Google Cloud . Para isso, execute o seguinte no terminal:
```
gcloud config get-value project
```
LOCATION: o local da fila.
QUEUE_ID: o ID da fila.
ACCESS_TOKEN: seu token de acesso. Para isso, execute o seguinte no terminal:
```
gcloud auth application-default login
```

gcloud auth application-default print-access-token

Python

No exemplo de código a seguir, forneça o valor do seu token de autenticação.

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

Fornecer seus próprios gerenciadores de tarefas de destino HTTP

Os gerenciadores de tarefas de HTTP Target são muito parecidos com os gerenciadores de tarefas do App Engine, com as seguintes exceções:

Tempos limites: para todos os gerenciadores de tarefas de destino HTTP, o tempo limite padrão é de 10 minutos, com um máximo de 30 minutos.
Lógica de autenticação: ao escrever o próprio código no serviço de destino para validar o token, você precisa usar um token de ID. Para mais informações, consulte OpenID Connect (em inglês), especialmente Como validar um token de ID (em inglês).

Cabeçalhos: uma solicitação de destino HTTP tem cabeçalhos definidos pela fila, que contém informações específicas da tarefa que seu gerenciador pode usar. Eles são semelhantes, mas não idênticos, aos cabeçalhos definidos nas solicitações de tarefas do App Engine. Esses cabeçalhos fornecem apenas informações. Eles não devem ser usados como fontes de identidade.

Se esses cabeçalhos estiverem presentes em uma solicitação de usuário externo ao seu app, eles serão substituídos pelos internos. A única exceção é para solicitações de administradores conectados do aplicativo, que podem definir cabeçalhos para fins de teste.

As solicitações de destino HTTP sempre contêm os seguintes cabeçalhos:

Cabeçalho	Descrição
`X-CloudTasks-QueueName`	O nome da fila.
`X-CloudTasks-TaskName`	O nome abreviado da tarefa ou, se nenhum nome foi especificado na criação, um código exclusivo gerado pelo sistema. Esse é o valor `my-task-id` no nome completo da tarefa, ou seja, task_name = `projects/my-project-id/locations/my-location/queues/my-queue-id/tasks/my-task-id`.
`X-CloudTasks-TaskRetryCount`	O número de novas tentativas para a tarefa. Para a primeira tentativa, esse valor é `0`. Esse número inclui tentativas em que a tarefa falhou devido a códigos de erro 5XX e nunca chegou à fase de execução.
`X-CloudTasks-TaskExecutionCount`	O número total de vezes em que a tarefa recebeu uma resposta do gerenciador. Como o Cloud Tasks exclui a tarefa depois que uma resposta bem-sucedida foi recebida, todas as respostas anteriores do gerenciador falharam. Esse número não inclui falhas devido a códigos de erro 5XX.
`X-CloudTasks-TaskETA`	O horário de agendamento da tarefa, especificado em segundos desde 1º de janeiro de 1970.

Além disso, as solicitações do Cloud Tasks podem conter os seguintes cabeçalhos:

Cabeçalho	Descrição
`X-CloudTasks-TaskPreviousResponse`	O código de resposta HTTP da tentativa anterior.
`X-CloudTasks-TaskRetryReason`	O motivo para tentar novamente a tarefa.

Adicionar manualmente o papel de agente de serviço do Cloud Tasks

É possível adicionar manualmente o papel Agente de serviço do Cloud Tasks (roles/cloudtasks.serviceAgent) à sua conta de serviço do Cloud Tasks, que é o agente de serviço principal do Cloud Tasks.

Isso é necessário somente se você ativou a API Cloud Tasks antes de 19 de março de 2019.

Console

Encontre e copie o número do projeto Google Cloud na página Boas-vindas do console Google Cloud .
No console do Google Cloud , acesse a página IAM.

Acessar IAM
Clique em Conceder acesso. O painel Conceder acesso é aberto.
Na seção Adicionar principais, adicione um endereço de e-mail neste formato:
```
 service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com
 
```
Substitua PROJECT_NUMBER pelo Google Cloud número do projeto.
Na seção Atribuir papéis, pesquise e selecione Agente de serviço do Cloud Tasks.
Clique em Salvar.

gcloud

Encontre seu número do projeto:
```
gcloud projects describe PROJECT_ID --format='table(projectNumber)'
```
Substitua PROJECT_ID pela ID do seu projeto.
Copie o número.
Conceda à conta de serviço do Cloud Tasks o papel Cloud Tasks Service Agent, usando o número do projeto que você copiou:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member serviceAccount:service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com \
    --role roles/cloudtasks.serviceAgent
```
Substitua:
- PROJECT_ID: o ID do projeto Google Cloud .
- PROJECT_NUMBER: o número do projeto Google Cloud.

Outras configurações

Há vários atributos de tarefa que podem ser configurados. Para uma lista completa, consulte a definição de recursos de tarefa. Por exemplo, é possível personalizar os seguintes atributos:

Nomeação:se você especificar um nome para a tarefa, o Cloud Tasks poderá usá-lo para garantir a eliminação da duplicação de tarefas, embora o processamento necessário para isso possa aumentar a latência.
Programação:é possível programar uma tarefa para um horário futuro. Esse recurso é compatível apenas com CreateTask e não com BufferTask.

Também é possível configurar atributos da fila, como substituições de roteamento, limites de taxa e parâmetros de nova tentativa. Essas configurações são aplicadas a todas as tarefas em uma fila. Para mais informações, consulte Configurar filas do Cloud Tasks.

A seguir

Saiba mais sobre as tarefas de destino HTTP na referência da API RPC.
Saiba mais sobre as tarefas de destino HTTP na referência da API REST.

Criar tarefas de destino HTTP Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Criar uma tarefa usando o método CreateTask

C#

Go

Java

Node.js

PHP

Python

Ruby

Criar uma tarefa usando o método BufferTask

Limitações

Chame o método BufferTask

curl

Python

Configurar uma conta de serviço para autenticação do gerenciador de destino HTTP

Usar tarefas de destino HTTP com tokens de autenticação

Método CreateTask

Go

Java

Node.js

Python

Método BufferTask

curl

Python

Fornecer seus próprios gerenciadores de tarefas de destino HTTP

Adicionar manualmente o papel de agente de serviço do Cloud Tasks

Console

gcloud

Outras configurações

A seguir

Criar tarefas de destino HTTP

Criar uma tarefa usando o método `CreateTask`

Criar uma tarefa usando o método `BufferTask`

Chame o método `BufferTask`

Método `CreateTask`

Método `BufferTask`