1. Übersicht
In diesem Lab werden Funktionen und Fähigkeiten vorgestellt, mit denen der Entwicklungsworkflow für Softwareentwickler optimiert werden kann, die mit der Entwicklung von Java-Anwendungen in einer Containerumgebung betraut sind. Bei der typischen Containerentwicklung muss der Nutzer die Details von Containern und den Container-Build-Prozess genau kennen. Außerdem müssen Entwickler in der Regel den Ablauf unterbrechen, um ihre Anwendungen in Remote-Umgebungen zu testen und zu debuggen. Mit den in dieser Anleitung erwähnten Tools und Technologien können Entwickler effektiv mit Containeranwendungen arbeiten, ohne ihre IDE zu verlassen.
Lerninhalte
In diesem Lab lernen Sie Methoden für die Entwicklung mit Containern in GCP kennen, darunter:
- InnerLoop-Entwicklung mit Cloud Workstations
- Neue Java-Startanwendung erstellen
- Der Entwicklungsprozess
- Entwickeln eines einfachen CRUD Rest-Dienstes
- Anwendung im GKE-Cluster debuggen
- Anwendung mit Cloud SQL-Datenbank verbinden
2. Einrichtung und Anforderungen
Umgebung zum selbstbestimmten Lernen einrichten
- Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.
- Der Projektname ist der Anzeigename für die Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
- Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf die Projekt-ID verweisen, die üblicherweise als
PROJECT_ID
gekennzeichnet ist. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID erstellen. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen. - Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.
- Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab sollte möglichst wenig kosten. Wenn Sie Ressourcen herunterfahren möchten, um über diese Anleitung hinaus keine Kosten zu verursachen, können Sie die von Ihnen erstellten Ressourcen oder das gesamte Projekt löschen. Neue Google Cloud-Nutzer haben Anspruch auf eine kostenlose Testversion mit 300$Guthaben.
Cloud Shell-Editor starten
Dieses Lab wurde für die Verwendung mit dem Google Cloud Shell-Editor entwickelt und getestet. So greifen Sie auf den Editor zu:
- Rufen Sie Ihr Google-Projekt unter https://console.cloud.google.com auf.
- Klicken Sie rechts oben auf das Symbol für den Cloud Shell-Editor
- Unten im Fenster wird ein neuer Bereich geöffnet.
- Klicken Sie auf die Schaltfläche „Editor öffnen“.
- Der Editor wird mit einem Explorer auf der rechten Seite und dem Editor im mittleren Bereich geöffnet.
- Unten auf dem Bildschirm sollte außerdem ein Terminalbereich verfügbar sein.
- Wenn das Terminal NICHT geöffnet ist, verwende die Tastenkombination „Strg +“, um ein neues Terminalfenster zu öffnen
gcloud einrichten
Legen Sie in Cloud Shell Ihre Projekt-ID und die Region fest, in der Sie die Anwendung bereitstellen möchten. Speichern Sie sie als Variablen des Typs PROJECT_ID
und REGION
.
export REGION=us-central1
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
Quellcode klonen
Den Quellcode für dieses Lab finden Sie auf GitHub im Container-Entwicklerworkshop der Google Cloud Platform. Klonen Sie es mit dem folgenden Befehl und wechseln Sie dann in das Verzeichnis.
git clone https://github.com/GoogleCloudPlatform/container-developer-workshop.git
cd container-developer-workshop/labs/spring-boot
In diesem Lab verwendete Infrastruktur bereitstellen
In diesem Lab stellen Sie Code in GKE bereit und greifen auf Daten zu, die in einer Cloud SQL-Datenbank gespeichert sind. Mit dem Einrichtungsskript unten wird diese Infrastruktur für Sie vorbereitet. Die Bereitstellung dauert über 25 Minuten. Warten Sie, bis das Skript abgeschlossen ist, bevor Sie mit dem nächsten Abschnitt fortfahren.
./setup_with_cw.sh &
Cloud Workstations-Cluster
Öffnen Sie Cloud Workstations in der Cloud Console. Warten Sie, bis der Cluster den Status READY
hat.
Workstationkonfiguration erstellen
Wenn die Verbindung zu Ihrer Cloud Shell-Sitzung getrennt wurde, klicken Sie auf „Wieder verbinden“. und führen Sie dann den Befehl „gcloud cli“ aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispiel-Projekt-ID unten durch Ihre Qwiklabs-Projekt-ID, bevor Sie den Befehl ausführen.
gcloud config set project qwiklabs-gcp-project-id
Führen Sie das folgende Skript im Terminal aus, um eine Cloud Workstations-Konfiguration zu erstellen.
cd ~/container-developer-workshop/labs/spring-boot
./workstation_config_setup.sh
Überprüfen Sie die Ergebnisse im Abschnitt „Konfigurationen“. Es dauert zwei Minuten, bis der Status BEREIT aktiviert ist.
Öffnen Sie Cloud Workstations in der Console und erstellen Sie eine neue Instanz.
Ändern Sie den Namen in my-workstation
und wählen Sie die vorhandene Konfiguration aus: codeoss-java
.
Prüfen Sie die Ergebnisse im Abschnitt „Workstations“.
Workstation starten
Starten und starten Sie die Workstation.
Du kannst Cookies von Drittanbietern zulassen, indem du auf das Symbol in der Adressleiste klickst.
Klicken Sie auf „Website funktioniert nicht?“.
Klicke auf „Cookies zulassen“.
Sobald die Workstation gestartet wurde, wird Code OSS IDE angezeigt. Klicken Sie auf „Als erledigt markieren“. auf der Seite „Erste Schritte“.
3. Neue Java-Startanwendung erstellen
In diesem Abschnitt erstellen Sie mithilfe einer von spring.io bereitgestellten Beispielanwendung von Grund auf eine Java Spring Boot-Anwendung. Öffnen Sie ein neues Terminal.
Beispielanwendung klonen
- Startanwendung erstellen
curl https://start.spring.io/starter.zip -d dependencies=web -d type=maven-project -d javaVersion=17 -d packageName=com.example.springboot -o sample-app.zip
Wenn diese Meldung angezeigt wird, klicken Sie auf die Schaltfläche „Zulassen“, damit Sie das Einfügen auf die Workstation kopieren können.
- Anwendung entpacken
unzip sample-app.zip -d sample-app
- Öffnen Sie die Beispiel-App. Ordner
cd sample-app && code-oss-cloud-workstations -r --folder-uri="$PWD"
Spring-Boot-Entwicklertools hinzufügen und Jib
Um die Spring Boot-Entwicklertools zu aktivieren, suchen und öffnen Sie die Datei pom.xml im Explorer in Ihrem Editor. Fügen Sie als Nächstes den folgenden Code nach der Textzeile ein, die <description>Demo project for Spring Boot</description>
lautet.
- Spring-boot-devtools in pom.xml hinzufügen
Öffnen Sie pom.xml
im Stammverzeichnis des Projekts. Fügen Sie nach dem Eintrag Description
die folgende Konfiguration hinzu.
pom.xml
<!-- Spring profiles-->
<profiles>
<profile>
<id>sync</id>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</profile>
</profiles>
- jib-maven-plugin in pom.xml aktivieren
Jib ist ein Open-Source-Tool zur Java-Containerisierung von Google, mit dem Java-Entwickler Container mit den ihnen bekannten Java-Tools erstellen können. Jib ist ein schneller und einfacher Container-Image-Builder, der alle Schritte zum Verpacken Ihrer Anwendung in ein Container-Image übernimmt. Sie müssen weder ein Dockerfile schreiben noch Docker installieren. Außerdem ist die Anwendung direkt in Maven und Gradle integriert.
Scrollen Sie in der Datei pom.xml
nach unten und aktualisieren Sie den Abschnitt Build
, um das Jib-Plug-in einzubinden. Der Build-Abschnitt sollte nach Fertigstellung wie folgt aussehen.
pom.xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- Jib Plugin-->
<plugin>
<groupId>com.google.cloud.tools</groupId>
<artifactId>jib-maven-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<!-- Maven Resources Plugin-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
</plugin>
</plugins>
</build>
Manifeste generieren
Skaffold bietet integrierte Tools zur Vereinfachung der Containerentwicklung. In diesem Schritt initialisieren Sie Skaffold, wodurch automatisch grundlegende Kubernetes-YAML-Dateien erstellt werden. Der Prozess versucht, Verzeichnisse mit Container-Image-Definitionen wie ein Dockerfile zu ermitteln, und erstellt dann für jedes Verzeichnis ein Deployment und ein Dienstmanifest.
Führen Sie den folgenden Befehl im Terminal aus, um den Prozess zu starten.
- Führen Sie den folgenden Befehl im Terminal aus
skaffold init --generate-manifests
- Tun Sie Folgendes, wenn Sie dazu aufgefordert werden:
- Bewegen Sie den Cursor mit den Pfeilen auf
Jib Maven Plugin
- Drücken Sie die Leertaste, um die Option auszuwählen.
- Drücke zum Fortfahren die Eingabetaste
- Geben Sie 8080 als Port ein.
- Geben Sie y ein, um die Konfiguration zu speichern
Zwei Dateien werden dem Arbeitsbereich „skaffold.yaml
“ und „deployment.yaml
“ hinzugefügt
Skaffold-Ausgabe:
App-Name aktualisieren
Die in der Konfiguration enthaltenen Standardwerte stimmen derzeit nicht mit dem Namen Ihrer Anwendung überein. Aktualisieren Sie die Dateien so, dass sie auf den Namen Ihrer Anwendung anstatt auf die Standardwerte verweisen.
- Einträge in der Skaffold-Konfiguration ändern
skaffold.yaml
öffnen- Wählen Sie den Image-Namen aus, der derzeit als
pom-xml-image
festgelegt ist - Klicken Sie mit der rechten Maustaste und wählen Sie „Alle Vorkommen ändern“ aus.
- Geben Sie den neuen Namen als
demo-app
ein.
- Einträge in der Kubernetes-Konfiguration ändern
- Datei „
deployment.yaml
“ öffnen - Wählen Sie den Image-Namen aus, der derzeit als
pom-xml-image
festgelegt ist - Klicken Sie mit der rechten Maustaste und wählen Sie „Alle Vorkommen ändern“ aus.
- Geben Sie den neuen Namen als
demo-app
ein.
Modus für automatische Synchronisierung aktivieren
Um die Funktion „Hot Refresh“ zu optimieren, verwenden Sie die Synchronisierungsfunktion von Jib. In diesem Schritt konfigurieren Sie Skaffold, um dieses Feature im Build-Prozess zu verwenden.
Beachten Sie, dass das Symbol „Sync“ Profil, das Sie in der Skaffold-Konfiguration konfigurieren, nutzt die Spring-Synchronisierung. Profil, das Sie im vorherigen Schritt konfiguriert haben, in dem Sie die Unterstützung für spring-dev-tools aktiviert haben.
- Skaffold-Konfiguration aktualisieren
Ersetzen Sie in der Datei skaffold.yaml
den gesamten Build-Abschnitt der Datei durch die folgende Spezifikation. Ändern Sie keine anderen Abschnitte der Datei.
skaffold.yaml
build:
artifacts:
- image: demo-app
jib:
project: com.example:demo
type: maven
args:
- --no-transfer-progress
- -Psync
fromImage: gcr.io/distroless/java17-debian11:debug
sync:
auto: true
Standardroute hinzufügen
Erstellen Sie im Ordner „/src/main/java/com/example/springboot/
“ eine Datei mit dem Namen „HelloController.java
“.
Fügen Sie den folgenden Inhalt in die Datei ein, um eine Standard-HTTP-Route zu erstellen.
HelloController.java
package com.example.springboot;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Value;
@RestController
public class HelloController {
@Value("${target:local}")
String target;
@GetMapping("/")
public String hello()
{
return String.format("Hello from your %s environment!", target);
}
}
4. Der Entwicklungsprozess
In diesem Abschnitt führen Sie einige Schritte mit dem Cloud Code-Plug-in durch, um die grundlegenden Prozesse kennenzulernen und die Konfiguration und Einrichtung Ihrer Startanwendung zu validieren.
Cloud Code lässt sich in Skaffold einbinden, um den Entwicklungsprozess zu optimieren. Wenn Sie in den folgenden Schritten ein Deployment in GKE ausführen, erstellen Cloud Code und Skaffold automatisch das Container-Image, übertragen es per Push in eine Container Registry und stellen die Anwendung dann in GKE bereit. Das geschieht im Hintergrund und abstrahiert die Details außerhalb des Entwicklungsablaufs. Cloud Code verbessert außerdem Ihren Entwicklungsprozess, indem es herkömmliche Debugging- und Hotsync-Funktionen für die containerbasierte Entwicklung bereitstellt.
In Google Cloud anmelden
Klicken Sie auf das Cloud Code-Symbol und wählen Sie „In Google Cloud anmelden“ aus:
Klicken Sie auf „Zur Anmeldung fortfahren“.
Prüfen Sie die Ausgabe im Terminal und öffnen Sie den Link:
Melden Sie sich mit den Anmeldedaten Ihrer Qwiklabs-Teilnehmer an.
Wählen Sie „Zulassen“ aus:
Kopieren Sie den Bestätigungscode und kehren Sie zum Tab „Workstation“ zurück.
Füge den Bestätigungscode ein und drücke die Eingabetaste.
Kubernetes-Cluster hinzufügen
- Cluster hinzufügen
- Wählen Sie Google Kubernetes Engine aus:
- Projekt auswählen.
- Wählen Sie „quote-cluster“ aus. die bei der Ersteinrichtung erstellt wurde.
Aktuelle Projekt-ID mit gcloud cli festlegen
Kopieren Sie die Projekt-ID für dieses Lab von der Qwiklabs-Seite.
Führen Sie den Befehl „gcloud cli“ aus, um die Projekt-ID festzulegen. Ersetzen Sie die Beispielprojekt-ID, bevor Sie den Befehl ausführen.
gcloud config set project qwiklabs-gcp-project-id
Beispielausgabe:
Fehlerbehebung in Kubernetes
- Wählen Sie unten im linken Bereich Cloud Code aus.
- Wählen Sie im Bereich, der unter DEVELOPMENT SESSIONS (Entwicklungssitzungen) angezeigt wird, die Option „Debug on Kubernetes“ aus.
Scrollen Sie nach unten, falls die Option nicht angezeigt wird.
- Wähle „Ja“ aus. aktuellen Kontext zu verwenden.
- Wählen Sie „quote-cluster“ aus. die bei der Ersteinrichtung erstellt wurde.
- Wählen Sie das Container-Repository aus.
- Wähle im unteren Bereich den Tab „Output“ (Ausgabe) aus, um den Fortschritt und die Benachrichtigungen anzusehen
- Wählen Sie „Kubernetes: Run/Debug – Detail“ aus. im Drop-down-Menü „Kanal“ rechts, um zusätzliche Details und Logs aufzurufen, die live aus den Containern gestreamt werden
Warten Sie, bis die Anwendung bereitgestellt wurde.
- Prüfen Sie die in GKE bereitgestellte Anwendung in der Cloud Console.
- Kehren Sie zur vereinfachten Ansicht zurück, indem Sie „Kubernetes: Run/Debug“ auswählen. Dropdown-Menü auf dem Tab AUSGABE aus.
- Wenn der Build und die Tests abgeschlossen sind, wird auf dem Tab „Ausgabe“
Resource deployment/demo-app status completed successfully
angezeigt und die URL wird aufgeführt: „Forwarded URL from service demo-app: http://localhost:8080“ - Bewegen Sie den Mauszeiger im Cloud Code-Terminal auf die URL in der Ausgabe (http://localhost:8080) und wählen Sie in der angezeigten Kurzinfo „Link folgen“ aus.
Ein neuer Tab wird geöffnet und die Ausgabe sieht so aus:
Haltepunkte verwenden
- Öffnen Sie die
HelloController.java
App unter/src/main/java/com/example/springboot/HelloController.java
. - Suchen Sie die Rückgabeanweisung für den Stammpfad, der
return String.format("Hello from your %s environment!", target);
lautet. - Fügen Sie dieser Zeile einen Haltepunkt hinzu, indem Sie auf den leeren Bereich links neben der Zeilennummer klicken. Ein roter Indikator wird angezeigt, um darauf hinzuweisen, dass der Haltepunkt eingerichtet ist.
- Laden Sie Ihren Browser neu. Der Debugger stoppt den Prozess am Haltepunkt und ermöglicht es Ihnen, die Variablen und den Status der Anwendung zu untersuchen, die remote in GKE ausgeführt wird.
- Klicken Sie im Bereich „Variablen“ so lange auf „Ziel“, .
- Aktuellen Wert als „lokal“ beobachten
- Doppelklicken Sie auf den Variablennamen „target“. und im Pop-up
Ändern Sie den Wert in „Cloud Workstations“
- Klicken Sie im Steuerfeld zur Fehlerbehebung auf die Schaltfläche Weiter .
- Sehen Sie sich die Antwort in Ihrem Browser an. Sie enthält jetzt den aktualisierten Wert, den Sie gerade eingegeben haben.
- Entfernen Sie den Breakpoint, indem Sie auf den roten Indikator links neben der Zeilennummer klicken. Dadurch wird verhindert, dass die Ausführung des Codes in dieser Zeile gestoppt wird, während Sie in diesem Lab fortfahren.
Heiße Aufladung
- Ändern Sie die Anweisung, sodass ein anderer Wert zurückgegeben wird, z. B. "Hello from %s Code".
- Die Datei wird automatisch gespeichert und mit den Remote-Containern in GKE synchronisiert
- Aktualisieren Sie Ihren Browser, um die aktualisierten Ergebnisse zu sehen.
- Beenden Sie die Debugging-Sitzung, indem Sie auf das rote Quadrat in der Debugging-Symbolleiste klicken.
Wählen Sie „Ja, nach jeder Ausführung bereinigen“ aus.
5. Entwickeln eines einfachen CRUD Rest-Dienstes
Jetzt ist Ihre Anwendung vollständig für die Containerentwicklung konfiguriert und Sie haben den grundlegenden Entwicklungsworkflow mit Cloud Code durchgegangen. In den folgenden Abschnitten wenden Sie das Gelernte an. Dazu fügen Sie REST-Dienstendpunkte hinzu, die eine Verbindung zu einer verwalteten Datenbank in Google Cloud herstellen.
Abhängigkeiten konfigurieren
Der Anwendungscode verwendet eine Datenbank, um die übrigen Dienstdaten zu speichern. Stellen Sie sicher, dass die Abhängigkeiten verfügbar sind, indem Sie Folgendes in die Datei pom.xl einfügen.
- Öffnen Sie die Datei
pom.xml
und fügen Sie Folgendes in den Abschnitt „Abhängigkeiten“ der Konfiguration ein
pom.xml
<!-- Database dependencies-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
Code REST-Dienst
Quote.java
Erstellen Sie in /src/main/java/com/example/springboot/
eine Datei mit dem Namen Quote.java
und kopieren Sie den Code unten. Definiert das Entitätsmodell für das in der Anwendung verwendete Quote-Objekt.
package com.example.springboot;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.util.Objects;
@Entity
@Table(name = "quotes")
public class Quote
{
@Id
@Column(name = "id")
private Integer id;
@Column(name="quote")
private String quote;
@Column(name="author")
private String author;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getQuote() {
return quote;
}
public void setQuote(String quote) {
this.quote = quote;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Quote quote1 = (Quote) o;
return Objects.equals(id, quote1.id) &&
Objects.equals(quote, quote1.quote) &&
Objects.equals(author, quote1.author);
}
@Override
public int hashCode() {
return Objects.hash(id, quote, author);
}
}
QuoteRepository.java
Erstellen Sie unter src/main/java/com/example/springboot
eine Datei mit dem Namen QuoteRepository.java
und kopieren Sie den folgenden Code
package com.example.springboot;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
public interface QuoteRepository extends JpaRepository<Quote,Integer> {
@Query( nativeQuery = true, value =
"SELECT id,quote,author FROM quotes ORDER BY RANDOM() LIMIT 1")
Quote findRandomQuote();
}
Dieser Code verwendet JPA für die dauerhafte Speicherung der Daten. Die Klasse erweitert die Spring-JPARepository
-Schnittstelle und ermöglicht das Erstellen von benutzerdefiniertem Code. Sie haben dem Code die benutzerdefinierte Methode findRandomQuote
hinzugefügt.
QuoteController.java
Eine QuoteController
-Klasse stellt diese Funktion bereit, um den Endpunkt für den Dienst freizugeben.
Erstellen Sie unter src/main/java/com/example/springboot
eine Datei mit dem Namen QuoteController.java
und kopieren Sie den folgenden Inhalt
package com.example.springboot;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class QuoteController {
private final QuoteRepository quoteRepository;
public QuoteController(QuoteRepository quoteRepository) {
this.quoteRepository = quoteRepository;
}
@GetMapping("/random-quote")
public Quote randomQuote()
{
return quoteRepository.findRandomQuote();
}
@GetMapping("/quotes")
public ResponseEntity<List<Quote>> allQuotes()
{
try {
List<Quote> quotes = new ArrayList<Quote>();
quoteRepository.findAll().forEach(quotes::add);
if (quotes.size()==0 || quotes.isEmpty())
return new ResponseEntity<List<Quote>>(HttpStatus.NO_CONTENT);
return new ResponseEntity<List<Quote>>(quotes, HttpStatus.OK);
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<List<Quote>>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@PostMapping("/quotes")
public ResponseEntity<Quote> createQuote(@RequestBody Quote quote) {
try {
Quote saved = quoteRepository.save(quote);
return new ResponseEntity<Quote>(saved, HttpStatus.CREATED);
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@PutMapping("/quotes/{id}")
public ResponseEntity<Quote> updateQuote(@PathVariable("id") Integer id, @RequestBody Quote quote) {
try {
Optional<Quote> existingQuote = quoteRepository.findById(id);
if(existingQuote.isPresent()){
Quote updatedQuote = existingQuote.get();
updatedQuote.setAuthor(quote.getAuthor());
updatedQuote.setQuote(quote.getQuote());
return new ResponseEntity<Quote>(updatedQuote, HttpStatus.OK);
} else {
return new ResponseEntity<Quote>(HttpStatus.NOT_FOUND);
}
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@DeleteMapping("/quotes/{id}")
public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) {
Optional<Quote> quote = quoteRepository.findById(id);
if (quote.isPresent()) {
quoteRepository.deleteById(id);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
} else {
return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
}
Datenbankkonfigurationen hinzufügen
application.yaml
Fügen Sie die Konfiguration für die Back-End-Datenbank hinzu, auf die der Dienst zugreift. Bearbeiten oder erstellen Sie die Datei application.yaml
unter src/main/resources
und fügen Sie eine parametrisierte Spring-Konfiguration für das Back-End hinzu.
target: local
spring:
config:
activate:
on-profile: cloud-dev
datasource:
url: 'jdbc:postgresql://${DB_HOST:127.0.0.1}/${DB_NAME:quote_db}'
username: '${DB_USER:user}'
password: '${DB_PASS:password}'
jpa:
properties:
hibernate:
jdbc:
lob:
non_contextual_creation: true
dialect: org.hibernate.dialect.PostgreSQLDialect
hibernate:
ddl-auto: update
Datenbankmigration hinzufügen
Ordner „db/migration
“ unter „src/main/resources
“ erstellen
SQL-Datei erstellen: V1__create_quotes_table.sql
Fügen Sie den folgenden Inhalt in die Datei ein
V1__create_quotes_table.sql
CREATE TABLE quotes(
id INTEGER PRIMARY KEY,
quote VARCHAR(1024),
author VARCHAR(256)
);
INSERT INTO quotes (id,quote,author) VALUES (1,'Never, never, never give up','Winston Churchill');
INSERT INTO quotes (id,quote,author) VALUES (2,'While there''s life, there''s hope','Marcus Tullius Cicero');
INSERT INTO quotes (id,quote,author) VALUES (3,'Failure is success in progress','Anonymous');
INSERT INTO quotes (id,quote,author) VALUES (4,'Success demands singleness of purpose','Vincent Lombardi');
INSERT INTO quotes (id,quote,author) VALUES (5,'The shortest answer is doing','Lord Herbert');
Kubernetes-Konfiguration
Durch die folgenden Ergänzungen der Datei deployment.yaml
kann die Anwendung eine Verbindung zu den Cloud SQL-Instanzen herstellen.
- TARGET: Konfiguriert die Variable, um die Umgebung anzugeben, in der die App ausgeführt wird.
- SPRING_PROFILES_ACTIVE – zeigt das aktive Spring-Profil an, das als
cloud-dev
konfiguriert wird - DB_HOST – die private IP-Adresse für die Datenbank, die angezeigt wird, wenn die Datenbankinstanz erstellt wurde, oder durch Klicken auf
SQL
im Navigationsmenü der Google Cloud Console – ändern Sie den Wert. - DB_USER und DB_PASS – wie in der Cloud SQL-Instanzkonfiguration festgelegt, als Secret in der GCP gespeichert
Aktualisieren Sie die Datei „deployment.yaml“ mit dem Inhalt unten.
deployment.yaml
apiVersion: v1
kind: Service
metadata:
name: demo-app
labels:
app: demo-app
spec:
ports:
- port: 8080
protocol: TCP
clusterIP: None
selector:
app: demo-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: demo-app
labels:
app: demo-app
spec:
replicas: 1
selector:
matchLabels:
app: demo-app
template:
metadata:
labels:
app: demo-app
spec:
containers:
- name: demo-app
image: demo-app
env:
- name: PORT
value: "8080"
- name: TARGET
value: "Local Dev - CloudSQL Database - K8s Cluster"
- name: SPRING_PROFILES_ACTIVE
value: cloud-dev
- name: DB_HOST
value: ${DB_INSTANCE_IP}
- name: DB_PORT
value: "5432"
- name: DB_USER
valueFrom:
secretKeyRef:
name: gke-cloud-sql-secrets
key: username
- name: DB_PASS
valueFrom:
secretKeyRef:
name: gke-cloud-sql-secrets
key: password
- name: DB_NAME
valueFrom:
secretKeyRef:
name: gke-cloud-sql-secrets
key: database
Ersetzen Sie den Wert DB_HOST durch die Adresse Ihrer Datenbank, indem Sie die folgenden Befehle im Terminal ausführen:
export DB_INSTANCE_IP=$(gcloud sql instances describe quote-db-instance \
--format=json | jq \
--raw-output ".ipAddresses[].ipAddress")
envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml
Öffnen Sie die Datei „deployment.yaml“ und prüfen Sie, ob der Wert DB_HOST mit der Instanz-IP aktualisiert wurde.
Anwendung bereitstellen und validieren
- Wählen Sie unten im Cloud Shell-Editor den Bereich „Cloud Code“ und dann oben auf dem Bildschirm „Debug on Kubernetes“ aus.
- Wenn der Build und die Tests abgeschlossen sind, wird auf dem Tab „Ausgabe“
Resource deployment/demo-app status completed successfully
angezeigt und die URL wird aufgeführt: „Forwarded URL from service demo-app: http://localhost:8080“. Beachten Sie, dass der Port manchmal anders sein kann, z. B. 8081. Ist dies der Fall, legen Sie den entsprechenden Wert fest. Wert für URL im Terminal festlegen
export URL=localhost:8080
- Zufällige Zitate ansehen
Führen Sie im Terminal den folgenden Befehl mehrmals für den Endpunkt mit zufälligen Anführungszeichen aus. Wiederholter Aufruf mit unterschiedlichen Angeboten beobachten
curl $URL/random-quote | jq
- Angebot hinzufügen
Erstellen Sie mit dem unten aufgeführten Befehl ein neues Zitat mit id=6 und beobachten Sie, wie die Anfrage zurückgegeben wird
curl -H 'Content-Type: application/json' -d '{"id":"6","author":"Henry David Thoreau","quote":"Go confidently in the direction of your dreams! Live the life you have imagined"}' -X POST $URL/quotes
- Angebot löschen
Löschen Sie jetzt das Zitat, das Sie mit der Methode "delete" hinzugefügt haben, und beobachten Sie den Antwortcode HTTP/1.1 204
.
curl -v -X DELETE $URL/quotes/6
- Serverfehler
Wenn die letzte Anfrage noch einmal ausgeführt wird, nachdem der Eintrag bereits gelöscht wurde, tritt ein Fehlerstatus auf
curl -v -X DELETE $URL/quotes/6
Beachten Sie, dass die Antwort ein HTTP:500 Internal Server Error
zurückgibt.
Fehler in der Anwendung beheben
Im vorherigen Abschnitt haben Sie in der Anwendung einen Fehlerstatus festgestellt, als Sie versucht haben, einen Eintrag zu löschen, der sich nicht in der Datenbank befand. In diesem Abschnitt legen Sie einen Haltepunkt fest, um das Problem zu lokalisieren. Der Fehler ist im DELETE-Vorgang aufgetreten, daher arbeiten Sie mit der QuoteController-Klasse.
src/main/java/com/example/springboot/QuoteController.java
öffnen- Methode
deleteQuote()
finden - Finde die folgende Zeile:
Optional<Quote> quote = quoteRepository.findById(id);
- Legen Sie einen Haltepunkt für diese Zeile fest, indem Sie auf die leere Fläche links neben der Zeilennummer klicken.
- Ein roter Indikator wird angezeigt, der darauf hinweist, dass der Breakpoint festgelegt ist.
- Führen Sie den Befehl
delete
noch einmal aus.
curl -v -X DELETE $URL/quotes/6
- Wechseln Sie zurück zur Debug-Ansicht, indem Sie auf das Symbol in der linken Spalte klicken.
- Sehen Sie sich an, wie die Debug-Zeile in der QuoteController-Klasse gestoppt wurde.
- Klicken Sie im Debugger auf das
step over
-Symbol.
- Beachten Sie, dass ein Code den internen Serverfehler HTTP 500 an den Client zurückgibt, was nicht ideal ist.
Trying 127.0.0.1:8080... * Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0) > DELETE /quotes/6 HTTP/1.1 > Host: 127.0.0.1:8080 > User-Agent: curl/7.74.0 > Accept: */* > * Mark bundle as not supporting multiuse < HTTP/1.1 500 < Content-Length: 0 < Date: < * Connection #0 to host 127.0.0.1 left intact
Code aktualisieren
Der Code ist falsch und der Block else
sollte so refaktoriert werden, dass der Statuscode „HTTP 404 nicht gefunden“ zurückgegeben wird.
Korrigieren Sie den Fehler.
- Während die Fehlerbehebungssitzung noch läuft, schließen Sie die Anfrage ab, indem Sie auf „Weiter“ klicken im Steuerfeld zur Fehlerbehebung.
- Ändern Sie als Nächstes den
else
-Block in den Code:
else {
return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
}
Die Methode sollte so aussehen:
@DeleteMapping("/quotes/{id}") public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) { Optional<Quote> quote = quoteRepository.findById(id); if (quote.isPresent()) { quoteRepository.deleteById(id); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } else { return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND); } }
- Löschbefehl noch einmal ausführen
curl -v -X DELETE $URL/quotes/6
- Gehen Sie den Debugger durch und beobachten Sie, wie der Fehler "HTTP 404 Not Found" an den Aufrufer zurückgegeben wird.
Trying 127.0.0.1:8080... * Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0) > DELETE /quotes/6 HTTP/1.1 > Host: 127.0.0.1:8080 > User-Agent: curl/7.74.0 > Accept: */* > * Mark bundle as not supporting multiuse < HTTP/1.1 404 < Content-Length: 0 < Date: < * Connection #0 to host 127.0.0.1 left intact
- Beenden Sie die Debugging-Sitzung, indem Sie auf das rote Quadrat in der Debugging-Symbolleiste klicken.
6. Glückwunsch
Glückwunsch! In diesem Lab haben Sie eine komplett neue Java-Anwendung erstellt und so konfiguriert, dass sie effektiv mit Containern funktioniert. Anschließend haben Sie Ihre Anwendung in einem Remote-GKE-Cluster bereitgestellt und entsprechende Fehler behoben. Dabei folgten Sie dem Entwicklerablauf, der auch in herkömmlichen Anwendungspaketen verwendet wird.
Was Sie gelernt haben
- InnerLoop-Entwicklung mit Cloud Workstations
- Neue Java-Startanwendung erstellen
- Der Entwicklungsprozess
- Einfachen CRUD REST-Dienst entwickeln
- Anwendung im GKE-Cluster debuggen
- Anwendung mit Cloud SQL-Datenbank verbinden