Esta página foi traduzida pela API Cloud Translation.

Crie tarefas de destino HTTP

Os processadores do Cloud Tasks podem ser executados em qualquer ponto final HTTP com um endereço IP externo, como o GKE, o Compute Engine ou até mesmo um servidor Web no local. As suas tarefas podem ser executadas em qualquer um destes serviços de forma fiável e configurável.

Esta página demonstra como criar programaticamente tarefas de destino HTTP básicas e colocá-las em filas do Cloud Tasks. O início rápido demonstra como fazê-lo através da CLI Google Cloud.

Para tarefas que têm destinos HTTP (em oposição a destinos explícitos do App Engine, que são menos comuns), existem duas formas de criar tarefas:

Método CreateTask:tem de criar explicitamente um objeto de tarefa. Use este método se as tarefas na fila tiverem configurações de encaminhamento diferentes. Neste caso, especifica o encaminhamento ao nível da tarefa e não pode usar o encaminhamento ao nível da fila. Esta abordagem usa o método CreateTask.
Método BufferTask: use este método se a sua fila estiver configurada para armazenar tarefas em buffer antes de um serviço. A fila tem de ter encaminhamento ao nível da fila. Esta abordagem usa o método BufferTask.

Crie uma tarefa através do método `CreateTask`

Esta secção aborda a criação de uma tarefa através da construção do objeto de tarefa. Usar o método CreateTask.

Quando cria uma tarefa através do método CreateTask, cria e define explicitamente o objeto de tarefa. Tem de especificar o serviço e o controlador que processam a tarefa.

Opcionalmente, pode transmitir dados específicos da tarefa ao controlador. Também pode ajustar a configuração da tarefa, como agendar uma hora no futuro em que deve ser executada ou limitar o número de vezes que quer que a tarefa seja repetida se falhar (consulte Configuração avançada).

Os exemplos seguintes chamam o método CreateTask para criar uma tarefa através das bibliotecas 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;
    }
}

Ir


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

Tenha em atenção o ficheiro 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();

Tenha em atenção o ficheiro 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());

Tenha em atenção o ficheiro 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,
        )
    )

Tenha em atenção o ficheiro 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

Crie uma tarefa através do método `BufferTask`

Esta secção aborda a criação de uma tarefa através do envio de um pedido HTTP. O método que usa chama-se BufferTask.

Limitações

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

Bibliotecas cliente: o método BufferTask não é suportado em bibliotecas cliente.
API RPC: o método BufferTask não é suportado na API RPC.
Encaminhamento ao nível da tarefa: este método não suporta o encaminhamento ao nível da tarefa. Uma vez que não existe nenhum local para adicionar informações de encaminhamento quando cria uma tarefa desta forma, tem de usar o encaminhamento ao nível da fila (caso contrário, a tarefa não tem informações de encaminhamento). Se a sua fila ainda não usar o encaminhamento ao nível da fila, consulte o artigo Configure o encaminhamento ao nível da fila para tarefas HTTP.

Chame o método `BufferTask`

Os exemplos seguintes mostram como criar uma tarefa enviando um pedido HTTP para o ponto final da POSTAPI Cloud Tasksbuffer.

curl

O fragmento do código seguinte mostra um exemplo de criação de tarefas com o método BufferTask usando curl:

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

Substitua o seguinte:

HTTP_METHOD: o método HTTP para o seu pedido; por exemplo, GET ou POST.
PROJECT_ID: o ID do seu projeto Google Cloud . Pode obter esta informação executando o seguinte no terminal:
```
gcloud config get-value project
```
LOCATION: a localização da sua fila.
QUEUE_ID: o ID da sua 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

Configure uma conta de serviço para a autenticação do controlador de destino HTTP

O Cloud Tasks pode chamar controladores de destino HTTP que requerem autenticação se tiver uma conta de serviço com as credenciais adequadas para aceder ao controlador.

Pode usar a sua conta de serviço atual se lhe conceder as funções adequadas. Estas instruções abrangem a criação de uma nova conta de serviço especificamente para esta função. A conta de serviço existente ou nova usada para a autenticação do Cloud Tasks tem de estar no mesmo projeto que as suas filas do Cloud Tasks.

Na Google Cloud consola, aceda à página Contas de serviço.

