Creating App Engine tasks

This page 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.

You can also 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 necessary processing can add increased latency.

You create tasks in the form of an HTTP request, which you can construct as you like. Using the Google Cloud Client Libraries however, as the following samples do, can help you manage details of low level communication with the server, including authenticating with Google.


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

class CreateAppEngineTask
    public string CreateTask(
        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(

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


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

from import tasks_v2

# 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'

# 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:
    # 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.
    timestamp = datetime.datetime.utcnow() + datetime.timedelta(seconds=in_seconds)

    # 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('Created task {}'.format(
return response

Note the requirements.txt file:



// Instantiates a client.
try (CloudTasksClient client = CloudTasksClient.create()) {

  // Variables provided by the CLI.
  // projectId = "my-project-id";
  // queueName = "my-appengine-queue";
  // location = "us-central1";
  // payload = "hello";

  // Construct the fully qualified queue name.
  String queuePath = QueueName.of(projectId, location, queueName).toString();

  // Construct the task body.
  Task.Builder taskBuilder =
                  .setBody(ByteString.copyFrom(payload, Charset.defaultCharset()))

  if (params.hasOption(IN_SECONDS_OPTION.getOpt())) {
    // Add the scheduled time to the request.
    int seconds = Integer.parseInt(params.getOptionValue(IN_SECONDS_OPTION.getOpt()));

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

Note the pom.xml file:

<?xml version="1.0" encoding="UTF-8"?>
Copyright 2018 Google LLC

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 See the License for the specific language governing permissions and
 limitations under the License.
<project xmlns=""

    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.


    <!-- Compile/runtime dependencies -->
    <!-- Test dependencies -->

    <!-- for hot reload of the web application-->

      <!-- <plugin>
      </plugin> -->



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.
// POST is the default HTTP method, but any HTTP method can be used.
// Setting a body value is only compatible with HTTP POST and PUT requests.
if (isset($payload)) {

// Create a Cloud Task object.
$task = new Task();

// 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": "^1.4.0"


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

import (

	cloudtasks ""
	taskspb ""

// 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
	ctx := context.Background()
	client, err := cloudtasks.NewClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewClient: %v", 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.
	req := &taskspb.CreateTaskRequest{
		Parent: queuePath,
		Task: &taskspb.Task{
			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: %v", err)

	return createdTask, nil


// 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: {
      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 + / 1000,

  console.log('Sending task:');
  // Send create task request.
  const request = {parent, task};
  const [response] = await client.createTask(request);
  const name =;
  console.log(`Created task ${name}`);

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": ">=10"
  "files": [
  "scripts": {
    "test": "mocha",
    "start": "node server.js"
  "dependencies": {
    "@google-cloud/tasks": "^2.1.2",
    "body-parser": "^1.18.3",
    "express": "^4.16.3"
  "devDependencies": {
    "chai": "^4.2.0",
    "mocha": "^8.0.0",
    "uuid": "^8.0.0"


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 =

  # Construct the fully qualified queue name.
  parent = client.queue_path project_id, location_id, 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

  # Add scheduled time to task.
  if seconds
    timestamp =
    timestamp.seconds = + seconds.to_i
    task[:schedule_time] = timestamp

  # Send create task request.
  puts "Sending task #{task}"
  response = client.create_task parent, task

  puts "Created task #{}" if

What's next