Crear controladores de tareas de App Engine

En esta página se muestra cómo crear un controlador de tareas de App Engine, que es el código de trabajador que gestiona una tarea de App Engine. La cola de Cloud Tasks envía solicitudes HTTP al controlador de tareas. Una vez completado el proceso, el controlador debe enviar un código de estado HTTP entre 200 y 299 a la cola. Cualquier otro valor indica que la tarea ha fallado y que la cola vuelve a intentar realizarla.

Las solicitudes de la cola de tareas de App Engine se envían desde la dirección IP 0.1.0.2. Consulta también el intervalo de direcciones IP de las solicitudes enviadas al entorno de App Engine.

C# 

    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddLogging(builder => builder.AddDebug());
            services.AddRouting();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
        {
            var logger = loggerFactory.CreateLogger("testStackdriverLogging");

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                // Configure error reporting service.
                app.UseExceptionHandler("/Home/Error");
            }

            var routeBuilder = new RouteBuilder(app);

            routeBuilder.MapPost("log_payload", context =>
            {
                // Log the request payload
                var reader = new StreamReader(context.Request.Body);
                var task = reader.ReadToEnd();

                logger.LogInformation($"Received task with payload: {task}");
                return context.Response.WriteAsync($"Printed task payload: {task}");
            });

            routeBuilder.MapGet("hello", context =>
            {
                // Basic index to verify app is serving
                return context.Response.WriteAsync("Hello, world!");
            });

            routeBuilder.MapGet("_ah/health", context =>
            {
                // Respond to GAE health-checks
                return context.Response.WriteAsync("OK");
            });

            routeBuilder.MapGet("/", context =>
            {
                return context.Response.WriteAsync("Hello, world!");
            });

            var routes = routeBuilder.Build();
            app.UseRouter(routes);
        }
    }

Go 


// Sample task_handler is an App Engine app demonstrating Cloud Tasks handling.
package main

import (
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

func main() {
	// Allow confirmation the task handling service is running.
	http.HandleFunc("/", indexHandler)

	// Handle all tasks.
	http.HandleFunc("/task_handler", taskHandler)

	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
		log.Printf("Defaulting to port %s", port)
	}

	log.Printf("Listening on port %s", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		log.Fatal(err)
	}
}

// indexHandler responds to requests with our greeting.
func indexHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path != "/" {
		http.NotFound(w, r)
		return
	}
	fmt.Fprint(w, "Hello, World!")
}

// taskHandler processes task requests.
func taskHandler(w http.ResponseWriter, r *http.Request) {
	taskName := r.Header.Get("X-Appengine-Taskname")
	if taskName == "" {
		// You may use the presence of the X-Appengine-Taskname header to validate
		// the request comes from Cloud Tasks.
		log.Println("Invalid Task: No X-Appengine-Taskname request header found")
		http.Error(w, "Bad Request - Invalid Task", http.StatusBadRequest)
		return
	}

	// Pull useful headers from Task request.
	queueName := r.Header.Get("X-Appengine-Queuename")

	// Extract the request body for further task details.
	body, err := io.ReadAll(r.Body)
	if err != nil {
		log.Printf("ReadAll: %v", err)
		http.Error(w, "Internal Error", http.StatusInternalServerError)
		return
	}

	// Log & output details of the task.
	output := fmt.Sprintf("Completed task: task queue(%s), task name(%s), payload(%s)",
		queueName,
		taskName,
		string(body),
	)
	log.Println(output)

	// Set a non-2xx status code to indicate a failure in task processing that should be retried.
	// For example, http.Error(w, "Internal Server Error: Task Processing", http.StatusInternalServerError)
	fmt.Fprintln(w, output)
}

Java 

@WebServlet(
    name = "Tasks",
    description = "Create Cloud Task",
    urlPatterns = "/tasks/create"
)
public class TaskServlet extends HttpServlet {
  private static Logger log = Logger.getLogger(TaskServlet.class.getName());