Aceda a Contas de serviço
Se necessário, selecione o projeto adequado.
Clique em Criar conta de serviço.
Na secção Detalhes da conta de serviço, atribua um nome à conta. A consola cria um nome de conta de email relacionado para a conta. É assim que faz referência à conta. Também pode adicionar uma descrição da finalidade da conta. Clique em Criar e continuar.
Na secção Conceda a esta conta de serviço acesso ao projeto, clique em Selecionar uma função. Pesquise e selecione Cloud Tasks Enqueuer. Esta função concede à conta de serviço autorização para adicionar tarefas à fila.
Clique em + Adicionar outra função.
Clique em Selecionar uma função. Pesquise e selecione Utilizador da conta de serviço. Esta função permite que a conta de serviço autorize a fila a criar tokens em seu nome através das credenciais da conta de serviço.
Se o seu controlador fizer parte do Google Cloud, conceda à conta de serviço a função associada ao acesso ao serviço onde o seu controlador está a ser executado. Cada serviço dentro do Google Cloud requer uma função diferente. Por exemplo, para aceder a um controlador no Cloud Run, conceda a função Cloud Run Invoker. Pode usar a conta de serviço que acabou de criar ou qualquer outra conta de serviço no seu projeto.
Clique em Concluído para terminar de criar a conta de serviço.

O Cloud Tasks tem de ter uma conta de serviço própria com a função Cloud Tasks Service Agent concedida. Isto permite gerar tokens de cabeçalho com base nas credenciais associadas à conta de serviço do Cloud Tasks para autenticação com o destino do controlador. A conta de serviço do Cloud Tasks com esta função concedida é criada automaticamente quando ativa a API Cloud Tasks, a menos que a tenha ativado antes de 19 de março de 2019. Nesse caso, tem de adicionar a função manualmente.

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

Para autenticar entre o Cloud Tasks e um controlador de destino HTTP que requer essa autenticação, o Cloud Tasks cria um token de cabeçalho. Este token baseia-se nas credenciais da conta de serviço Cloud Tasks Enqueuer, identificada pelo respetivo endereço de email. A conta de serviço usada para autenticação tem de fazer parte do mesmo projeto onde reside a fila do Cloud Tasks. O pedido, com o token do cabeçalho, é enviado da fila para o controlador por HTTPS. Pode usar um token de ID ou um token de acesso. Geralmente, os tokens de ID devem ser usados para qualquer controlador em execução no Google Cloud, por exemplo, em funções do Cloud Run ou no Cloud Run. A principal exceção é para as APIs Google alojadas em *.googleapis.com: estas APIs esperam um token de acesso.

Pode configurar a autenticação ao nível da fila ou da tarefa. Para configurar a autenticação ao nível da fila, consulte o artigo Criar filas do Cloud Tasks. Se a autenticação estiver configurada ao nível da fila, esta configuração substitui a configuração ao nível da tarefa. Para configurar a autenticação ao nível da tarefa, especifique um token de ID (OIDC) ou um token de acesso (OAuth) na própria tarefa.

`CreateTask` método

Os exemplos seguintes usam o método CreateTask com as bibliotecas 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 uma chave de acesso, substitua o parâmetro OIDC pelo parâmetro OAuth adequado ao idioma na criação do pedido.

Ir

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

Tenha em atenção o ficheiro 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();

Tenha em atenção o ficheiro 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,
        )
    )

Tenha em atenção o ficheiro requirements.txt:

google-cloud-tasks==2.18.0

`BufferTask` método

Os exemplos seguintes usam as credenciais padrão da aplicação para autenticar quando usam 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 o seguinte:

HTTP_METHOD: o método HTTP para o seu pedido; por exemplo, GET ou POST.
PROJECT_ID: o ID do seu projeto Google Cloud . Pode obter esta informação executando o seguinte no terminal:
```
gcloud config get-value project
```
LOCATION: a localização da sua fila.
QUEUE_ID: o ID da sua fila.
ACCESS_TOKEN: a sua chave de acesso. Pode obter este valor executando o seguinte no seu terminal:
```
gcloud auth application-default login
```

gcloud auth application-default print-access-token

Python

No exemplo de código seguinte, indique o valor do 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

Forneça os seus próprios controladores de tarefas de destino HTTP

Os processadores de tarefas de destino HTTP são muito semelhantes aos processadores de tarefas do App Engine, com as seguintes exceções:

Tempos limite: para todos os controladores de tarefas de destino HTTP, o tempo limite predefinido é de 10 minutos, com um máximo de 30 minutos.
Lógica de autenticação: se estiver a escrever o seu próprio código no serviço segmentado para validar o token, deve usar um token de ID. Para mais informações sobre o que isto implica, consulte OpenID Connect, em particular Validar um token de ID.

Cabeçalhos: um pedido de destino HTTP tem cabeçalhos definidos pela fila, que contêm informações específicas da tarefa que o seu controlador pode usar. Estes são semelhantes, mas não idênticos, aos cabeçalhos definidos nos pedidos de tarefas do App Engine. Estes cabeçalhos fornecem informações apenas. Não devem ser usados como fontes de identidade.

