Google 會運用 AI 技術將內容翻譯成你偏好的語言，但可能會出錯。

以程式輔助方式建立 App Engine 工作

本文說明如何透過程式建立 App Engine 工作，並排入 Cloud Tasks 佇列。

使用這個程序時，您可以明確指定應處理工作的服務和處理常式，並選擇將工作專屬資料傳送給處理常式。Cloud Tasks 服務會將工作要求轉送至處理常式，但這個工作站位於 App Engine 中。因此，所有以 App Engine 處理常式為目標的佇列都必須有 App Engine 應用程式。處理常式必須在 App Engine 應用程式執行的區域中執行。這個區域也會做為 Cloud Tasks 要求的 LOCATION_ID 參數。詳情請參閱「以 App Engine 為目標的 Cloud Tasks 佇列」。

您可以微調工作的設定，例如安排未來的執行時間，或限制工作失敗時的重試次數。如果您選擇為工作指定名稱，Cloud Tasks 就能使用該名稱確保工作重複資料刪除，但這項處理作業可能會增加延遲時間。

您也可以使用 Google Cloud CLI 建立 App Engine 工作，或直接向 Cloud Tasks API 傳送要求。詳情請參閱「建立工作」。

App Engine 防火牆規則

在 App Engine 標準環境中，App Engine 防火牆可允許特定內部流量略過防火牆。也就是說，如果您將 default 規則設為 deny，來自特定服務且傳送至 App Engine 標準環境的要求就不會遭到封鎖。這些都是應用程式本身設定中要求或從相同應用程式傳送的流量類型。以這種方式略過防火牆規則的要求也包括 Cloud Tasks 中的 App Engine 工作 (包括 App Engine 工作佇列)。

如要允許傳入要求，請使用下列 IP 範圍，讓 Cloud Tasks 中的 App Engine 工作 (包括 App Engine 工作佇列) 傳送要求：

傳送至 App Engine 標準環境的要求 IP 範圍：0.1.0.2/32 (如果設為拒絕，則會略過預設防火牆規則)
傳送至 App Engine 彈性環境的要求 IP 範圍：0.1.0.2/32

使用用戶端程式庫建立工作

您以 HTTP 要求的形式建立工作，並可隨意建構。不過就如同下列範例所示，使用用戶端程式庫有助您管理與伺服器之間的低階通訊詳細資料，其中也包括 Google 驗證。如要將工作新增至佇列，請參閱「將工作新增至 Cloud Tasks 佇列」一文。

C#


using Google.Cloud.Tasks.V2;
using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;
using System;

class CreateAppEngineTask
{
    public string CreateTask(
        // TODO: call this method by passing correct values for
        // the following parameters or change the parameters' default values.
        string projectId = "YOUR-PROJECT-ID",
        string location = "us-central1",
        string queue = "my-queue",
        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
            {
                AppEngineHttpRequest = new AppEngineHttpRequest
                {
                    HttpMethod = HttpMethod.Post,
                    RelativeUri = "/log_payload",
                    Body = ByteString.CopyFromUtf8(payload)
                },
                ScheduleTime = Timestamp.FromDateTime(
                    DateTime.UtcNow.AddSeconds(inSeconds))
            }
        });

        Console.WriteLine($"Created Task {response.Name}");
        return response.Name;
    }
}

Go


// Command create_task constructs and adds a task to an App Engine Queue.
package main

import (
	"context"
	"fmt"

	cloudtasks "cloud.google.com/go/cloudtasks/apiv2"
	taskspb "cloud.google.com/go/cloudtasks/apiv2/cloudtaskspb"
)

// createTask creates a new task in your App Engine queue.
func createTask(projectID, locationID, queueID, 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#AppEngineHttpRequest
			MessageType: &taskspb.Task_AppEngineHttpRequest{
				AppEngineHttpRequest: &taskspb.AppEngineHttpRequest{
					HttpMethod:  taskspb.HttpMethod_POST,
					RelativeUri: "/task_handler",
				},
			},
		},
	}

	// Add a payload message if one is present.
	req.Task.GetAppEngineHttpRequest().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.AppEngineHttpRequest;
