Create App Engine tasks programmatically

This document demonstrates how to programmatically create App Engine tasks and place them in Cloud Tasks queues.

Using this process you can explicitly specify the service and handler that should process the task, and optionally pass task-specific data along to the handler. The Cloud Tasks service forwards the task request to the handler, but this worker is located within App Engine. So all queues that target App Engine handlers must have an App Engine app. The handlers must run in the region where the App Engine app runs. This region also serves as the LOCATION_ID parameter for your Cloud Tasks requests. For more information, see Cloud Tasks queues with App Engine targets.

You can fine-tune the configuration for the task, like scheduling a time in the future when it should be executed or limiting the number of times you want the task to be retried if it fails. If you chose to specify a name for the task, Cloud Tasks can use that name to ensure task deduplication, although the processing necessary for this can add increased latency.

You can also create App Engine tasks by using the Google Cloud CLI or by sending a direct request to the Cloud Tasks API. For more information, see Create tasks.

App Engine firewall rules

In the App Engine standard environment, the App Engine firewall can allow certain internal traffic to bypass the firewall. This means that if you set the default rule to deny, requests from certain services destined for the App Engine standard environment don't get blocked. These are all types of traffic requested in the app's own configuration, or sent from the same app. Requests that bypass firewall rules in this way also include App Engine tasks in Cloud Tasks (including App Engine Task Queues).

To allow incoming requests, the following are the IP ranges for App Engine tasks in Cloud Tasks (including App Engine Task Queues):

  • IP range for requests sent to the App Engine standard environment: 0.1.0.2/32 (bypasses the default firewall rule if set to deny)

  • IP range for requests sent to the App Engine flexible environment: 0.1.0.2/32

Create tasks using the client libraries

You create tasks in the form of an HTTP request, which you can construct as you like. Using the client libraries however, as the following samples do, can help you manage details of low level communication with the server, including authenticating with Google. For adding a task to a queue, see Add a task to a Cloud Tasks queue

C# 


usingGoogle.Cloud.Tasks.V2 ;
usingGoogle.Protobuf ;
usingGoogle.Protobuf.WellKnownTypes ;
usingSystem;
classCreateAppEngineTask
{
publicstringCreateTask(
// TODO<developer>: call this method by passing correct values for
// the following parameters or change the parameters' default values.
stringprojectId="YOUR-PROJECT-ID",
stringlocation="us-central1",
stringqueue="my-queue",
stringpayload="Hello World!",
intinSeconds=0)
{
CloudTasksClient client=CloudTasksClient .Create ();
QueueName parent=newQueueName (projectId,location,queue);
varresponse=client.CreateTask (newCreateTaskRequest
{
Parent=parent.ToString (),
Task=newTask
{
AppEngineHttpRequest=newAppEngineHttpRequest
{
HttpMethod=HttpMethod .Post ,
RelativeUri="/log_payload",
Body=ByteString .CopyFromUtf8 (payload)
},
ScheduleTime=Timestamp .FromDateTime (
DateTime.UtcNow.AddSeconds(inSeconds))
}
});
Console.WriteLine($"Created Task {response.Name}");
returnresponse.Name;
}
}

Go 


// Command create_task constructs and adds a task to an App Engine Queue.
packagemain
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.
funccreateTask(projectID,locationID,queueID,messagestring)(*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)
iferr!=nil{
returnnil,fmt.Errorf("NewClient: %w",err)
}
deferclient.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)
iferr!=nil{
returnnil,fmt.Errorf("cloudtasks.CreateTask: %w",err)
}
returncreatedTask,nil
}

Java 

