Membuat tugas target HTTP

Pengendali Cloud Tasks dapat dijalankan di endpoint HTTP mana pun dengan alamat IP eksternal seperti GKE, Compute Engine, atau bahkan server web lokal. Tugas Anda dapat dijalankan di salah satu layanan ini dengan cara yang dapat diandalkan dan dikonfigurasi.

Halaman ini menunjukkan cara membuat tugas target HTTP dasar secara terprogram dan menempatkannya di antrean Cloud Tasks.

Untuk tugas yang memiliki target HTTP (bukan target App Engine eksplisit, yang kurang umum), ada dua cara untuk membuat tugas:

  • Metode BufferTask: Gunakan metode ini jika antrean Anda disiapkan untuk menampung tugas di depan layanan. Antrean harus memiliki pemilihan rute tingkat antrean. Untuk sebagian besar kasus penggunaan, ini adalah pendekatan terbaik. Pendekatan ini menggunakan metode BufferTask.

  • Metode CreateTask: Metode ini lebih kompleks. Anda harus membuat objek tugas secara eksplisit. Gunakan metode ini jika tugas dalam antrean Anda memiliki konfigurasi pemilihan rute yang berbeda. Dalam hal ini, Anda menentukan pemilihan rute di level tugas dan tidak dapat menggunakan pemilihan rute tingkat antrean. Pendekatan ini menggunakan metode CreateTask.

Pembuatan tugas dasar (metode BufferTask)

Bagian ini membahas pembuatan tugas dengan mengirim permintaan HTTP. Metode yang Anda gunakan disebut BufferTask.

Batasan

Metode BufferTask tunduk pada batasan berikut:

  • Library klien: Metode BufferTask tidak didukung di library klien.

  • RPC API: Metode BufferTask tidak didukung di RPC API.

  • Pemilihan rute tingkat tugas: Metode ini tidak mendukung pemilihan rute tingkat tugas. Karena tidak ada tempat untuk menambahkan informasi pemilihan rute saat membuat tugas dengan cara ini, Anda harus menggunakan pemilihan rute tingkat antrean (jika tidak, tugas tidak akan memiliki informasi pemilihan rute). Jika antrean Anda belum menggunakan pemilihan rute tingkat antrean, lihat Mengonfigurasi pemilihan rute tingkat antrean untuk tugas HTTP.

Memanggil metode BufferTask

Contoh berikut menunjukkan cara membuat tugas dengan mengirim permintaan POST HTTP ke endpoint buffer Cloud Tasks API.

curl

Cuplikan kode berikut menunjukkan contoh pembuatan tugas menggunakan metode BufferTask menggunakan curl:

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

Ganti kode berikut:

  • HTTP_METHOD: metode HTTP untuk permintaan Anda; misalnya, GET atau POST.
  • PROJECT_ID: ID project Google Cloud Anda. Anda bisa mendapatkannya dengan menjalankan perintah berikut di terminal: 
    gcloud config get-value project
  • LOCATION: lokasi antrean Anda.
  • QUEUE_ID: ID antrean Anda.

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

Pembuatan tugas lanjutan (metode CreateTask)

Bagian ini membahas cara membuat tugas dengan membuat objek tugas. Anda menggunakan metode CreateTask.

Saat membuat tugas menggunakan metode CreateTask, Anda secara eksplisit membuat dan menentukan objek tugas. Anda harus menentukan layanan dan pengendali yang memproses tugas.

Secara opsional, Anda dapat meneruskan data khusus tugas ke pengendali. Anda juga dapat menyesuaikan konfigurasi untuk tugas, seperti menjadwalkan waktu pada masa mendatang saat tugas harus dijalankan atau membatasi frekuensi percobaan ulang tugas yang diinginkan jika gagal (lihat Konfigurasi lanjutan).

Contoh berikut memanggil metode CreateTask untuk membuat tugas menggunakan library klien 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());
    }
  }
}

Perhatikan file 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();

Perhatikan file 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());

Perhatikan file composer.json:

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

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,
        )
    )

Perhatikan file requirements.txt:

google-cloud-tasks==2.13.1

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

Menyiapkan akun layanan untuk autentikasi pengendali target HTTP

Cloud Tasks dapat memanggil pengendali target HTTP yang memerlukan autentikasi jika Anda memiliki akun layanan dengan kredensial yang sesuai untuk mengakses pengendali.