import com.google.cloud.tasks.v2.CloudTasksClient;
import com.google.cloud.tasks.v2.HttpMethod;
import com.google.cloud.tasks.v2.QueueName;
import com.google.cloud.tasks.v2.Task;
import com.google.protobuf.ByteString;
import com.google.protobuf.Timestamp;
import java.io.IOException;
import java.nio.charset.Charset;
import java.time.Clock;
import java.time.Instant;

public class CreateTask {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project-id";
    String queue = "my-appengine-queue";
    String location = "us-central1";
    String payload = "hello";
    int seconds = 0; // Scheduled delay for the task in seconds
    createTask(projectId, queue, location, payload, seconds);
  }

  // This is an example snippet for showing best practices.
  public static void createTask(
      String projectId, String queueName, String location, String payload, int seconds)
      throws IOException {
    // Instantiates a client.
    try (CloudTasksClient client = CloudTasksClient.create()) {
      // Construct the fully qualified queue name.
      String queuePath = QueueName.of(projectId, location, queueName).toString();

      // Construct the task body.
      Task.Builder taskBuilder =
          Task.newBuilder()
              .setAppEngineHttpRequest(
                  AppEngineHttpRequest.newBuilder()
                      .setBody(ByteString.copyFrom(payload, Charset.defaultCharset()))
                      .setRelativeUri("/tasks/create")
                      .setHttpMethod(HttpMethod.POST)
                      .build());

      // Add the scheduled time to the request.
      taskBuilder.setScheduleTime(
          Timestamp.newBuilder()
              .setSeconds(Instant.now(Clock.systemUTC()).plusSeconds(seconds).getEpochSecond()));

      // Send create task request.
      Task task = client.createTask(queuePath, taskBuilder.build());
      System.out.println("Task created: " + task.getName());
    }
  }
}

請注意 pom.xml 檔案：

 version="1.0" encoding="UTF-8"?>

 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">
  4.0.0
  war
  1.0-SNAPSHOT
  com.example.appengine
  appengine-tasks-j11

  
  
    com.google.cloud.samples
    shared-configuration
    1.2.0
    
  

  
    11
    11
  

  
  
    
      
        com.google.cloud
        libraries-bom
        26.32.0
        pom
        import
      
    
  

  
    
      com.google.cloud
      google-cloud-tasks
    
    
    
      junit
      junit
      4.13.2
      test
    
    
      com.google.truth
      truth
      1.4.0
      test
    
  
  
    tasks
    
      
        org.apache.maven.plugins
        maven-war-plugin
        3.4.0
        
          false
        
      

      
        org.codehaus.mojo
        exec-maven-plugin
        3.1.1
        
          com.example.task.CreateTask
          false

Node.js

// Imports the Google Cloud Tasks library.
const {CloudTasksClient} = require('@google-cloud/tasks');

// Instantiates a client.
const client = new CloudTasksClient();

