Spanner mit Cloud Run Functions (1. Generation) verwenden

Ziele

Schreiben, Bereitstellen und Auslösen einer HTTP-Cloud Run Functions-Funktion, die auf Cloud Spanner zugreift.

Kosten

In dieser Anleitung werden Cloud Spanner und Cloud Run Functions verwendet, zwei kostenpflichtige Komponenten von Google Cloud.

  • Informationen zu den Kosten für die Verwendung von Cloud Spanner finden Sie auf der Seite zu den Preisen für Cloud Spanner.

  • Informationen zu den Kosten für die Verwendung von Cloud Run Functions, einschließlich kostenloser Aufrufe, finden Sie unter Preise für Cloud Run Functions.

Vorbereitung

  1. In diesem Thema wird davon ausgegangen, dass Ihnen eine Cloud Spanner-Instanz namens test-instance und eine Datenbank namens example-db mit dem Musikanwendungsschema zur Verfügung stehen. Weitere Informationen zum Erstellen von Instanzen und Datenbanken mit dem Musikanwendungsschema finden Sie unter Kurzanleitung zur Console oder in den „Erste Schritte“-Anleitungen für Go, Java, Node.js oder Python.

  2. Aktivieren Sie Cloud Run Functions und Cloud Build APIs.

    APIs aktivieren

  3. Installieren und initialisieren Sie die gcloud CLI.

    Wenn Sie die gcloud CLI bereits installiert haben, aktualisieren Sie sie mit dem folgenden Befehl:

    gcloud components update

  4. Bereiten Sie Ihre Entwicklungsumgebung vor:

Anwendung vorbereiten

  1. Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:

    Node.js 

    git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

    Python 

    git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

    Go

    git clone https://github.com/GoogleCloudPlatform/golang-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

    Java 

    git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

    Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

  2. Wechseln Sie zu dem Verzeichnis, das den Beispielcode für Cloud Run Functions für den Zugriff auf Cloud Spanner enthält:

    Node.js 

    cd nodejs-docs-samples/functions/spanner/

    Python 

    cd python-docs-samples/functions/spanner/

    Go

    cd golang-samples/functions/spanner/

    Java

    cd java-docs-samples/functions/spanner/

  3. Sehen Sie sich den Beispielcode an:

    Node.js 

    // Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

// Imports the functions framework to register your HTTP function
const functions = require('@google-cloud/functions-framework');

// Instantiates a client
const spanner = new Spanner();

// Your Cloud Spanner instance ID
const instanceId = 'test-instance';

// Your Cloud Spanner database ID
const databaseId = 'example-db';

/**
 * HTTP Cloud Function.
 *
 * @param {Object} req Cloud Function request context.
 * @param {Object} res Cloud Function response context.
 */
functions.http('spannerQuickstart', async (req, res) => {
  // Gets a reference to a Cloud Spanner instance and database
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  // The query to execute
  const query = {
    sql: 'SELECT * FROM Albums',
  };

  // Execute the query
  try {
    const results = await database.run(query);
    const rows = results[0].map(row => row.toJSON());
    rows.forEach(row => {
      res.write(
        `SingerId: ${row.SingerId}, ` +
          `AlbumId: ${row.AlbumId}, ` +
          `AlbumTitle: ${row.AlbumTitle}\n`
      );
    });
    res.status(200).end();
  } catch (err) {
    res.status(500).send(`Error querying Spanner: ${err}`);
  }
});

    Python 

    import functions_framework
from google.cloud import spanner

instance_id = "test-instance"
database_id = "example-db"

client = spanner.Client()
instance = client.instance(instance_id)
database = instance.database(database_id)


@functions_framework.http
def spanner_read_data(request):
    query = "SELECT * FROM Albums"

    outputs = []
    with database.snapshot() as snapshot:
        results = snapshot.execute_sql(query)

        for row in results:
            output = "SingerId: {}, AlbumId: {}, AlbumTitle: {}".format(*row)
            outputs.append(output)

    return "\n".join(outputs)

    Go

    
