Halaman ini diterjemahkan oleh Cloud Translation API.

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 andal dan dapat dikonfigurasi.

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

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

Metode CreateTask: Anda harus membuat objek tugas secara eksplisit. Gunakan metode ini jika tugas dalam antrean Anda memiliki konfigurasi perutean yang berbeda. Dalam hal ini, Anda menentukan perutean di tingkat tugas dan tidak dapat menggunakan perutean tingkat antrean. Pendekatan ini menggunakan metode CreateTask.
Metode BufferTask: Gunakan metode ini jika antrean Anda disiapkan untuk melakukan buffering tugas di depan layanan. Antrean harus memiliki perutean tingkat antrean. Pendekatan ini menggunakan metode BufferTask.

Membuat tugas menggunakan metode `CreateTask`

Bagian ini membahas cara membuat tugas dengan menyusun 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": "^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,
        )
    )

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

Membuat tugas menggunakan metode `BufferTask`

Bagian ini membahas cara membuat 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.
Perutean tingkat tugas: Metode ini tidak mendukung perutean tingkat tugas. Karena tidak ada tempat untuk menambahkan informasi perutean saat membuat tugas dengan cara ini, 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.

Panggil metode `BufferTask`

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

curl

Cuplikan kode berikut menunjukkan contoh pembuatan tugas 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 Google Cloud project 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

Menyiapkan akun layanan untuk autentikasi handler target HTTP

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

Anda dapat menggunakan akun layanan saat ini jika Anda memberikan 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.

Di konsol Google Cloud , buka halaman Service Accounts.

Buka Akun Layanan
Jika perlu, pilih project yang sesuai.
Klik Create service account.
Di bagian Service account details, beri nama akun. Konsol membuat nama akun email terkait untuk akun tersebut. Berikut cara Anda mereferensikan akun. Anda juga dapat menambahkan deskripsi tentang tujuan pembuatan akun tersebut. Klik Buat dan lanjutkan.
Di bagian Berikan akses akun layanan ini ke project, klik Pilih peran. Telusuri dan pilih Cloud Tasks Enqueuer. Peran ini memberikan izin kepada akun layanan untuk menambahkan tugas ke antrean.
Klik + Add another role.
Klik Pilih peran. Telusuri dan pilih Service Account User. Peran ini memungkinkan akun layanan memberi otorisasi pada antrean untuk membuat token atas namanya menggunakan kredensial akun layanan.
Jika handler Anda adalah bagian dari Google Cloud, berikan akun layanan peran yang terkait dengan akses ke layanan tempat handler Anda berjalan. Setiap layanan dalam Google Cloud memerlukan peran yang berbeda. Misalnya, untuk mengakses handler di Cloud Run, berikan peran Cloud Run Invoker. Anda dapat menggunakan akun layanan yang baru saja Anda buat atau akun layanan lain di project Anda.
Klik Selesai untuk menyelesaikan pembuatan akun layanan.

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

Menggunakan tugas target HTTP dengan token autentikasi

Untuk mengautentikasi antara Cloud Tasks dan handler target HTTP yang memerlukan autentikasi tersebut, Cloud Tasks 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 menjadi bagian dari project yang sama dengan tempat antrean Cloud Tasks Anda berada. 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 handler apa pun yang berjalan di Google Cloud, misalnya, di Cloud Run functions 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 menggantikan konfigurasi di tingkat tugas. Untuk mengonfigurasi autentikasi di tingkat tugas, tentukan token ID (OIDC) atau token akses (OAuth) di tugas itu sendiri.

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.18.0

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 Google Cloud project 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

Menyediakan pengendali tugas target HTTP Anda sendiri

Penangan tugas Target HTTP sangat mirip dengan penangan tugas App Engine, dengan pengecualian berikut:

Waktu tunggu: untuk semua handler tugas target HTTP, 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, terutama 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 serupa dengan, tetapi tidak identik dengan, header yang ditetapkan pada permintaan tugas App Engine. Header ini hanya memberikan informasi. ID tersebut 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 "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`	Jumlah total respons yang diterima tugas dari handler. Karena Cloud Tasks menghapus tugas setelah respons berhasil diterima, semua respons handler sebelumnya gagal. Jumlah ini tidak mencakup kegagalan karena kode error 5XX.
`X-CloudTasks-TaskETA`	Waktu jadwal tugas, ditentukan dalam detik sejak 1 Januari 1970.

Selain itu, permintaan dari Cloud Tasks dapat 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 secara manual

Anda dapat menambahkan peran Cloud Tasks Service Agent (roles/cloudtasks.serviceAgent) secara manual ke akun layanan Cloud Tasks Anda yang merupakan agen layanan utama untuk Cloud Tasks.

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

Konsol

Temukan dan salin nomor project untuk project Google Cloud Anda di halaman Welcome di konsol Google Cloud .
Di konsol Google Cloud , buka halaman IAM.

Buka IAM
Klik Grant access. Panel Berikan akses akan terbuka.
Di bagian Add principals, tambahkan alamat email dalam format ini:
```
 service-PROJECT_NUMBER@gcp-sa-cloudtasks.iam.gserviceaccount.com
 
```
Ganti PROJECT_NUMBER dengan Google Cloud nomor project Anda.
Di bagian Assign roles, telusuri dan pilih Cloud Tasks Service Agent.
Klik Simpan.

gcloud

Temukan nomor project Anda:

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

Ganti PROJECT_ID dengan project ID Anda.

Salin nomor ke bawah.
Beri akun layanan Cloud Tasks peran Cloud Tasks Service Agent, 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: ID project Anda. Google Cloud
- PROJECT_NUMBER: nomor project Google Cloud Anda.

Konfigurasi lainnya

Ada sejumlah atribut tugas yang dapat Anda konfigurasi. Untuk daftar lengkapnya, lihat definisi resource tugas. Misalnya, Anda dapat menyesuaikan atribut berikut:

Penamaan: 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.
Penjadwalan: Anda dapat menjadwalkan tugas untuk waktu mendatang. Fitur ini didukung hanya untuk CreateTask dan tidak didukung untuk BufferTask.

Anda juga dapat mengonfigurasi atribut antrean seperti penggantian perutean, batas kecepatan, dan parameter percobaan ulang. Konfigurasi ini diterapkan ke semua tugas dalam antrean. Untuk mengetahui informasi selengkapnya, lihat Mengonfigurasi antrean Cloud Tasks.

Langkah berikutnya

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

Membuat tugas target HTTP Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Membuat tugas menggunakan metode CreateTask

C#

Go

Java

Node.js

PHP

Python

Ruby

Membuat tugas menggunakan metode BufferTask

Batasan

Panggil metode BufferTask

curl

Python

Menyiapkan akun layanan untuk autentikasi handler target HTTP

Menggunakan tugas target HTTP dengan token autentikasi

Metode CreateTask

Go

Java

Node.js

Python

Metode BufferTask

curl

Python

Menyediakan pengendali tugas target HTTP Anda sendiri

Menambahkan peran Agen Layanan Cloud Tasks secara manual

Konsol

gcloud

Konfigurasi lainnya

Langkah berikutnya

Membuat tugas target HTTP

Membuat tugas menggunakan metode `CreateTask`

Membuat tugas menggunakan metode `BufferTask`

Panggil metode `BufferTask`

Metode `CreateTask`

Metode `BufferTask`