async function createTask() {
  // TODO(developer): Uncomment these lines and replace with your values.
  // const project = 'my-project-id';
  // const queue = 'my-appengine-queue';
  // const location = 'us-central1';
  // const payload = 'Hello, World!';

  // Construct the fully qualified queue name.
  const parent = client.queuePath(project, location, queue);

  const task = {
    appEngineHttpRequest: {
      headers: {
        'Content-Type': 'text/plain', // Set content type to ensure compatibility your application's request parsing
      },
      httpMethod: 'POST',
      relativeUri: '/log_payload',
    },
  };

  if (payload) {
    task.appEngineHttpRequest.body = Buffer.from(payload).toString('base64');
  }

  if (inSeconds) {
    // The time when the task is scheduled to be attempted.
    task.scheduleTime = {
      seconds: inSeconds + Date.now() / 1000,
    };
  }

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

createTask();

請注意 package.json 檔案：

{
  "name": "appengine-cloudtasks",
  "description": "Google App Engine Cloud Tasks example.",
  "license": "Apache-2.0",
  "author": "Google Inc.",
  "private": true,
  "engines": {
    "node": ">=20.0.0"
  },
  "files": [
    "*.js"
  ],
  "scripts": {
    "test": "c8 mocha -p -j 2 --timeout 30000",
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/tasks": "^6.0.0",
    "express": "^5.0.0"
  },
  "devDependencies": {
    "c8": "^12.0.0",
    "chai": "^6.0.0",
    "mocha": "^10.0.0",
    "uuid": "^11.1.1"
  }
}

PHP

use Google\Cloud\Tasks\V2\AppEngineHttpRequest;
use Google\Cloud\Tasks\V2\CloudTasksClient;
use Google\Cloud\Tasks\V2\HttpMethod;
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 App Engine Queue ID';
// $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 App Engine Http Request Object.
$httpRequest = new AppEngineHttpRequest();
// The path of the HTTP request to the App Engine service.
$httpRequest->setRelativeUri('/task_handler');
// 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 (isset($payload)) {
    $httpRequest->setBody($payload);
}

// Create a Cloud Task object.
$task = new Task();
$task->setAppEngineHttpRequest($httpRequest);

// Send request and print the task name.
$response = $client->createTask($queueName, $task);
printf('Created task %s' . PHP_EOL, $response->getName());

請注意 composer.json 檔案：

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

Python

"""Create a task for a given queue with an arbitrary payload."""

from google.cloud import tasks_v2
from google.protobuf import timestamp_pb2
import datetime
import json

# Create a client.
client = tasks_v2.CloudTasksClient()

# TODO(developer): Uncomment these lines and replace with your values.
# project = 'my-project-id'
# queue = 'my-appengine-queue'
# location = 'us-central1'
# payload = 'hello' or {'param': 'value'} for application/json
# in_seconds = None

# Construct the fully qualified queue name.
parent = client.queue_path(project, location, queue)

# Construct the request body.
task = {
    "app_engine_http_request": {  # Specify the type of request.
        "http_method": tasks_v2.HttpMethod.POST,
        "relative_uri": "/example_task_handler",
    }
}
if payload is not None:
    if isinstance(payload, dict):
        # Convert dict to JSON string
        payload = json.dumps(payload)
        # specify http content-type to application/json
        task["app_engine_http_request"]["headers"] = {
            "Content-type": "application/json"
        }
    # The API expects a payload of type bytes.
    converted_payload = payload.encode()

    # Add the payload to the request.
    task["app_engine_http_request"]["body"] = converted_payload

if in_seconds is not None:
    # Convert "seconds from now" into an rfc3339 datetime string.
    d = datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(
        seconds=in_seconds
    )

    # Create Timestamp protobuf.
    timestamp = timestamp_pb2.Timestamp()
    timestamp.FromDatetime(d)

    # Add the timestamp to the tasks.
    task["schedule_time"] = timestamp

# Use the client to build and send the task.
response = client.create_task(parent=parent, task=task)

print(f"Created task {response.name}")
return response

請注意 requirements.txt 檔案：

Flask==3.1.3; python_version >= '3.9'
gunicorn==23.0.0
google-cloud-tasks==2.18.0

Ruby

require "google/cloud/tasks"

# Create an App Engine Task
#
# @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 App Engine Queue ID.
# @param [String] payload The request body of your task.
# @param [Integer] seconds The delay, in seconds, to process your task.
def create_task project_id, location_id, queue_id, 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 = {
    app_engine_http_request: {
      http_method:  "POST",
      relative_uri: "/log_payload"
    }
  }

  # Add payload to task body.
  if payload
    task[:app_engine_http_request][:body] = payload
  end

  # 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

後續步驟

瞭解如何建立 App Engine 工作處理常式。
參閱 RPC API 參考資料進一步瞭解工作。
參閱 REST API 參考資料進一步瞭解工作。

以程式輔助方式建立 App Engine 工作 透過集合功能整理內容 你可以依據偏好儲存及分類內容。