Jika Anda memiliki akun layanan saat ini yang ingin digunakan, Anda dapat melakukannya. Cukup berikan peran yang sesuai. Petunjuk ini membahas cara membuat akun layanan baru khusus untuk fungsi ini. Akun layanan yang ada atau baru yang digunakan untuk autentikasi Cloud Tasks harus berada dalam project yang sama dengan antrean Cloud Tasks Anda.

  1. Di Konsol Google Cloud, buka halaman Service accounts.

    Buka halaman Service accounts

  2. Jika perlu, pilih project yang sesuai.

  3. Klik Create service account.

  4. Di bagian Detail akun layanan, beri nama akun. Konsol akan membuat nama akun email terkait untuk akun tersebut. Ini adalah cara Anda mereferensikan akun. Anda juga dapat menambahkan deskripsi tujuan akun. Klik Buat dan lanjutkan.

  5. Di bagian Berikan akses project ke akun layanan ini, klik Pilih peran. Telusuri dan pilih Cloud Tasks Enqueuer. Peran ini memberi akun layanan izin untuk menambahkan tugas ke antrean.

  6. Klik + Tambahkan peran lain.

  7. Klik Pilih peran. Telusuri dan pilih Service Account User. Peran ini memungkinkan akun layanan mengizinkan antrean membuat token atas namanya menggunakan kredensial akun layanan.

  8. Jika pengendali Anda adalah bagian dari Google Cloud, berikan peran yang terkait dengan akses ke layanan tempat pengendali Anda berjalan kepada akun layanan. Setiap layanan dalam Google Cloud memerlukan peran yang berbeda. Misalnya, untuk mengakses pengendali di Cloud Run, berikan peran Cloud Run Invoker. Anda dapat menggunakan akun layanan yang baru saja dibuat atau akun layanan lainnya di project Anda.

  9. Klik Selesai untuk menyelesaikan pembuatan akun layanan.

Cloud Tasks itu sendiri harus memiliki akun layanan sendiri yang memiliki peran Cloud Tasks Service Agent yang diberikan. Hal ini agar dapat menghasilkan token header berdasarkan kredensial yang terkait dengan akun layanan Cloud Tasks untuk mengautentikasi dengan target pengendali Anda. Akun layanan Cloud Tasks dengan peran ini yang diberikan akan otomatis dibuat saat Anda mengaktifkan Cloud Tasks API, kecuali Anda mengaktifkannya sebelum 19 Maret 2019. Jika demikian, Anda harus menambahkan peran secara manual.

Menggunakan tugas target HTTP dengan token autentikasi

Untuk mengautentikasi antara Cloud Tasks dan pengendali target HTTP yang memerlukan autentikasi tersebut, Cloud Tasks akan membuat token header. Token ini didasarkan pada kredensial di akun layanan Cloud Tasks Enqueuer, yang diidentifikasi oleh alamat emailnya. Akun layanan yang digunakan untuk autentikasi harus merupakan bagian dari project yang sama dengan antrean Cloud Tasks Anda. Permintaan, dengan token header, dikirim dari antrean ke pengendali melalui HTTPS. Anda dapat menggunakan token ID atau token akses. Token ID umumnya harus digunakan untuk pengendali apa pun yang berjalan di Google Cloud, misalnya, pada fungsi Cloud Run atau Cloud Run. Pengecualian utamanya adalah untuk Google API yang dihosting di *.googleapis.com: API ini memerlukan token akses.

Anda dapat mengonfigurasi autentikasi di tingkat antrean, atau di tingkat tugas. Untuk mengonfigurasi autentikasi di tingkat antrean, lihat Membuat antrean Cloud Tasks. Jika autentikasi dikonfigurasi di tingkat antrean, konfigurasi ini akan mengganti konfigurasi di tingkat tugas. Untuk mengonfigurasi autentikasi di tingkat tugas, tentukan token ID (OIDC) atau token akses (OAuth) di tugas itu sendiri.

Metode BufferTask

Contoh berikut menggunakan kredensial default aplikasi untuk melakukan autentikasi saat menggunakan metode BufferTask untuk membuat tugas.

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"

Ganti kode berikut:

  • HTTP_METHOD: metode HTTP untuk permintaan Anda; misalnya, GET atau POST.
  • PROJECT_ID: ID project Google Cloud Anda. Anda bisa mendapatkannya dengan menjalankan perintah berikut di terminal: 
    gcloud config get-value project
  • LOCATION: lokasi antrean Anda.
  • QUEUE_ID: ID antrean Anda.
  • ACCESS_TOKEN: token akses Anda. Anda bisa mendapatkannya dengan menjalankan perintah berikut di terminal:
  • gcloud auth application-default login
  • gcloud auth application-default print-access-token

Python

Dalam contoh kode berikut, berikan nilai token autentikasi Anda.

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

Metode CreateTask

Contoh berikut menggunakan metode CreateTask dengan library klien Cloud Tasks untuk membuat tugas yang juga menyertakan pembuatan token header. Token ID digunakan dalam contoh. Untuk menggunakan token akses, ganti parameter OIDC dengan parameter OAuth yang sesuai bahasa dalam membuat permintaan.

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

Perhatikan file 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();

Perhatikan file 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,
        )
    )

Perhatikan file requirements.txt:

google-cloud-tasks==2.13.1

Menyediakan pengendali tugas target HTTP Anda sendiri