  @Override
  public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
    log.info("Received task request: " + req.getServletPath());
    String body = req.getReader()
        .lines()
        .reduce("", (accumulator, actual) -> accumulator + actual);

    if (!body.isEmpty()) {
      log.info("Request payload: " + body);
      String output = String.format("Received task with payload %s", body);
      resp.getOutputStream().write(output.getBytes());
      log.info("Sending response: " + output);
      resp.setStatus(HttpServletResponse.SC_OK);
    } else {
      log.warning("Null payload received in request to " + req.getServletPath());
    }
  }
}

Node.js 

const express = require('express');

const app = express();
app.enable('trust proxy');

// Set the Content-Type of the Cloud Task to ensure compatibility
// By default, the Content-Type header of the Task request is set to "application/octet-stream"
// see https://cloud.google.com/tasks/docs/reference/rest/v2beta3/projects.locations.queues.tasks#AppEngineHttpRequest
app.use(express.text());

app.get('/', (req, res) => {
  // Basic index to verify app is serving
  res.send('Hello, World!').end();
});

app.post('/log_payload', (req, res) => {
  // Log the request payload
  console.log(`Received task with payload: ${req.body}`);
  res.send(`Printed task payload: ${req.body}`).end();
});

app.get('*', (req, res) => {
  res.send('OK').end();
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`App listening on port ${PORT}`);
  console.log('Press Ctrl+C to quit.');
});

PHP 


require __DIR__ . '/vendor/autoload.php';

use Google\Cloud\Logging\LoggingClient;

// Create the logging client.
$logging = new LoggingClient();
// Create a PSR-3-compatible logger.
$logger = $logging->psrLogger('app', ['batchEnabled' => true]);

// Front-controller to route requests.
switch (@parse_url($_SERVER['REQUEST_URI'])['path']) {
    case '/':
        print "Hello, World!\n";
        break;
    case '/task_handler':
        // Taskname and Queuename are two of several useful Cloud Tasks headers available on the request.
        $taskName = $_SERVER['HTTP_X_APPENGINE_TASKNAME'] ?? '';
        $queueName = $_SERVER['HTTP_X_APPENGINE_QUEUENAME'] ?? '';

        try {
            handle_task(
                $queueName,
                $taskName,
                file_get_contents('php://input')
            );
        } catch (Exception $e) {
            http_response_code(400);
            exit($e->getMessage());
        }
        break;
    default:
        http_response_code(404);
        exit('Not Found');
}

/**
 * Process a Cloud Tasks HTTP Request.
 *
 * @param string $queueName provides the name of the queue which dispatched the task.
 * @param string $taskName provides the identifier of the task.
 * @param string $body The task details from the HTTP request.
 */
function handle_task($queueName, $taskName, $body = '')
{
    global $logger;

    if (empty($taskName)) {
        // You may use the presence of the X-Appengine-Taskname header to validate
        // the request comes from Cloud Tasks.
        $logger->warning('Invalid Task: No X-Appengine-Taskname request header found');
        throw new Exception('Bad Request - Invalid Task');
    }

    $output = sprintf('Completed task: task queue(%s), task name(%s), payload(%s)', $queueName, $taskName, $body);
    $logger->info($output);

    // Set a non-2xx status code to indicate a failure in task processing that should be retried.
    // For example, http_response_code(500) to indicate a server error.
    print $output;
}

Python 

from flask import Flask, render_template, request

app = Flask(__name__)


@app.route("/example_task_handler", methods=["POST"])
def example_task_handler():
    """Log the request payload."""
    payload = request.get_data(as_text=True) or "(empty payload)"
    print(f"Received task with payload: {payload}")
    return render_template("index.html", payload=payload)

Ruby 

require "sinatra"
require "json"

get "/" do
  # Basic index to verify app is serving
  "Hello World!"
end

post "/log_payload" do
  data = request.body.read
  # Log the request payload
  puts "Received task with payload: #{data}"
  "Printed task payload: #{data}"
