Membuat tugas HTTP Target

Dengan rilis Target HTTP ini, pengendali Cloud Tasks kini dapat dijalankan di endpoint HTTP apa pun dengan alamat IP publik, seperti Cloud Functions, Cloud Run, GKE, Compute Engine, atau bahkan server web lokal. Tugas Anda dapat dijalankan pada salah satu layanan ini dengan cara yang andal dan dapat dikonfigurasi.

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

Jika Anda memilih untuk menentukan nama tugas, Cloud Tasks dapat menggunakan nama tersebut untuk memastikan penghapusan duplikat tugas, meskipun pemrosesan yang diperlukan untuk hal ini dapat menambah latensi.

Secara umum, Anda membuat tugas dalam bentuk permintaan HTTP. Penggunaan library klien dan akun layanan, seperti dalam contoh berikut, dapat membantu Anda mengelola detail komunikasi dengan server Cloud Tasks, dan mempermudah pembuatan tugas.

Membuat tugas HTTP Target

Untuk tugas yang memiliki target HTTP, ada dua cara untuk membuat tugas.

Metode BufferTask: Gunakan metode ini jika antrean disiapkan untuk mem-buffer tugas di depan layanan. Antrean harus memiliki perutean tingkat antrean.
Metode CreateTask: Metode ini lebih kompleks. Anda harus membuat objek tugas secara eksplisit. Gunakan metode ini jika tugas dalam antrean memiliki konfigurasi perutean yang berbeda. Dalam hal ini, Anda menentukan {i>routing<i} di level tugas.

`BufferTask` metode

Batasan

Library klien: Metode BufferTask tidak didukung di library klien.
RPC API: Metode BufferTask tidak didukung di RPC API.
Pemilihan rute tingkat antrean: Untuk menggunakan metode BufferTask, antrean Anda harus menggunakan perutean tingkat antrean (jika tidak, tugas tidak memiliki informasi perutean). Jika antrean Anda belum menggunakan perutean tingkat antrean, lihat Mengonfigurasi perutean tingkat antrean untuk tugas HTTP.

Contoh REST

Cuplikan kode berikut menunjukkan contoh pembuatan tugas yang menggunakan metode BufferTask dengan 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 Anda:
```
gcloud config get-value project
```
LOCATION: Lokasi antrean Anda.
QUEUE_ID: ID antrean Anda.

`CreateTask` metode

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

Secara opsional, Anda bisa meneruskan data tugas tertentu ke pengendali. Anda juga dapat menyesuaikan konfigurasi untuk tugas tersebut secara mendetail, seperti menjadwalkan waktu di masa mendatang kapan tugas tersebut harus dijalankan atau membatasi berapa kali tugas tersebut harus dicoba lagi jika gagal.

