Cloud Spanner mit Cloud Functions verwenden

Cloud Spanner

Ziele

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

Kosten

In dieser Anleitung werden 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.

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 die Cloud Functions und Cloud Build APIs.

    APIs aktivieren

  3. Installieren und initialisieren Sie das Cloud SDK.

    Wenn Sie das Cloud SDK bereits installiert haben, aktualisieren Sie es 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 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/

    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');
    
    // 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.
     */
    exports.get = 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

    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)
    
    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"
    	"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"
    
    // 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 get \
--runtime nodejs10 --trigger-http
Mit den folgenden Werten für das Flag --runtime können Sie Ihre bevorzugte Version von Node.js festlegen:
  • nodejs10
  • nodejs12
  • nodejs14 (öffentliche Vorschau)

Python

gcloud functions deploy spanner_read_data \
--runtime python38 --trigger-http
Mit den folgenden Werten für das Flag --runtime können Sie Ihre bevorzugte Version von Python festlegen:
  • python37
  • python38
  • python39 (öffentliche Vorschau)

Go

gcloud functions deploy HelloSpanner \
--runtime go113 --trigger-http
Mit diesen Werten für das Flag --runtime können Sie Ihre bevorzugte Version von Go festlegen:
  • go111 (veraltet)
  • go113

Java

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

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:

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.

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud-Konto für die in dieser Anleitung verwendeten Ressourcen für Cloud Spanner und Cloud 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 

Weitere Informationen