HTTP-Trigger

Mithilfe der HTTP-Methoden POST, PUT, GET, DELETE und OPTIONS können Sie Cloud Functions-Funktionen mit einer HTTP-Anfrage aufrufen. Zum Erstellen eines HTTP-Endpunkts für Ihre Funktion geben Sie beim Bereitstellen der Funktion --trigger-http als Triggertyp an. Aus Sicht des Aufrufers erfolgen HTTP-Aufrufe synchron. Das Ergebnis der Funktionsausführung wird also in der Antwort auf die HTTP-Anfrage zurückgegeben.

Mit dem folgenden gcloud-Befehl wird beispielsweise eine Funktion für die Node.js 10-Laufzeit bereitgestellt, die durch HTTP-Anfragen ausgelöst wird:

gcloud functions deploy FUNCTION_NAME --runtime nodejs10 --trigger-http --allow-unauthenticated

Für HTTP-Funktionen ist eine Authentifizierung standardmäßig erforderlich. Mit dem Flag --allow-unauthenticated können Sie die Funktion ohne Authentifizierung aufrufen. Wenn Sie eine Authentifizierung anfordern möchten, lassen Sie das Flag weg.

Zum Aufrufen von HTTP-Funktionen können Sie das allgemein verfügbare Befehlszeilendienstprogramm cURL verwenden. Der folgende cURL-Befehl führt eine POST-Anfrage mit einigen Daten für die URL einer bereitgestellten HTTP-Funktion aus:

curl -X POST "https://YOUR_REGION-YOUR_PROJECT_ID.cloudfunctions.net/FUNCTION_NAME" -H "Content-Type:application/json" --data '{"name":"Keyboard Cat"}'

Dabei gilt:

  • YOUR_REGION ist die Region, in der die Funktion bereitgestellt wird.
  • YOUR_PROJECT_ID ist die Projekt-ID der Google Cloud Platform.
  • FUNCTION_NAME ist der Name der HTTP-Funktion, die Sie bereitgestellt haben.

Die Trigger-URL für eine HTTP-Funktion ist verfügbar, nachdem die Funktion implementiert wurde, bzw. kann jederzeit mit dem Befehl gcloud functions describe abgefragt werden.

Sie können Ihre HTTP-Funktionen auch direkt über das gcloud-Tool auslösen. Der folgende Befehl ruft eine Funktion auf und sendet ihr Daten im Text einer HTTP-POST-Anfrage:

gcloud functions call FUNCTION_NAME --data '{"name":"Keyboard Cat"}'

Codebeispiel

Node.js

const escapeHtml = require('escape-html');

/**
 * HTTP Cloud Function.
 *
 * @param {Object} req Cloud Function request context.
 *                     More info: https://expressjs.com/en/api.html#req
 * @param {Object} res Cloud Function response context.
 *                     More info: https://expressjs.com/en/api.html#res
 */
exports.helloHttp = (req, res) => {
  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
};

Python

from flask import escape

def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <https://flask.palletsprojects.com/en/1.1.x/api/#incoming-request-data>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <https://flask.palletsprojects.com/en/1.1.x/api/#flask.make_response>.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return 'Hello {}!'.format(escape(name))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"
)

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Java


import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Logger;

public class HelloHttp implements HttpFunction {
  private static final Logger logger = Logger.getLogger(HelloHttp.class.getName());

  private static final Gson gson = new Gson();

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // Check URL parameters for "name" field
    // "world" is the default value
    String name = request.getFirstQueryParameter("name").orElse("world");

    // Parse JSON request and check for "name" field
    try {
      JsonElement requestParsed = gson.fromJson(request.getReader(), JsonElement.class);
      JsonObject requestJson = null;

      if (requestParsed != null && requestParsed.isJsonObject()) {
        requestJson = requestParsed.getAsJsonObject();
      }

      if (requestJson != null && requestJson.has("name")) {
        name = requestJson.get("name").getAsString();
      }
    } catch (JsonParseException e) {
      logger.severe("Error parsing JSON: " + e.getMessage());
    }

    var writer = new PrintWriter(response.getWriter());
    writer.printf("Hello %s!", name);
  }
}

Ereignisstruktur

Von HTTP ausgelöste Funktionen empfangen Ereignisse über sprachspezifische idiomatische HTTP-Frameworks. Weitere Informationen finden Sie in den Codebeispielen weiter oben.

Weitere Informationen

Die HTTP-Anleitung enthält ein Beispiel für die Implementierung einer HTTP-Funktion. Unter HTTP-Funktionen erhalten Sie weitere Informationen zum Schreiben von HTTP-Funktionen.