Pengendali tugas Target HTTP sangat mirip dengan pengendali tugas App Engine, dengan pengecualian berikut:

  • Waktu tunggu: untuk semua pengendali tugas target HTTP, waktu tunggu default-nya adalah 10 menit, dengan maksimum 30 menit.
  • Logika autentikasi: jika Anda menulis kode sendiri di layanan yang ditargetkan untuk memvalidasi token, Anda harus menggunakan token ID. Untuk mengetahui informasi selengkapnya tentang hal ini, lihat OpenID Connect, terutama Memvalidasi token ID.

  • Header: permintaan target HTTP memiliki header yang ditetapkan oleh antrean, yang berisi informasi khusus tugas yang dapat digunakan pengendali. Header ini mirip dengan, tetapi tidak identik dengan, header yang ditetapkan pada permintaan tugas App Engine. Header ini hanya memberikan informasi. ID ini tidak boleh digunakan sebagai sumber identitas.

    Jika ada header ini dalam permintaan pengguna eksternal ke aplikasi Anda, header tersebut akan diganti dengan header internal. Satu-satunya pengecualian adalah untuk permintaan dari administrator aplikasi yang login, yang diizinkan menyetel header untuk tujuan pengujian.

    Permintaan target HTTP selalu berisi header berikut:

    Header Deskripsi
    X-CloudTasks-QueueName Nama antrean.
    X-CloudTasks-TaskName Nama "pendek" tugas, atau, jika tidak ada nama yang ditentukan saat pembuatan, ID unik yang dihasilkan sistem. Ini adalah nilai my-task-id dalam nama tugas lengkap, yaitu, task_name = projects/my-project-id/locations/my-location/queues/my-queue-id/tasks/my-task-id.
    X-CloudTasks-TaskRetryCount Frekuensi percobaan ulang tugas ini. Untuk upaya pertama, nilainya adalah 0. Jumlah ini mencakup upaya saat tugas gagal karena kode error 5XX dan tidak pernah mencapai fase eksekusi.
    X-CloudTasks-TaskExecutionCount Total frekuensi tugas menerima respons dari pengendali. Karena Cloud Tasks menghapus tugas setelah respons berhasil diterima, semua respons pengendali sebelumnya gagal. Jumlah ini tidak mencakup kegagalan karena kode error 5XX.
    X-CloudTasks-TaskETA Waktu penjadwalan tugas, ditentukan dalam detik sejak 1 Januari 1970.

    Selain itu, permintaan dari Cloud Tasks mungkin berisi header berikut:

    Header Deskripsi
    X-CloudTasks-TaskPreviousResponse Kode respons HTTP dari percobaan ulang sebelumnya.
    X-CloudTasks-TaskRetryReason Alasan percobaan ulang tugas.

Menambahkan peran Agen Layanan Cloud Tasks ke akun layanan Cloud Tasks secara manual

Tindakan ini hanya diperlukan jika Anda mengaktifkan Cloud Tasks API sebelum 19 Maret 2019.

Konsol

  1. Temukan nomor project untuk project Anda di Halaman Project Settings Google Cloud.
  2. Salin nomor tersebut.
  3. Buka Halaman Konsol Admin IAM.
  4. Klik Grant access. Layar Berikan akses akan terbuka.

  5. Di bagian Tambahkan akun utama, tambahkan alamat email dengan format: 

     service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com

    Ganti PROJECT_NUMBER dengan nomor project Google Cloud Anda.

  6. Di bagian Assign roles, telusuri dan pilih Cloud Tasks Service Agent.

  7. Klik Simpan.

gcloud

  1. Temukan nomor project Anda: 

        gcloud projects describe PROJECT_ID --format='table(projectNumber)'

    Ganti PROJECT_ID dengan project ID Anda.

  2. Salin nomor tersebut.

  3. Berikan peran Cloud Tasks Service Agent ke akun layanan Cloud Tasks, menggunakan nomor project yang Anda salin:

        gcloud projects add-iam-policy-binding PROJECT_ID --member serviceAccount:service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com --role roles/cloudtasks.serviceAgent

    Ganti kode berikut:

    • PROJECT_ID: Project ID Google Cloud Anda.
    • PROJECT_NUMBER: nomor project Google Cloud Anda.

Konfigurasi lanjutan

Ada sejumlah atribut yang dapat Anda konfigurasi dalam tugas. Untuk daftar lengkap, lihat definisi resource tugas.

Contoh atribut yang dapat Anda sesuaikan:

  • Penamaan: Jika Anda memilih untuk menentukan nama untuk tugas, Cloud Tasks dapat menggunakan nama tersebut untuk memastikan penghapusan duplikat tugas, meskipun pemrosesan yang diperlukan untuk hal ini dapat meningkatkan latensi.
  • Penjadwalan: Anda dapat menjadwalkan tugas pada waktu mendatang. Hanya didukung untuk CreateTask (tidak didukung untuk BufferTask)
  • Konfigurasi percobaan ulang: Konfigurasikan perilaku percobaan ulang untuk tugas jika tugas gagal. Hanya didukung untuk CreateTask (tidak didukung untuk BufferTask)

Langkah selanjutnya