Se estes cabeçalhos estiverem presentes num pedido de um utilizador externo à sua app, são substituídos pelos internos. A única exceção é para pedidos de administradores com sessão iniciada da aplicação, que podem definir cabeçalhos para fins de teste.

Os pedidos de destino HTTP contêm sempre os seguintes cabeçalhos:

Cabeçalho	Descrição
`X-CloudTasks-QueueName`	O nome da fila.
`X-CloudTasks-TaskName`	O nome "curto" da tarefa ou, se não tiver sido especificado nenhum nome na criação, um ID exclusivo gerado pelo sistema. Este é o valor `my-task-id` no nome da tarefa completo, 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 vezes que esta tarefa foi repetida. Para a primeira tentativa, este valor é `0`. Este número inclui tentativas em que a tarefa falhou devido a códigos de erro 5XX e nunca atingiu a fase de execução.
`X-CloudTasks-TaskExecutionCount`	O número total de vezes que a tarefa recebeu uma resposta do controlador. Uma vez que o Cloud Tasks elimina a tarefa assim que recebe uma resposta bem-sucedida, todas as respostas anteriores do controlador foram falhas. Este número não inclui falhas devido a códigos de erro 5XX.
`X-CloudTasks-TaskETA`	A hora agendada da tarefa, especificada em segundos desde 1 de janeiro de 1970.

Além disso, os pedidos do Cloud Tasks podem conter os seguintes cabeçalhos:

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

Adicione manualmente a função de agente do serviço Cloud Tasks

Pode adicionar manualmente a função Agente do serviço Cloud Tasks (roles/cloudtasks.serviceAgent) à sua conta do serviço Cloud Tasks, que é o agente do serviço principal para o Cloud Tasks.

Isto só é necessário se tiver ativado a API Cloud Tasks antes de 19 de março de 2019.

Consola

Encontre e copie o número do projeto para o seu Google Cloud projeto na página Boas-vindas da consola Google Cloud .
Na Google Cloud consola, aceda à página IAM.

Aceda ao IAM
Clique em Conceder acesso. O painel Conceder acesso é aberto.
Na secção Adicionar responsáveis, adicione um endereço de email neste formato:
```
 service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com
 
```
Substitua PROJECT_NUMBER pelo seu Google Cloud número do projeto.
Na secção Atribuir funções, pesquise e selecione Agente de serviço do Cloud Tasks.
Clique em Guardar.

gcloud

Encontre o número do projeto:
```
gcloud projects describe PROJECT_ID --format='table(projectNumber)'
```
Substitua PROJECT_ID pelo ID do seu projeto.
Copie o número.
Conceda à conta de serviço do Cloud Tasks a função Cloud Tasks Service Agent através do número do projeto que 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 o seguinte:
- PROJECT_ID: o ID do Google Cloud projeto.
- PROJECT_NUMBER: o número do seu Google Cloud projeto.

Outras configurações

Existem vários atributos de tarefas que pode configurar. Para ver uma lista completa, consulte a definição do recurso de tarefas. Por exemplo, pode personalizar os seguintes atributos:

Atribuição de nomes: se optar por especificar um nome para a tarefa, o Cloud Tasks pode usar esse nome para garantir a desduplicação de tarefas, embora o processamento necessário para tal possa aumentar a latência.
Agendamento: pode agendar uma tarefa para uma hora futura. Isto é suportado apenas para CreateTask e não é suportado para BufferTask.

Também pode configurar atributos da fila, como substituições de encaminhamento, limites de taxa e parâmetros de repetição. Estas configurações são aplicadas a todas as tarefas numa fila. Para mais informações, consulte o artigo Configure filas do Cloud Tasks.

O que se segue?

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

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

Crie uma tarefa através do método CreateTask

C#

Ir

Java

Node.js

PHP

Python

Ruby

Crie uma tarefa através do método BufferTask

Limitações

Chame o método BufferTask

curl

Python

Configure uma conta de serviço para a autenticação do controlador de destino HTTP

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

CreateTask método

Ir

Java

Node.js

Python

BufferTask método

curl

Python

Forneça os seus próprios controladores de tarefas de destino HTTP

Adicione manualmente a função de agente do serviço Cloud Tasks

Consola

gcloud

Outras configurações

O que se segue?

Crie tarefas de destino HTTP

Crie uma tarefa através do método `CreateTask`

Crie uma tarefa através do método `BufferTask`

Chame o método `BufferTask`

`CreateTask` método

`BufferTask` método