InnerLoop-Entwicklung mit Java – Spring Boot

1. Übersicht

In diesem Lab werden Funktionen und Möglichkeiten zur Optimierung des Entwicklungsworkflows für Softwareentwickler vorgestellt, 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:

• Einrichtung und Anforderungen
• Neue Java-Startanwendung erstellen
• Der Entwicklungsprozess
• Entwickeln eines einfachen CRUD Rest-Dienstes
• Bereinigen

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

1. 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 und jederzeit aktualisiert werden kann.
• Die Projekt-ID muss für alle Google Cloud-Projekte eindeutig sein und ist 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 in der Regel als PROJECT_ID identifiziert wird. Wenn es dir nicht gefällt, kannst du eine weitere zufällige Projekt-ID generieren. Du kannst aber auch selbst eine andere testen, um zu sehen, ob sie verfügbar ist. Dann ist es „eingefroren“ nachdem das Projekt erstellt wurde.
• Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Achtung:Eine Projekt-ID muss global eindeutig sein und kann nach der Auswahl von niemandem mehr verwendet werden. Sie sind der einzige Nutzer dieser ID. Wenn ein Projekt gelöscht wird, kann diese ID nicht mehr verwendet werden.

Hinweis:Wenn Sie ein Gmail-Konto verwenden, können Sie die Standardeinstellung Keine Organisation beibehalten. Wenn Sie ein Google Workspace-Konto verwenden, wählen Sie einen Standort aus, der für Ihre Organisation sinnvoll ist.

2. 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 beenden möchten, damit über diese Anleitung hinaus keine Kosten anfallen, führen Sie eine Bereinigung durch am Ende des Codelabs. 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:

1. Rufen Sie Ihr Google-Projekt unter https://console.cloud.google.com auf.
2. Klicken Sie rechts oben auf das Symbol für den Cloud Shell-Editor

3. Unten im Fenster wird ein neuer Bereich geöffnet.
4. Klicken Sie auf die Schaltfläche „Editor öffnen“.

5. Der Editor wird mit einem Explorer auf der rechten Seite und dem Editor im mittleren Bereich geöffnet.
6. Unten auf dem Bildschirm sollte außerdem ein Terminalbereich verfügbar sein.
7. 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 PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')

Quellcode abrufen

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 10 Minuten. Während die Einrichtung verarbeitet wird, kannst du mit den nächsten Schritten fortfahren.

./setup.sh

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.

Beispielanwendung klonen

1. Startanwendung erstellen

curl  https://start.spring.io/starter.zip -d dependencies=web -d type=maven-project -d javaVersion=11 -d packageName=com.example.springboot -o sample-app.zip

2. Anwendung entpacken

unzip sample-app.zip -d sample-app

3. Wechseln Sie zum Verzeichnis „sample-app“ und öffnen Sie den Ordner im Cloud Shell-IDE-Arbeitsbereich

cd sample-app && cloudshell workspace .

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, in der <description>Demo Project for Spring Boot</description> steht.

1. Spring-boot-devtools in pom.xml hinzufügen

Öffnen Sie die Datei „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>

2. jib-maven-plugin in pom.xml aktivieren

Jib ist ein Open-Source-Tool von Google zur Java-Containerisierung, mit dem Java-Entwickler Container mit 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 kein Dockerfile schreiben und Docker ist auch nicht direkt in Maven und Gradle eingebunden.

Scrollen Sie in der Datei pom.xml nach unten und aktualisieren Sie den Abschnitt Build, sodass das Jib-Plug-in enthalten ist. 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>

Wählen Sie Always aus, wenn Sie zur Änderung der Build-Datei aufgefordert werden.

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 aus, um den Prozess zu starten.

1. Führen Sie den folgenden Befehl im Terminal aus

skaffold init --generate-manifests

2. 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ücken Sie die Eingabetaste, um fortzufahren

3. Geben Sie 8080 als Port ein.
4. Geben Sie y ein, um die Konfiguration zu speichern

Der Arbeitsbereichvisualisierung werden zwei Dateien hinzugefügt: skaffold.yaml und deployment.yaml

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.

1. 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.

2. 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.

Hot Sync 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.

1. 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/java:debug
    sync:
      auto: true

Standardroute hinzufügen

Erstellen Sie eine Datei mit dem Namen HelloController.java unter /src/main/java/com/example/springboot/.

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 Kubernetes bereitstellen

1. Wählen Sie unten im Cloud Shell-Editor den Bereich „Cloud Code“ aus.

2. Wählen Sie im oberen Bereich die Option „Debug on Kubernetes“ aus. Wenn Sie dazu aufgefordert werden, wählen Sie „Ja“ aus, um den aktuellen Kubernetes-Kontext zu verwenden.

3. Wenn Sie den Befehl zum ersten Mal ausführen, wird oben auf dem Bildschirm eine Eingabeaufforderung angezeigt, in der Sie gefragt werden, ob Sie den aktuellen Kubernetes-Kontext verwenden möchten. Wählen Sie „Yes“ (Ja) aus. den aktuellen Kontext akzeptieren und nutzen.

4. Als Nächstes wird eine Eingabeaufforderung angezeigt, in der Sie gefragt werden, welche Container Registry verwendet werden soll. Drücken Sie die Eingabetaste, um den angegebenen Standardwert zu übernehmen

5. Wähle im unteren Bereich den Tab „Output“ (Ausgabe) aus, um den Fortschritt und die Benachrichtigungen anzusehen

6. 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

7. Kehren Sie zur vereinfachten Ansicht zurück, indem Sie „Kubernetes: Run/Debug“ auswählen. aus dem Drop-down-Menü
8. 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“
9. 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 „Webvorschau öffnen“ aus.