Contoh berikut mengikuti 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;
    }
}

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

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>

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"
    }
}

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
}

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": "^4.0.0",
    "express": "^4.16.3"
  },
  "devDependencies": {
    "c8": "^8.0.0",
    "chai": "^4.2.0",
    "mocha": "^10.0.0",
    "uuid": "^9.0.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

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.

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

Di Konsol Google Cloud, buka halaman Service accounts.

Buka halaman Service accounts
Jika perlu, pilih project yang sesuai.
Klik Create service account.
Di bagian Detail akun layanan, beri nama akun tersebut. Console akan membuat nama akun email terkait untuk akun tersebut. Ini adalah cara Anda mereferensikan akun. Anda juga dapat menambahkan deskripsi tentang fungsi akun tersebut. Klik Buat dan lanjutkan.
Di bagian Grant this service account access to project, klik Select a role. Telusuri dan pilih Enqueuer Cloud Tasks. Peran ini memberi akun layanan izin untuk menambahkan tugas ke antrean.
Klik + Tambahkan peran lain.
Klik Select a role. Telusuri dan pilih Service Account User. Peran ini memungkinkan akun layanan mengizinkan antrean untuk membuat token atas namanya menggunakan kredensial akun layanan.
Jika pengendali Anda adalah bagian dari Google Cloud, beri akun layanan peran yang terkait dengan mengakses layanan tempat pengendali Anda berjalan. Setiap layanan dalam Google Cloud memerlukan peran yang berbeda. Misalnya, untuk mengakses pengendali di Cloud Run diperlukan peran Cloud Run Invoker, dan seterusnya. Anda dapat menggunakan akun layanan yang baru saja dibuat atau akun layanan lain di project Anda.
Klik Selesai untuk menyelesaikan pembuatan akun layanan.

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

Menggunakan tugas HTTP Target dengan token otentikasi

Untuk melakukan autentikasi antara Cloud Tasks dan pengendali Target HTTP yang memerlukan autentikasi semacam itu, Cloud Tasks akan membuat token header. Token ini didasarkan pada kredensial di akun layanan Cloud Tasks Enqueuer, yang diidentifikasi berdasarkan alamat emailnya. Akun layanan yang digunakan untuk autentikasi harus menjadi bagian dari project yang sama tempat Cloud Task queue Anda berada. Permintaan, dengan token header, dikirim melalui HTTPS, dari antrean ke pengendali. Anda dapat menggunakan token ID atau token akses. Token ID secara umum harus digunakan untuk setiap pengendali yang berjalan di Google Cloud, misalnya, di Cloud Functions atau Cloud Run. Pengecualian utama adalah untuk Google API yang dihosting di *.googleapis.com: API ini mengharapkan token akses. Anda harus menentukan token ID (OIDC) atau token akses (OAuth) di tugas itu sendiri.

`BufferTask` metode

Batasan

Library klien: Metode BufferTask tidak didukung di library klien.
RPC API: Metode BufferTask tidak didukung di RPC API.
Pemilihan rute tingkat antrean: Untuk menggunakan metode BufferTask, antrean Anda harus menggunakan perutean tingkat antrean (jika tidak, tugas tidak memiliki informasi perutean). Jika antrean Anda belum menggunakan perutean tingkat antrean, lihat Mengonfigurasi perutean tingkat antrean untuk tugas HTTP.

Contoh REST dengan autentikasi

Saat Anda menggunakan metode BufferTask untuk membuat tugas, konfigurasi OIDC atau OAuth apa pun yang ditetapkan pada tingkat antrean akan menggantikan konfigurasi di tingkat tugas. Untuk mengonfigurasi autentikasi di tingkat antrean, lihat Membuat antrean Cloud Tasks. Namun, Anda dapat melakukan autentikasi saat membuat tugas. Contoh berikut menggunakan kredensial default aplikasi untuk mengautentikasi saat membuat tugas:

  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 Anda:
```
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:
1. ```
gcloud auth application-default login
```
2. ```
gcloud auth application-default print-access-token
```

`CreateTask` metode

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

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

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>

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
}

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": "^4.0.0",
    "express": "^4.16.3"
  },
  "devDependencies": {
    "c8": "^8.0.0",
    "chai": "^4.2.0",
    "mocha": "^10.0.0",
    "uuid": "^9.0.0"
  }
}

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 HTTP Target, waktu tunggu default 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, khususnya Memvalidasi token ID.

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

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

Permintaan Target HTTP selalu berisi header berikut:

Header	Deskripsi
`X-CloudTasks-QueueName`	Nama antrean.
`X-CloudTasks-TaskName`	Nama "singkat" 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 berapa kali tugas menerima respons dari pengendali. Karena Cloud Tasks menghapus tugas setelah respons yang berhasil diterima, semua respons pengendali sebelumnya adalah gagal. Jumlah ini tidak termasuk kegagalan karena kode error 5XX.
`X-CloudTasks-TaskETA`	Waktu jadwal tugas, yang 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

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

Menggunakan Console

Temukan nomor project untuk project Anda di Halaman Setelan Project Google Cloud.
Salin nomornya ke bawah.
Buka Halaman Konsol Admin IAM.
Klik Grant access. Layar Berikan akses akan terbuka.
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 Anda di atas.
Di bagian Assign roles, telusuri dan pilih Cloud Tasks Service Agent.
Klik Save.

Menggunakan gcloud

Temukan nomor project Anda:

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

Ganti PROJECT_ID dengan project ID Anda.

Salin nomornya ke bawah.
Berikan peran Cloud Tasks Service Agent kepada 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 PROJECT_ID dengan project ID Anda dan PROJECT_NUMBER dengan nomor project Anda di atas.

Langkah selanjutnya

Pelajari lebih lanjut tugas Target HTTP di referensi RPC API.
Pelajari lebih lanjut tugas Target HTTP di referensi REST API.

Membuat tugas HTTP Target

Membuat tugas HTTP Target

BufferTask metode

Batasan

Contoh REST

CreateTask metode

C#

Python

Java

PHP

Go

Node.js

Ruby

Menyiapkan akun layanan untuk autentikasi pengendali Target HTTP

Menggunakan tugas HTTP Target dengan token otentikasi

BufferTask metode

Batasan

Contoh REST dengan autentikasi

CreateTask metode

Python

Java

Go

Node.js

Menyediakan pengendali tugas Target HTTP Anda sendiri

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

Menggunakan Console

Menggunakan gcloud

Langkah selanjutnya

`BufferTask` metode

`CreateTask` metode

`BufferTask` metode

`CreateTask` metode