Um die Suche zu vereinfachen und die Dokumentation zu verbessern, teilen wir die Dokumentation der 1. Generation und der 2. Generation in separate Gruppen ein.

Cloud Spanner mit Cloud Functions (2. Generation) verwenden

Cloud Spanner

Lernziele

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

Kosten

In dieser Anleitung werden Cloud Spanner und Cloud 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 Functions, einschließlich kostenloser Aufrufe, finden Sie unter Preise für Cloud Functions.

Hinweise

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.
Hinweis: Nach diesem Schritt sollten in der Datenbank zwei Tabellen mit den im Musikanwendungsschema angegebenen Beispieldaten vorhanden sein: Singers und Albums.
Aktivieren Sie die Cloud Functions und Cloud Build APIs.

APIs aktivieren
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
```
Bereiten Sie Ihre Entwicklungsumgebung vor:

Node.js

Einrichtungsleitfaden für Node.js aufrufen

Python

Einrichtungsleitfaden für Python aufrufen

Go

Zum Einrichtungsleitfaden für Go

Java

Zum Einrichtungsleitfaden für Java

Anwendung vorbereiten

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.
Einfach loslegen (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.

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

Node.js

cd nodejs-docs-samples/functions/spanner/

Python

cd python-docs-samples/functions/spanner/

Einfach loslegen (Go)

cd golang-samples/functions/spanner/

Java

cd java-docs-samples/functions/spanner/

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)

Einfach loslegen (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 bereitstellen

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

Node.js

gcloud functions deploy nodejs-spanner-function \
--gen2 \
--runtime=nodejs20 \
--region=REGION \
--source=. \
--entry-point=spannerQuickstart 
--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 python-spanner-function \
--gen2 \
--runtime=python312 \
--region=REGION \
--source=. \
--entry-point=spanner_read_data 
--trigger-http

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

Einfach loslegen (Go)

gcloud functions deploy go-spanner-function \
--gen2 \
--runtime=go121 \
--region=REGION \
--source=. \
--entry-point=HelloSpanner 
--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 \
--gen2 \
--runtime=java17 \
--region=REGION \
--source=. \
--entry-point=functions.HelloSpanner \
--memory=512MB 
--trigger-http

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

Ersetzen Sie REGION durch den Namen der Google Cloud-Region, in der Sie die Funktion bereitstellen möchten (z. B. us-west1).

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 mit den Cloud Functions-Funktionen 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:

curl URL

Ersetzen Sie URL durch den URL-Wert, der zurückgegeben wird, 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 absolviert und die Datenbank 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.

Bereinigen

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

Löschen Sie die Instanz:

gcloud spanner instances delete test-instance

Löschen Sie die von Ihnen bereitgestellte Funktion:

Node.js

gcloud functions delete nodejs-spanner-function

Python

gcloud functions delete python-spanner-function

Einfach loslegen (Go)

gcloud functions delete go-spanner-function

Java

gcloud functions delete java-spanner-function