Die Antwort lautet:

Hello from your local environment!

Haltepunkte verwenden

1. Öffnen Sie die Anwendung HelloController.java unter /src/main/java/com/example/springboot/HelloController.java.
2. Suchen Sie die Rückgabeanweisung für den Stammpfad, der return String.format("Hello from your %s environment!", target); lautet.
3. 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.
4. Laden Sie Ihren Browser neu. Der Debugger stoppt den Prozess am Haltepunkt und ermöglicht es Ihnen, den variablen Sandstatus der Anwendung zu untersuchen, die remote in GKE ausgeführt wird.
5. Klicken Sie im Bereich „Variablen“ so lange auf „Ziel“, .
6. Aktuellen Wert als „lokal“ beobachten
7. Doppelklicken Sie auf den Variablennamen „target“. und im Pop-up-Fenster den Wert in einen anderen Wert wie z. B. „Cloud“ ändern.
8. Klicken Sie im Steuerfeld zur Fehlerbehebung auf die Schaltfläche Weiter .
9. Sehen Sie sich die Antwort in Ihrem Browser an. Sie enthält jetzt den aktualisierten Wert, den Sie gerade eingegeben haben.

Heiße Aufladung

1. Ändern Sie die Anweisung, sodass ein anderer Wert zurückgegeben wird, z. B. "Hello from %s Code".
2. Die Datei wird automatisch gespeichert und mit den Remote-Containern in GKE synchronisiert
3. Aktualisieren Sie Ihren Browser, um die aktualisierten Ergebnisse zu sehen.
4. Beenden Sie die Fehlerbehebungssitzung durch Klicken auf das rote Quadrat in der Debugging-Symbolleiste .

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 üben Sie das Gelernte. Sie fügen 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.

1. Ö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>

Restdienst programmieren

Quote.java

Erstellen Sie eine Datei mit dem Namen Quote.java in /src/main/java/com/example/springboot/ und kopieren Sie den Code unten. Definiert das Entitätsmodell für das in der Anwendung verwendete Quote-Objekt.

package com.example.springboot;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.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 eine Datei namens QuoteRepository.java unter src/main/java/com/example/springboot 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 eine Datei mit dem Namen QuoteController.java unter src/main/java/com/example/springboot 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) {
        try {
            quoteRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            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

Erstellen Sie einen Ordner unter src/main/resources/db/migration/

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

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

Anwendung bereitstellen und validieren

1. Wählen Sie unten im Cloud Shell-Editor den Bereich „Cloud Code“ und dann oben auf dem Bildschirm „Debug on Kubernetes“ aus.
2. 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“
3. Zufällige Zitate ansehen

Führen Sie im Cloud Shell-Terminal den unten stehenden Befehl mehrmals für den Endpunkt mit zufälligen Anführungszeichen aus. Wiederholten Aufruf mit unterschiedlichen Angeboten beobachten

curl -v 127.0.0.1:8080/random-quote

4. 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 -v -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 127.0.0.1:8080/quotes

5. 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 127.0.0.1:8080/quotes/6

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 127.0.0.1:8080/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.

1. Öffnen Sie src.main.java.com.example.springboot.QuoteController.java
2. Methode deleteQuote() finden
3. Suchen Sie die Zeile, in der ein Element aus der Datenbank gelöscht wird: quoteRepository.deleteById(id);
4. Legen Sie einen Haltepunkt für diese Zeile fest, indem Sie auf die leere Fläche links neben der Zeilennummer klicken.
5. Ein roter Indikator wird angezeigt, der darauf hinweist, dass der Breakpoint festgelegt ist.
6. Führen Sie den Befehl delete noch einmal aus.

curl -v -X DELETE 127.0.0.1:8080/quotes/6

7. Wechseln Sie zurück zur Debug-Ansicht, indem Sie auf das Symbol in der linken Spalte klicken.
8. Sehen Sie sich an, wie die Debug-Zeile in der QuoteController-Klasse gestoppt wurde.
9. Klicken Sie im Debugger auf das Symbol step over und sehen Sie sich an, dass eine Ausnahme ausgelöst wurde.
10. Beachten Sie, dass eine sehr allgemeine RuntimeException was caught. einen 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 Ausnahmeblock sollte so umgestaltet werden, dass die Ausnahme EmptyResultDataAccessException abgefangen und der Statuscode „HTTP 404 nicht gefunden“ zurückgegeben wird.

Korrigieren Sie den Fehler.

1. Während die Fehlerbehebungssitzung noch läuft, schließen Sie die Anfrage ab, indem Sie auf „Weiter“ klicken im Steuerfeld zur Fehlerbehebung.
2. Fügen Sie dem Code als Nächstes den folgenden Block hinzu:

       } catch (EmptyResultDataAccessException e){
            return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
        }

Die Methode sollte so aussehen:

    public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) {
        try {
            quoteRepository.deleteById(id);
            return new ResponseEntity<>(HttpStatus.NO_CONTENT);
        } catch(EmptyResultDataAccessException e){
            return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }

3. Löschbefehl noch einmal ausführen

curl -v -X DELETE 127.0.0.1:8080/quotes/6

4. Gehen Sie den Debugger durch und beobachten Sie, wie das EmptyResultDataAccessException abgefangen und 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

5. Beenden Sie die Fehlerbehebungssitzung durch Klicken auf das rote Quadrat in der Debugging-Symbolleiste .

6. Bereinigen

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.

So bereinigen Sie nach Abschluss des Labs:

1. Die im Lab verwendeten Dateien löschen

cd ~ && rm -rf container-developer-workshop

2. Löschen Sie das Projekt, um alle zugehörigen Infrastrukturen und Ressourcen zu entfernen.