Spring Boot-Anwendung mit Cloud Spanner

1. Übersicht

Cloud Spanner ist ein hochverfügbares, horizontal skalierbares und multiregionales RDBMS. In diesem Codelab wird die kleinste Instanz von Cloud Spanner verwendet. Vergessen Sie aber nicht, sie nach Abschluss des Codelabs herunterzufahren.

Lerninhalte

• Cloud Spanner zum Speichern und Abrufen von Daten mit Spring Boot verwenden

Voraussetzungen

• Google Cloud Platform-Projekt
• Ein Browser wie Google Chrome oder Mozilla Firefox

Wie werden Sie diese Anleitung verwenden?

Nur lesen Lesen und Übungen durchführen

Wie würden Sie Ihre Erfahrungen mit der Verwendung von Google Cloud Platform-Diensten bewerten?

Anfänger Mittelstufe Fortgeschritten

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

1. Melden Sie sich in der Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder G Suite-Konto haben, müssen Sie eines erstellen.

Hinweis:Wir empfehlen Ihnen, sich die URL console.cloud.google.com zu merken. Damit können Sie mühelos auf die Cloud Console zugreifen.

Notieren Sie sich die Projekt-ID, also den projektübergreifend nur einmal vorkommenden Namen eines Google Cloud-Projekts. Der oben angegebene Name ist bereits vergeben und kann leider nicht mehr verwendet werden. Sie wird später in diesem Codelab als PROJECT_ID bezeichnet.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie den Standardspeicherort auf Keine Organisation belassen. Wenn Sie ein G Suite-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Google Cloud-Ressourcen verwenden zu können.

Die Durchführung dieses Codelabs sollte keine oder nur geringe Kosten verursachen. Folgen Sie bitte der Anleitung im Abschnitt „Bereinigen“, in der Sie erfahren, wie Sie Ressourcen herunterfahren können, damit nach Abschluss dieser Anleitung keine Gebühren anfallen. Neue Nutzer von Google Cloud kommen für das Programm für den kostenlosen Testzeitraum mit einem Guthaben von 300$ infrage.

Cloud Shell aktivieren

1. Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter. So sieht dieses Fenster aus:

Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.

Diese virtuelle Maschine verfügt über sämtliche Entwicklertools, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser oder Ihrem Chromebook erledigt werden.

Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie bereits authentifiziert sind und für das Projekt schon Ihre Projekt-ID eingestellt ist.

2. Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Hinweis:Das gcloud-Befehlszeilentool ist ein leistungsstarkes und vereinheitlichtes Befehlszeilentool in Google Cloud. Das Tool ist in der Cloud Shell vorinstalliert. Sie werden feststellen, dass die Tab-Vervollständigung unterstützt wird. Weitere Informationen finden Sie in der Übersicht über das gcloud-Befehlszeilentool.

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

3. Cloud Spanner initialisieren

Cloud Spanner API mit der gcloud CLI aktivieren:

gcloud services enable spanner.googleapis.com

Cloud Spanner-Instanz erstellen:

gcloud spanner instances create spanner-instance \
 --config=regional-us-central1 \
 --nodes=1 --description="A Spanner Instance"

Erstellen Sie eine Datenbank in der Instanz:

gcloud spanner databases create orders \
  --instance=spanner-instance

Erstellen Sie eine schema.ddl-Datei, um das Datenschema zu beschreiben:

cat << EOF > schema.ddl
CREATE TABLE orders (
  order_id STRING(36) NOT NULL,
  description STRING(255),
  creation_timestamp TIMESTAMP,
) PRIMARY KEY (order_id);

CREATE TABLE order_items (
  order_id STRING(36) NOT NULL,
  order_item_id STRING(36) NOT NULL,
  description STRING(255),
  quantity INT64,
) PRIMARY KEY (order_id, order_item_id),
  INTERLEAVE IN PARENT orders ON DELETE CASCADE;
