创建任务以发送到 Cloud Run、Cloud Functions 函数或外部网址。
深入探索
如需查看包含此代码示例的详细文档,请参阅以下内容:
- 创建 HTTP Target 任务
- Cloud Tasks API 使用入门 (Go)
- Cloud Tasks API 使用入门 (Java)
- Cloud Tasks API 使用入门 (Node.js)
代码示例
C#
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
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
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
// 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
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
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());
}
}
}
Node.js
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
// 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();
PHP
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
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());
Python
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
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,
)
)
Ruby
如需了解如何安装和使用 Cloud Tasks 客户端库,请参阅 Cloud Tasks 客户端库。
如需向 Cloud Tasks 进行身份验证,请设置应用默认凭据。 如需了解详情,请参阅为本地开发环境设置身份验证。
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
后续步骤
如需搜索和过滤其他 Google Cloud 产品的代码示例,请参阅 Google Cloud 示例浏览器。