Cloud Functions: Gruß-Funktion

In diesem Beispiel wird gezeigt, wie Sie eine Cloud Functions-Funktion erstellen, die einen Vornamen und einen Nachnamen als Eingabe akzeptiert und eine personalisierte Begrüßungsnachricht zurückgibt.

Codebeispiel

C#

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Run Functions zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

using Google.Cloud.Functions.Framework;
using System.Text.Json.Serialization;
using System.Threading;
using System.Threading.Tasks;

namespace Greeting;

public class Function : ITypedFunction<GreetingRequest, GreetingResponse>
{
    public Task<GreetingResponse> HandleAsync(GreetingRequest request, CancellationToken cancellationToken) =>
        Task.FromResult(new GreetingResponse
        {
            Message = $"Hello {request.FirstName} {request.LastName}!",
        });
}

public class GreetingRequest
{
    [JsonPropertyName("first_name")]
    public string FirstName { get; set; }

    [JsonPropertyName("last_name")]
    public string LastName { get; set; }
}

public class GreetingResponse
{
    [JsonPropertyName("message")]
    public string Message { get; set; }
}

Go


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

import (
	"fmt"

	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

func init() {
	functions.Typed("Greeting", greeting)
}

// greeting is a Typed Cloud Function.
func greeting(request *GreetingRequest) (*GreetingResponse, error) {
	return &GreetingResponse{
		Message: fmt.Sprintf("Hello %v %v!", request.FirstName, request.LastName),
	}, nil
}

type GreetingRequest struct {
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
}

type GreetingResponse struct {
	Message string `json:"message"`
}

Java

import com.google.cloud.functions.TypedFunction;
import com.google.gson.annotations.SerializedName;

public class Greeting implements TypedFunction<GreetingRequest, GreetingResponse> {
  @Override
  public GreetingResponse apply(GreetingRequest request) throws Exception {
    GreetingResponse response = new GreetingResponse();
    response.message = String.format("Hello %s %s!", request.firstName, request.lastName);
    return response;
  }
}

Node.js

const functions = require('@google-cloud/functions-framework');

functions.typed('greeting', req => {
  return {
    message: `Hello ${req.first_name} ${req.last_name}!`,
  };
});

PHP


use Google\CloudFunctions\FunctionsFramework;

class GreetingRequest
{
    /** @var string */
    public $first_name;

    /** @var string */
    public $last_name;

    public function __construct(string $first_name = '', string $last_name = '')
    {
        $this->first_name = $first_name;
        $this->last_name = $last_name;
    }

    public function serializeToJsonString(): string
    {
        return json_encode([
            'first_name' => $this->first_name,
            'last_name' => $this->last_name,
        ]);
    }

    public function mergeFromJsonString(string $body): void
    {
        $obj = json_decode($body);
        $this->first_name = $obj['first_name'];
        $this->last_name = $obj['last_name'];
    }
}

class GreetingResponse
{
    /** @var string */
    public $message;

    public function __construct(string $message = '')
    {
        $this->message = $message;
    }

    public function serializeToJsonString(): string
    {
        return json_encode([
            'message' => $message,
        ]);
    }

    public function mergeFromJsonString(string $body): void
    {
        $obj = json_decode($body);
        $this->message = $obj['message'];
    }
};

function greeting(GreetingRequest $req): GreetingResponse
{
    return new GreetingResponse("Hello $req->first_name $req->last_name!");
};

FunctionsFramework::typed('greeting', 'greeting');

Python

from dataclasses import dataclass

import functions_framework


@dataclass
class GreetingRequest:
    first_name: str
    last_name: str

    # Required to deserialize the request
    @staticmethod
    def from_dict(req: dict) -> "GreetingRequest":
        return GreetingRequest(
            first_name=req["first_name"],
            last_name=req["last_name"],
        )


@dataclass
class GreetingResponse:
    message: str

    # Required to serialize the response
    def to_dict(self) -> dict:
        return {
            "message": self.message,
        }


@functions_framework.typed
def greeting(req: GreetingRequest):
    return GreetingResponse(message=f"Hello {req.first_name} {req.last_name}!")

Ruby

require "functions_framework"

FunctionsFramework.typed "greeting" do |req|
  {
    message: "Hello #{req['first_name']} #{req['last_name']}!"
  }
end

Nächste Schritte

Informationen zum Suchen und Filtern von Codebeispielen für andere Google Cloud -Produkte finden Sie im Google Cloud Beispielbrowser.