EOF

Schema auf die Cloud Spanner-Datenbank anwenden:

gcloud spanner databases ddl update orders \
  --instance=spanner-instance \
  --ddl="$(<schema.ddl)"

4. Neue Spring Boot-Java-Anwendung booten

Verwenden Sie in der Cloud Shell-Umgebung den folgenden Befehl, um eine neue Spring Boot-Anwendung zu initialisieren und zu booten:

$ curl https://start.spring.io/starter.tgz \
  -d packaging=jar \
  -d dependencies=cloud-gcp,web,lombok \
  -d baseDir=spanner-example \
  -d type=maven-project \
  -d bootVersion=3.2.6 | tar -xzvf -

$ cd spanner-example

Dadurch wird ein neues Verzeichnis spanner-example/ mit einem neuen Maven-Projekt, dem Maven-Wrapper pom.xml und einem Anwendungseinstiegspunkt erstellt.

Fügen Sie in der Datei pom.xml den Spring Data Cloud Spanner-Starter hinzu.

spanner-example/pom.xml

<project>
  ...
  <dependencies>
        ...
        <!-- Add Spring Cloud GCP Spanner Starter -->
        <dependency>
                <groupId>com.google.cloud</groupId>
                <artifactId>spring-cloud-gcp-starter-data-spanner</artifactId>
        </dependency>

        ...

  </dependencies>

  ...
</project>

Konfigurieren Sie in „application.properties“ die Verbindungsinformationen für die Spanner-Datenbank:

spanner-example/src/main/resources/application.properties

spring.cloud.gcp.spanner.instance-id=spanner-instance
spring.cloud.gcp.spanner.database=orders

Prüfen Sie, ob JAVA_HOME auf die richtige Version eingestellt ist:

export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64/

Erstellen Sie die App neu, um sicherzustellen, dass Ihre Maven-Konfiguration korrekt ist:

./mvnw package

5. Entitäten erstellen

Mit der Spring Data Spanner-Unterstützung von Spring Cloud GCP können Sie mit Spring Data ganz einfach ein Java-Objekt und eine idiomatische ORM-Zuordnung zu einer Spanner-Tabelle erstellen.

Erstellen Sie zuerst eine OrderItem-Klasse.

spanner-example/src/main/java/com/example/demo/OrderItem.java

package com.example.demo;

import com.google.cloud.spring.data.spanner.core.mapping.Column;
import com.google.cloud.spring.data.spanner.core.mapping.PrimaryKey;
import com.google.cloud.spring.data.spanner.core.mapping.Table;

@Table(name="order_items")
@Data
class OrderItem {
  @PrimaryKey(keyOrder = 1)
  @Column(name="order_id")
  private String orderId;

  @PrimaryKey(keyOrder = 2)
  @Column(name="order_item_id")
  private String orderItemId;

  private String description;
  private Long quantity;
}

Für über- und untergeordnete Beziehungen in Spanner sollten Sie einen zusammengesetzten Primärschlüssel verwenden. In diesem Beispiel ist der zusammengesetzte Schlüssel order_id und order_item_id.

Erstellen Sie als Nächstes eine Order-Klasse:

spanner-example/src/main/java/com/example/demo/Order.java

package com.example.demo;

import java.time.LocalDateTime;
import java.util.List;
import lombok.Data;
import com.google.cloud.spring.data.spanner.core.mapping.Column;
import com.google.cloud.spring.data.spanner.core.mapping.Interleaved;
import com.google.cloud.spring.data.spanner.core.mapping.PrimaryKey;
import com.google.cloud.spring.data.spanner.core.mapping.Table;

@Table(name="orders")
@Data
public class Order {
  @PrimaryKey
  @Column(name="order_id")
  private String id;

  private String description;

  @Column(name="creation_timestamp")
  private LocalDateTime timestamp;

  @Interleaved
  private List<OrderItem> items;
}