importcom.google.cloud.tasks.v2.AppEngineHttpRequest ;
importcom.google.cloud.tasks.v2.CloudTasksClient ;
importcom.google.cloud.tasks.v2.HttpMethod ;
importcom.google.cloud.tasks.v2.QueueName ;
importcom.google.cloud.tasks.v2.Task ;
importcom.google.protobuf.ByteString ;
importcom.google.protobuf.Timestamp ;
importjava.io.IOException;
importjava.nio.charset.Charset;
importjava.time.Clock;
importjava.time.Instant;
publicclass CreateTask{
publicstaticvoidmain(String[]args)throwsIOException{
// TODO(developer): Replace these variables before running the sample.
StringprojectId="my-project-id";
Stringqueue="my-appengine-queue";
Stringlocation="us-central1";
Stringpayload="hello";
intseconds=0;// Scheduled delay for the task in seconds
createTask(projectId,queue,location,payload,seconds);
}
// This is an example snippet for showing best practices.
publicstaticvoidcreateTask(
StringprojectId,StringqueueName,Stringlocation,Stringpayload,intseconds)
throwsIOException{
// Instantiates a client.
try(CloudTasksClient client=CloudTasksClient .create()){
// Construct the fully qualified queue name.
StringqueuePath=QueueName .of(projectId,location,queueName).toString();
// Construct the task body.
Task .BuildertaskBuilder=
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 ());
}
}
}

Note the pom.xml file:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--
Copyright2019GoogleLLC
LicensedundertheApacheLicense,Version2.0(the"License");
youmaynotusethisfileexceptincompliancewiththeLicense.
YoumayobtainacopyoftheLicenseat
http://www.apache.org/licenses/LICENSE-2.0
Unlessrequiredbyapplicablelaworagreedtoinwriting,software
distributedundertheLicenseisdistributedonan"ASIS"BASIS,
WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
SeetheLicenseforthespecificlanguagegoverningpermissionsand
limitationsundertheLicense.
-->
<projectxmlns="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.0http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<groupId>com.example.appengine</groupId>
<artifactId>appengine-tasks-j11</artifactId>
<!--
Theparentpomdefinescommonstylechecksandtestingstrategiesforoursamples.
Removingorreplacingitshouldnotaffecttheexecutionofthesamplesinanyway.
-->
<parent>
<groupId>com.google.cloud.samples</groupId>
<artifactId>shared-configuration</artifactId>
<version>1.2.0</version>
<relativePath></relativePath>
</parent>
<properties>
<maven.compiler.target>11</maven.compiler.target>
<maven.compiler.source>11</maven.compiler.source>
</properties>
<!--Usinglibraries-bomtomanageversions.
Seehttps://github.com/GoogleCloudPlatform/cloud-opensource-java/wiki/The-Google-Cloud-Platform-Libraries-BOM-->
<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>
<!--Testdependencies-->
<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>
<build>
<finalName>tasks</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
<version>3.4.0</version>
<configuration>
<failOnMissingWebXml>false</failOnMissingWebXml>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>3.1.1</version>
<configuration>
<mainClass>com.example.task.CreateTask</mainClass>
<cleanupDaemonThreads>false</cleanupDaemonThreads>
</configuration>
</plugin>
</plugins>
</build>
</project>

Node.js 

// Imports the Google Cloud Tasks library.
const{CloudTasksClient}=require('@google-cloud/tasks');
// Instantiates a client.
constclient=newCloudTasksClient ();
asyncfunctioncreateTask(){
// 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.
constparent=client.queuePath(project,location,queue);
consttask={
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.
constrequest={parent:parent,task:task};
const[response]=awaitclient.createTask(request);
constname=response.name;
console.log(`Created task ${name}`);
}
createTask();

Note the package.json file:

{
"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":"^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());

Note the composer.json file:

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

Python 

"""Create a task for a given queue with an arbitrary payload."""
fromgoogle.cloudimport tasks_v2
fromgoogle.protobufimport timestamp_pb2
importdatetime
importjson
# 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

Note the requirements.txt file:

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.
defcreate_taskproject_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_pathproject: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.
ifpayload
task[:app_engine_http_request][:body]=payload
end
# Add scheduled time to task.
ifseconds
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_taskparent:parent,task:task
puts"Created task #{response.name}"ifresponse.name
end

What's next

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2026年08月26日 UTC.