1. Einführung
Mit Spring Framework 5.0 wurde spezielle Kotlin-Unterstützung hinzugefügt, die es Kotlin-Entwicklern erleichtert, Spring zu verwenden. Diese Änderungen haben zur Folge, dass die von Spring Cloud GCP bereitgestellten Google Cloud-Integrationen auch in Kotlin nahtlos funktionieren. In diesem Codelab erfahren Sie, wie einfach es ist, Google Cloud-Dienste in Ihren Kotlin-Anwendungen zu verwenden.
In diesem Codelab wird beschrieben, wie Sie eine einfache Registrierungsanwendung in Kotlin einrichten, die die Verwendung von GCP-Diensten wie Cloud Pub/Sub und Cloud SQL demonstriert.
Aufgaben
In diesem Codelab richten Sie eine Kotlin Spring Boot-Anwendung ein, die Registranteninformationen akzeptiert, in einem Cloud Pub/Sub-Thema veröffentlicht und in einer Cloud MySQL-Datenbank speichert.
Lerninhalte
So binden Sie Google Cloud-Dienste in Ihre Kotlin Spring-Anwendung ein.
Voraussetzungen
- Google Cloud Platform-Projekt
- Ein Browser, z. B. Chrome oder Firefox
Wie werden Sie diese Anleitung verwenden?
Wie würden Sie Ihre Erfahrung mit der Entwicklung von HTML/CSS-Web-Apps bewerten?
Wie würden Sie Ihre Erfahrungen mit der Verwendung von Google Cloud Platform-Diensten bewerten?
2. Einrichtung und Anforderungen
Umgebung zum selbstbestimmten Lernen einrichten
- 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.
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.
- 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.
Google Cloud Shell
Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Google Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.
Cloud Shell aktivieren
- 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.
- 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`
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. Pub/Sub-Ressourcen bereitstellen
Zuerst müssen wir ein Cloud Pub/Sub-Thema und ein Abo einrichten. In dieser Anwendung veröffentlichen wir Registrierungsinformationen in einem Pub/Sub-Thema. Die Informationen werden dann aus diesem Thema gelesen und in einer Datenbank gespeichert.
In dieser Anleitung verwenden wir Cloud Shell, um unsere Ressourcen bereitzustellen. Pub/Sub-Ressourcen können auch über den Cloud Pub/Sub-Bereich in der Google Cloud Console konfiguriert werden.
Aktivieren Sie zuerst die Pub/Sub API in Ihrem Cloud Shell-Terminal.
$ gcloud services enable pubsub.googleapis.com
Als Nächstes erstellen wir ein Pub/Sub-Thema mit dem Namen registrations für diese Anwendung. Die über die Anwendung eingereichten Registrierungsinformationen werden in diesem Thema veröffentlicht.
$ gcloud pubsub topics create registrations
Erstellen Sie schließlich ein Abo für das Thema. Mit einem Pub/Sub-Abo können Sie Nachrichten von einem Thema empfangen.
$ gcloud pubsub subscriptions create registrations-sub --topic=registrations
Sie haben jetzt ein Cloud Pub/Sub-Thema und ein Abo für Ihre Anwendung erstellt.
4. Cloud SQL-Instanz (MySQL) und -Datenbank erstellen
Für unsere Beispielanwendung müssen wir auch eine Datenbankinstanz einrichten, in der die Registranteninformationen gespeichert werden. In diesem Schritt wird auch das Cloud Shell-Terminal verwendet, um Cloud SQL-Ressourcen bereitzustellen. Sie können Ihre Cloud SQL-Instanzen auch über die Google Cloud Console aufrufen und konfigurieren.
Aktivieren Sie zuerst die Cloud SQL Admin API.
$ gcloud services enable sqladmin.googleapis.com
Als Nächstes stellen wir eine Cloud SQL-Instanz (MySQL) bereit. Die Ausführung dieses Befehls kann einige Zeit dauern.
$ gcloud sql instances create codelab-instance --region=us-east1
Nachdem Sie Ihre Cloud SQL-Instanz erstellt haben, erstellen Sie in Ihrer Instanz eine neue Datenbank mit dem Namen registrants.
$ gcloud sql databases create registrants --instance codelab-instance
Sie haben jetzt die Einrichtung der Cloud SQL-Instanz und ‑Datenbank für Ihre Anwendung abgeschlossen.
5. Spring Boot-Anwendung initialisieren
Wir können jetzt mit dem Schreiben der Anwendung beginnen. Für die nächsten Schritte wird weiterhin die in den Einrichtungsschritten beschriebene Cloud Shell verwendet.
Zuerst verwenden wir Initializr, um den Gerüstcode für das Projekt zu generieren. Führen Sie in Ihrem Cloud Shell-Fenster Folgendes aus:
$ cd ~
$ curl https://start.spring.io/starter.tgz \
-d language=kotlin \
-d bootVersion=2.4.0 \
-d dependencies=web,data-jpa,integration,cloud-gcp-pubsub,thymeleaf \
-d baseDir=registrations-codelab | tar -xzvf -
$ cd registrations-codelab
Mit diesem Befehl wird eine erste Maven-Projekteinrichtung sowie Gerüstcode für Ihre Anwendung im Verzeichnis registrations-codelab/ generiert. In den folgenden Abschnitten werden die Codeänderungen beschrieben, die für eine funktionierende Anwendung erforderlich sind.
Cloud Shell-Code-Editor
Am einfachsten können Sie Code in der Cloud Shell-Umgebung mit dem integrierten Cloud Shell-Code-Editor bearbeiten und ansehen.
Klicken Sie nach dem Öffnen einer Cloud Shell-Instanz auf das Stiftsymbol, um den Code-Editor zu öffnen. Im Editor sollten Sie die von Initializr erstellten Projektdateien direkt bearbeiten können.
6. Datenbankkonfiguration
Konfigurieren Sie zuerst Ihre Anwendung so, dass sie eine Verbindung zur von Ihnen eingerichteten Cloud MySQL-Datenbank herstellen kann. Die Spring Cloud GCP-Bibliotheken bieten einen Cloud MySQL-Starter, der die erforderlichen Abhängigkeiten für die Verbindung zu einer Cloud MySQL-Instanz bereitstellt.
Fügen Sie die spring-cloud-gcp-starter-sql-mysql-Abhängigkeit in die pom.xml des Projekts ein:
registrations-codelab/pom.xml
...
<dependencies>
... Other dependencies above ...
<!-- Add the MySQL starter to the list of dependencies -->
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>spring-cloud-gcp-starter-sql-mysql</artifactId>
</dependency>
</dependencies>
Außerdem müssen Sie die Konfigurationsdatei application.properties ändern, um Ihre Datenbankkonfiguration zu beschreiben. Kopieren Sie die folgenden Attribute in Ihre application.properties-Datei.
So finden Sie den Namen der Instanzverbindung zu Ihrer Datenbank:
$ gcloud sql instances describe codelab-instance \ --format 'value(connectionName)'
Die Ausgabe wird in der Datei application.properties verwendet, um die Verbindungsinformationen zu konfigurieren.
src/main/resources/application.properties
# Modify this property using the output from the previous command line. spring.cloud.gcp.sql.instance-connection-name=INSTANCE_CONNECTION_NAME # Your database name spring.cloud.gcp.sql.database-name=registrants # So app starts despite "table already exists" errors. spring.datasource.continue-on-error=true # Enforces database initialization spring.datasource.initialization-mode=always # Cloud SQL (MySQL) only supports InnoDB, not MyISAM spring.jpa.database-platform=org.hibernate.dialect.MySQL55Dialect spring.jpa.hibernate.ddl-auto=create-drop # This is used if you want to connect to a different database instance # user other than root; not used in codelab. # spring.datasource.username=root # This is used to specify the password of the database user; # not used in codelab. # spring.datasource.password=password
Das einzige Attribut, das Sie ändern müssen, ist der Name der Instanzverbindung. Dieser Wert muss als durch Doppelpunkte getrennter Wert im Format YOUR_GCP_PROJECT_ID:REGION:DATABASE_INSTANCE_NAME angegeben werden.
7. Statische Inhalte erstellen
Zuerst erstellen wir das Frontend für unsere Anwendung. Die App sollte ein Formular enthalten, mit dem Personen registriert werden können, sowie eine Ansicht, in der alle erfolgreichen Registrierungen angezeigt werden.
Erstellen Sie für die Startseite eine index.html mit dem Registrierungsformular.
src/main/resources/static/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Registration Sample Application</title>
</head>
<body>
<h1>Registration</h1>
<div>
<nav>
<a href="/">Home</a><br>
<a href="/registrants">Registered People</a><br>
</nav>
<p>
This is a demo registration application which sends user information to a Pub/Sub topic and
persists it into a MySQL database.
</p>
<h2>Register Person</h2>
<div>
<form action="/registerPerson" method="post">
First Name: <input type="text" name="firstName" />
Last Name: <input type="text" name="lastName" />
Email: <input type="text" name="email" />
<input type="submit" value="Submit"/>
</form>
</div>
</div>
</body>
</html>
Als Nächstes erstellen wir eine Thymeleaf-Vorlage mit dem Namen registrants.html, um die registrierten Nutzer anzuzeigen. Thymeleaf ist ein Vorlagen-Framework, mit dem wir dynamisch erstelltes HTML erstellen und bereitstellen. Die Vorlage sieht aus wie HTML, enthält aber einige zusätzliche Markdown-Elemente für dynamische Inhalte. Diese Vorlage akzeptiert einen einzelnen Parameter namens personsList, der alle Registranten enthält, die sich über die Anwendung registriert haben.
src/main/resources/templates/registrants.html
<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Registrants List</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
</head>
<body>
<h1>Registrants List</h1>
<p>
This page displays all the people who were registered through the Pub/Sub topic.
All results are retrieved from the MySQL database.
</p>
<table border="1">
<tr>
<th>First Name</th>
<th>Last Name</th>
<th>Email</th>
</tr>
<tr th:each="person : ${personsList}">
<td>[[${person.firstName}]]</td>
<td>[[${person.lastName}]]</td>
<td>[[${person.email}]]</td>
</tr>
</table>
</body>
</html>
An diesem Punkt können Sie prüfen, ob die statischen Inhalte bereitgestellt werden.
Erstellen und Ausführen der App mit Maven:
$ ./mvnw spring-boot:run
Klicken Sie im Cloud Shell-Fenster auf die Schaltfläche „Vorschau“ und prüfen Sie, ob die Startseite gerendert wird. Keine der Funktionen auf der Benutzeroberfläche funktioniert jedoch, da kein Web-Controller vorhanden ist. Das wird im nächsten Schritt hinzugefügt.
Drücken Sie nach der Vorschau der Anwendung CTRL+C, um die Anwendung zu beenden.
8. Registranten an ein Pub/Sub-Thema senden
In diesem Schritt implementieren wir die Funktion, mit der über das Webformular eingereichte Registrierungen in einem Cloud Pub/Sub-Thema veröffentlicht werden.
Datenklassen hinzufügen
Zuerst erstellen wir einige Kotlin-Datenklassen. Diese dienen als JPA-Entitäten und als Zwischenrepräsentation der über das Formular eingereichten Registranten.
Fügen Sie dem Demopaket zwei neue Dateien hinzu: eine Person-Klasse und eine Spring Data PersonRepository. Mit diesen beiden Klassen können wir Registrierungseinträge mithilfe von Spring Data JPA ganz einfach in unserer MySQL-Datenbank speichern und daraus abrufen.
src/main/kotlin/com/example/demo/Person.kt
package com.example.demo
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.Id
@Entity
data class Person(
val firstName: String,
val lastName: String,
val email: String,
@Id @GeneratedValue
var id: Long? = 0)
src/main/kotlin/com/example/demo/PersonRepository.kt
package com.example.demo
import org.springframework.data.repository.CrudRepository
interface PersonRepository : CrudRepository<Person, Long>
Webcontroller hinzufügen
Als Nächstes erstellen wir eine Controller-Klasse, die die Registranten aus dem Formular verarbeitet und die Informationen an das zuvor erstellte Cloud Pub/Sub-Thema sendet. Dieser Controller erstellt zwei Endpunkte:
/registerPerson: Der POST-Endpunkt, an den Registranteninformationen gesendet und dann an das Pub/Sub-Thema weitergeleitet werden. In der FunktionregisterPerson(..)werden die Informationen des Registranten mitPubSubTemplatean das Pub/Sub-Thema gesendet.PubSubTemplateist eine Convenience-Klasse aus den Spring Cloud GCP Pub/Sub-Integrationen, die den Boilerplate-Code minimiert, der für die Interaktion mit Cloud Pub/Sub erforderlich ist./registrants: Hier werden alle Registranten angezeigt, die erfolgreich in der Datenbank registriert wurden. Diese Informationen werden aus der MySQL-Instanz über das Spring Data-Repository abgerufen, das wir im vorherigen Schritt erstellt haben.
Erstellen Sie die folgende Controller-Klasse im Demopaket:
src/main/kotlin/com/example/demo/Controller.kt
package com.example.demo
import com.google.cloud.spring.pubsub.core.PubSubTemplate
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController
import org.springframework.web.servlet.ModelAndView
import org.springframework.web.servlet.view.RedirectView
@RestController
class Controller(val pubSubTemplate: PubSubTemplate, val personRepository: PersonRepository) {
// The Pub/Sub topic name created earlier.
val REGISTRATION_TOPIC = "registrations"
@PostMapping("/registerPerson")
fun registerPerson(
@RequestParam("firstName") firstName: String,
@RequestParam("lastName") lastName: String,
@RequestParam("email") email: String): RedirectView {
pubSubTemplate.publish(
REGISTRATION_TOPIC,
Person(firstName, lastName, email))
return RedirectView("/")
}
@GetMapping("/registrants")
fun getRegistrants(): ModelAndView {
val personsList = personRepository.findAll().toList()
return ModelAndView("registrants", mapOf("personsList" to personsList))
}
}
Der Controller liest die über das Webformular eingereichten Registranteninformationen und veröffentlicht sie dann im Pub/Sub-Thema.
JSON-Objekt-Mapper-Bean hinzufügen
Im Controller wird ein Person-Objekt im Pub/Sub-Thema veröffentlicht, nicht ein String. Das ist möglich, weil wir die Spring Cloud GCP-Unterstützung für benutzerdefinierte JSON-Nutzlasten nutzen, die an Themen gesendet werden. Mit den Bibliotheken können Sie Objekte in JSON serialisieren, JSON-Nutzlasten an ein Thema senden und die Nutzlast beim Empfang deserialisieren.
Damit Sie diese Funktion nutzen können, müssen wir Ihrem Anwendungskontext eine ObjectMapper-Bean hinzufügen. Diese ObjectMapper-Bean wird verwendet, um Objekte in JSON zu serialisieren und aus JSON zu deserialisieren, wenn Ihre Anwendung Nachrichten sendet und empfängt. Fügen Sie in der Klasse DemoApplication.kt die Spring-Bean JacksonPubSubMessageConverter hinzu:
src/main/kotlin/com/example/demo/DemoApplication.kt
package com.example.demo
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
// new imports to add
import org.springframework.context.annotation.Bean
import com.fasterxml.jackson.databind.ObjectMapper
import com.google.cloud.spring.pubsub.support.converter.JacksonPubSubMessageConverter
@SpringBootApplication
class DemoApplication {
// This bean enables serialization/deserialization of
// Java objects to JSON for Pub/Sub payloads
@Bean
fun jacksonPubSubMessageConverter(objectMapper: ObjectMapper) =
JacksonPubSubMessageConverter(objectMapper)
}
fun main(args: Array<String>) {
runApplication<DemoApplication>(*args)
}
An diesem Punkt können Sie versuchen, die Anwendung noch einmal auszuführen:
$ ./mvnw spring-boot:run
Über das Webformular auf der Hauptseite sendet die Anwendung die Informationen nun an das von Ihnen erstellte Pub/Sub-Thema. Allerdings passiert noch nichts Nützliches, da wir noch aus diesem Pub/Sub-Thema lesen müssen. Das erfolgt im nächsten Schritt.
9. Registranten aus dem Pub/Sub-Thema lesen
Im letzten Schritt verarbeiten wir die Informationen der Registranten aus dem Pub/Sub-Thema und speichern sie in der Cloud MySQL-Datenbank. Dadurch wird die Anwendung abgeschlossen. Sie können dann neue Registrierungen über das Formular einreichen und alle registrierten Nutzer über den /registrants-Endpunkt aufrufen.
Diese Anwendung nutzt Spring Integration, das viele praktische Abstraktionen für den Umgang mit Messaging bietet. Wir fügen ein PubSubInboundChannelAdapter hinzu, damit wir Nachrichten aus dem Pub/Sub-Thema lesen und zur weiteren Verarbeitung in die pubsubInputChannel einfügen können. Anschließend konfigurieren wir die Funktion messageReceiver mit @ServiceActivator, damit sie mit den Nachrichten aufgerufen wird, die auf dem pubsubInputChannel eingehen.
src/main/kotlin/com/example/demo/DemoApplication.kt
package com.example.demo
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.context.annotation.Bean
import com.fasterxml.jackson.databind.ObjectMapper
import org.springframework.cloud.gcp.pubsub.support.converter.JacksonPubSubMessageConverter
// new imports to add
import com.google.cloud.spring.pubsub.core.PubSubTemplate
import com.google.cloud.spring.pubsub.integration.AckMode
import com.google.cloud.spring.pubsub.integration.inbound.PubSubInboundChannelAdapter
import com.google.cloud.spring.pubsub.support.BasicAcknowledgeablePubsubMessage
import com.google.cloud.spring.pubsub.support.GcpPubSubHeaders
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.integration.annotation.ServiceActivator
import org.springframework.integration.channel.DirectChannel
import org.springframework.messaging.MessageChannel
import org.springframework.messaging.handler.annotation.Header
@SpringBootApplication
class DemoApplication {
private val REGISTRANT_SUBSCRIPTION = "registrations-sub"
@Autowired
private lateinit var personRepository: PersonRepository
// New Spring Beans to add
@Bean
fun pubsubInputChannel() = DirectChannel()
@Bean
fun messageChannelAdapter(
@Qualifier("pubsubInputChannel") inputChannel: MessageChannel,
pubSubTemplate: PubSubTemplate): PubSubInboundChannelAdapter {
val adapter = PubSubInboundChannelAdapter(
pubSubTemplate, REGISTRANT_SUBSCRIPTION)
adapter.outputChannel = inputChannel
adapter.ackMode = AckMode.MANUAL
adapter.payloadType = Person::class.java
return adapter
}
@ServiceActivator(inputChannel = "pubsubInputChannel")
fun messageReceiver(
payload: Person,
@Header(GcpPubSubHeaders.ORIGINAL_MESSAGE) message: BasicAcknowledgeablePubsubMessage) {
personRepository.save(payload)
print("Message arrived! Payload: $payload")
message.ack()
}
// ObjectMapper bean from previous step
@Bean
fun jacksonPubSubMessageConverter(objectMapper: ObjectMapper) = JacksonPubSubMessageConverter(objectMapper)
}
fun main(args: Array<String>) {
runApplication<DemoApplication>(*args)
}
An diesem Punkt haben Sie die Einrichtung der Anwendung abgeschlossen. Führen Sie folgenden Befehl aus, um zu prüfen, ob die App ordnungsgemäß funktioniert:
$ ./mvnw spring-boot:run
Klicken Sie noch einmal auf die Schaltfläche Vorschau und versuchen Sie, einen Nutzer zu registrieren, indem Sie das Formular ausfüllen und senden.
Klicken Sie auf den Link Registrierte Personen, um zu prüfen, ob der neue Registrant in der Tabelle angezeigt wird.
Herzlichen Glückwunsch! Sie haben es geschafft. Beenden Sie die Anwendung, indem Sie im Terminalfenster CTRL+C drücken.
10. Bereinigen
Um Ihre Umgebung zu bereinigen, müssen Sie das erstellte Pub/Sub-Thema und die Cloud MySQL-Instanz löschen.
Cloud SQL-Instanz löschen
$ gcloud sql instances delete codelab-instance
Pub/Sub-Ressourcen löschen
$ gcloud pubsub subscriptions delete registrations-sub $ gcloud pubsub topics delete registrations
11. Glückwunsch!
Sie haben jetzt eine Spring Kotlin-Anwendung geschrieben, die in Cloud Pub/Sub und Cloud SQL (MySQL) eingebunden ist.
Weitere Informationen
- Spring on GCP-Projekt: http://cloud.spring.io/spring-cloud-gcp/
- GitHub-Repository für Spring on GCP: https://github.com/GoogleCloudPlatform/spring-cloud-gcp
- Java in der Google Cloud Platform: https://cloud.google.com/java/
- Kotlin-Beispielanwendungen mit GCP: https://github.com/GoogleCloudPlatform/spring-cloud-gcp/tree/master/spring-cloud-gcp-kotlin-samples
Lizenz
Dieser Text ist mit einer Creative Commons Attribution 2.0 Generic License lizenziert.