In dieser Klasse wird die Annotation @Interleaved verwendet, um eine 1:n-Beziehung zu Positionen zu erstellen.

6. OrderRepository-Schnittstelle erstellen

Erstellen Sie die OrderRepository-Klasse mit folgendem Inhalt:

spanner-example/src/main/java/com/example/demo/OrderRepository.java

package com.example.demo;

import com.google.cloud.spring.data.spanner.repository.SpannerRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface OrderRepository extends SpannerRepository<Order, String> {
}

Die Schnittstelle erweitert SpannerRepository<Order, String>, wobei Order die Domain-Klasse und String der Typ des Primärschlüssels ist. Spring Data bietet über diese Schnittstelle automatisch CRUD-Zugriff und Sie müssen keinen zusätzlichen Code erstellen.

7. REST-Controller für grundlegende Vorgänge erstellen

Öffnen Sie die Hauptanwendungsklasse DemoApplication und ändern Sie sie so, dass sie so aussieht:

spanner-example/src/main/java/com/example/demo/DemoApplication.java

package com.example.demo;

import java.time.LocalDateTime;
import java.util.UUID;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;

@SpringBootApplication
public class DemoApplication {
        public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
        }
}

@RestController
class OrderController {
  private final OrderRepository orderRepository;

        OrderController(OrderRepository orderRepository) {
                this.orderRepository = orderRepository;
        }

        @GetMapping("/api/orders/{id}")
        public Order getOrder(@PathVariable String id) {
          return orderRepository.findById(id)
                                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, id + " not found"));
        }

        @PostMapping("/api/orders")
        public String createOrder(@RequestBody Order order) {
                // Spanner currently does not auto generate IDs
                // Generate UUID on new orders
                order.setId(UUID.randomUUID().toString());
                order.setTimestamp(LocalDateTime.now());

                order.getItems().forEach(item -> {
                        // Assign parent ID, and also generate child ID
                        item.setOrderId(order.getId());
                        item.setOrderItemId(UUID.randomUUID().toString());
                });

          Order saved = orderRepository.save(order);
          return saved.getId();
        }
}

8. Anwendung ausführen

Erstellen Sie die Anwendung neu und führen Sie sie aus:

./mvnw spring-boot:run

Der Server sollte ordnungsgemäß gestartet werden und Port 8080 überwachen.

Sie können einen Auftragsdatensatz an den Endpunkt senden:

curl -H"Content-Type: application/json" -d'{"description": "My orders", "items": [{"description": "Android Phone", "quantity": "1"}]}' \
  http://localhost:8080/api/orders

Sie sollte mit der UUID der Bestellung antworten.

Sie können die Bestellung dann mit der UUID abrufen:

curl http://localhost:8080/api/orders/REPLACE_WITH_ORDER_UUID

Wenn Sie sehen möchten, wie die Daten in Cloud Spanner gespeichert werden, rufen Sie die Cloud Console auf und gehen Sie zu Spanner → Spanner-Instanz → order database → orders table → Data (Spanner → Spanner-Instanz → Auftragsdatenbank → Auftragstabelle → Daten).

9. Bereinigen

Löschen Sie die Cloud Spanner-Instanz, um Kosten zu vermeiden.

gcloud spanner instances delete spanner-instance -q

10. Glückwunsch!

In diesem Codelab haben Sie eine interaktive CLI-Anwendung erstellt, mit der Daten in Cloud Spanner gespeichert und abgerufen werden können.

Weitere Informationen

• Cloud Spanner: https://cloud.google.com/spanner/
• Spring on GCP-Projekt: https://googlecloudplatform.github.io/spring-cloud-gcp/reference/html/
• GitHub-Repository für Spring on GCP: https://github.com/spring-cloud/spring-cloud-gcp
• Java auf der Google Cloud Platform: https://cloud.google.com/java/

Lizenz

Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.