end

Tiempos de espera

Las tareas de App Engine tienen tiempos de espera específicos que dependen del tipo de escalado del servicio que las ejecuta.

Estos son los valores para los servicios de los trabajadores que se ejecutan en el entorno estándar:

  • Escalado automático: el procesamiento de la tarea debe finalizar en 10 minutos.
  • Escalado manual y básico: las peticiones pueden ejecutarse durante un máximo 24 horas.

En el caso de los servicios de trabajador que se ejecutan en el entorno flexible, todos los tipos tienen un tiempo de espera de 60 minutos.

Si el controlador no cumple el plazo, la cola asume que la tarea ha fallado y vuelve a intentarlo.

Leer los encabezados de solicitud de tareas de App Engine

Las solicitudes que envía una cola de Cloud Tasks al controlador de App Engine tienen encabezados especiales que contienen información específica de la tarea que puede que el controlador quiera usar.

Estos encabezados se definen internamente. Si alguno de estos encabezados está presente en una solicitud de un usuario externo a tu aplicación, se sustituirá por los internos, excepto en el caso de las solicitudes de administradores que hayan iniciado sesión en la aplicación, que pueden definir encabezados con fines de prueba.

Las solicitudes de tareas de App Engine siempre contienen los siguientes encabezados:

Header Descripción
X-AppEngine-QueueName El nombre de la cola.
X-AppEngine-TaskName El nombre "corto" de la tarea o, si no se ha especificado ningún nombre al crearla, un ID único generado por el sistema. Este es el valor de my-task-id en el nombre de la tarea completo. Por ejemplo, task_name = projects/my-project-id/locations/my-location/queues/my-queue-id/tasks/my-task-id.
X-AppEngine-TaskRetryCount Número de veces que se ha vuelto a intentar realizar la tarea. En el primer intento, este valor es 0. Este número incluye los intentos en los que la tarea ha fallado debido a la falta de instancias disponibles y nunca ha llegado a la fase de ejecución.
X-AppEngine-TaskExecutionCount Número de veces que se ha ejecutado la tarea y ha recibido una respuesta del controlador. Como Cloud Tasks elimina la tarea una vez que se ha recibido una respuesta correcta, todas las respuestas anteriores del controlador son errores. Este número no incluye los errores debidos a la falta de instancias disponibles. Ten en cuenta que X-AppEngine-TaskExecutionCount puede ser igual a X-AppEngine-TaskRetryCount si se actualiza antes de que se intente ejecutar.
X-AppEngine-TaskETA La hora programada de la tarea, especificada en segundos desde el 1 de enero de 1970.

Si el controlador de solicitudes encuentra alguno de los encabezados indicados anteriormente, puede asumir que la solicitud es una solicitud de Cloud Tasks.

Además, las solicitudes de Cloud Tasks pueden contener los siguientes encabezados:

Header Descripción
X-AppEngine-TaskPreviousResponse El código de respuesta HTTP del reintento anterior.
X-AppEngine-TaskRetryReason El motivo por el que se vuelve a intentar realizar la tarea.
X-AppEngine-FailFast Indica que una tarea falla inmediatamente si no hay ninguna instancia disponible.

Rutas de destino

En las tareas de App Engine, tanto la cola como el controlador de tareas se ejecutan en el mismo proyecto. Google Cloud El tráfico se cifra durante el transporte y nunca sale de los centros de datos de Google. No puedes definir explícitamente el protocolo (por ejemplo, HTTP o HTTPS). Sin embargo, la solicitud al controlador parecerá haber usado el protocolo HTTP.

Las tareas se pueden enviar a controladores de tareas seguros, controladores de tareas no seguros y tiempos de ejecución no compatibles. Los URIs se restringen con login: admin. Como las tareas no se ejecutan como ningún usuario, no se pueden enviar a URIs restringidas con login: required. Los envíos de tareas tampoco siguen las redirecciones.

Siguientes pasos