// Package spanner contains an example of using Spanner from a Cloud Function.
package spanner

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"sync"

	"cloud.google.com/go/spanner"
	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
	"google.golang.org/api/iterator"
)

// client is a global Spanner client, to avoid initializing a new client for
// every request.
var client *spanner.Client
var clientOnce sync.Once

// db is the name of the database to query.
var db = "projects/my-project/instances/my-instance/databases/example-db"

func init() {
	functions.HTTP("HelloSpanner", HelloSpanner)
}

// HelloSpanner is an example of querying Spanner from a Cloud Function.
func HelloSpanner(w http.ResponseWriter, r *http.Request) {
	clientOnce.Do(func() {
		// Declare a separate err variable to avoid shadowing client.
		var err error
		client, err = spanner.NewClient(context.Background(), db)
		if err != nil {
			http.Error(w, "Error initializing database", http.StatusInternalServerError)
			log.Printf("spanner.NewClient: %v", err)
			return
		}
	})

	fmt.Fprintln(w, "Albums:")
	stmt := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
	iter := client.Single().Query(r.Context(), stmt)
	defer iter.Stop()
	for {
		row, err := iter.Next()
		if err == iterator.Done {
			return
		}
		if err != nil {
			http.Error(w, "Error querying database", http.StatusInternalServerError)
			log.Printf("iter.Next: %v", err)
			return
		}
		var singerID, albumID int64
		var albumTitle string
		if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
			http.Error(w, "Error parsing database response", http.StatusInternalServerError)
			log.Printf("row.Columns: %v", err)
			return
		}
		fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
	}
}

    Java

    import com.google.api.client.http.HttpStatusCodes;
import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.LazySpannerInitializer;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;

// HelloSpanner is an example of querying Spanner from a Cloud Function.
public class HelloSpanner implements HttpFunction {
  private static final Logger logger = Logger.getLogger(HelloSpanner.class.getName());

  // TODO<developer>: Set these environment variables.
  private static final String SPANNER_INSTANCE_ID =
      MoreObjects.firstNonNull(System.getenv("SPANNER_INSTANCE"), "my-instance");
  private static final String SPANNER_DATABASE_ID =
      MoreObjects.firstNonNull(System.getenv("SPANNER_DATABASE"), "example-db");

  private static final DatabaseId databaseId =
      DatabaseId.of(
          SpannerOptions.getDefaultProjectId(),
          SPANNER_INSTANCE_ID,
          SPANNER_DATABASE_ID);

  // The LazySpannerInitializer instance is shared across all instances of the HelloSpanner class.
  // It will create a Spanner instance the first time one is requested, and continue to return that
  // instance for all subsequent requests.
  private static final LazySpannerInitializer SPANNER_INITIALIZER = new LazySpannerInitializer();

  @VisibleForTesting
  DatabaseClient getClient() throws Throwable {
    return SPANNER_INITIALIZER.get().getDatabaseClient(databaseId);
  }

  @Override
  public void service(HttpRequest request, HttpResponse response) throws Exception {
    var writer = new PrintWriter(response.getWriter());
    try {
      DatabaseClient client = getClient();
      try (ResultSet rs =
          client
              .singleUse()
              .executeQuery(Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"))) {
        writer.printf("Albums:%n");
        while (rs.next()) {
          writer.printf(
              "%d %d %s%n",
              rs.getLong("SingerId"), rs.getLong("AlbumId"), rs.getString("AlbumTitle"));
        }
      } catch (SpannerException e) {
        writer.printf("Error querying database: %s%n", e.getMessage());
        response.setStatusCode(HttpStatusCodes.STATUS_CODE_SERVER_ERROR, e.getMessage());
      }
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Spanner example failed", t);
      writer.printf("Error setting up Spanner: %s%n", t.getMessage());
      response.setStatusCode(HttpStatusCodes.STATUS_CODE_SERVER_ERROR, t.getMessage());
    }
  }
}

    Die Funktion sendet eine SQL-Abfrage, um alle Albums-Daten aus Ihrer Datenbank abzurufen. Sie wird ausgeführt, wenn Sie eine HTTP-Anfrage an den Endpunkt der Funktion stellen.

Funktion implementieren

Führen Sie zum Bereitstellen der Funktion mit einem HTTP-Trigger den folgenden Befehl im Verzeichnis spanner aus:

Node.js 

gcloud functions deploy get \
--runtime nodejs20 --trigger-http

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Node.js-Version anzugeben und die Funktion auszuführen.

Python 

gcloud functions deploy spanner_read_data \
--runtime python312 --trigger-http

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Python-Version anzugeben und die Funktion auszuführen.

Go

gcloud functions deploy HelloSpanner \
--runtime go121 --trigger-http

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Go-Version anzugeben und die Funktion auszuführen.

Java 

gcloud functions deploy java-spanner-function \
--entry-point functions.HelloSpanner \
--runtime java17 \
--memory 512MB --trigger-http

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Java-Version anzugeben und die Funktion auszuführen.

Die Bereitstellung der Funktion kann bis zu zwei Minuten dauern.

Beachten Sie den url-Wert, der zurückgegeben wird, wenn die Bereitstellung Ihrer Funktion abgeschlossen ist. Sie benötigen diesen Wert, wenn Sie die Funktion auslösen.

Sie können Ihre bereitgestellten Funktionen in der Google Cloud Console auf der Seite Cloud Run Functions sehen. Sie können auf dieser Seite auch Funktionen erstellen und bearbeiten sowie Details und Diagnosen für Ihre Funktionen abrufen.

Funktion auslösen

Senden Sie einen HTTP-Anfrage an Ihre Funktion:

Node.js 

curl "https://REGION-PROJECT_ID.cloudfunctions.net/get"

Python 

curl "https://REGION-PROJECT_ID.cloudfunctions.net/spanner_read_data"

Go

curl "https://REGION-PROJECT_ID.cloudfunctions.net/HelloSpanner"

Java 

curl "https://REGION-PROJECT_ID.cloudfunctions.net/java-spanner-function"

REGION und PROJECT_ID stimmen dabei mit den Werten überein, die in Ihrem Terminal sichtbar sind, wenn die Bereitstellung der Funktion abgeschlossen ist. Sie sollten eine Ausgabe sehen, die die Ergebnisse der SQL-Abfrage enthält, vorausgesetzt, Sie haben eine "Erste Schritte"-Anleitung durchgearbeitet und die Datenbank entsprechend aufgefüllt:

SingerId: 2, AlbumId: 2, AlbumTitle: Forever Hold Your Peace
SingerId: 1, AlbumId: 2, AlbumTitle: Go, Go, Go
SingerId: 2, AlbumId: 1, AlbumTitle: Green
SingerId: 2, AlbumId: 3, AlbumTitle: Terrified
SingerId: 1, AlbumId: 1, AlbumTitle: Total Junk

Sie können auch die URL der Funktion im Browser aufrufen, um das Ergebnis der SQL-Abfrage zu sehen.

Clean-up

So vermeiden Sie, dass Ihrem Google Cloud-Konto für die in diesem Dokument verwendeten Ressourcen für Cloud Spanner und Cloud Run Functions weitere Gebühren berechnet werden:

  1. Löschen Sie die Instanz:

    gcloud spanner instances delete test-instance

  2. Löschen Sie die von Ihnen bereitgestellte Funktion:

    Node.js 

    gcloud functions delete get

    Python 

    gcloud functions delete spanner_read_data

    Go

    gcloud functions delete HelloSpanner

    Java 

    gcloud functions delete java-spanner-function

Nächste Schritte