Bereitstellen der Spring Boot Application in Azure Kubernetes Service

Hinweis

Für Spring Boot-Anwendungen empfehlen wir die Verwendung von Azure-Container-Apps. Sie können trotzdem Azure Kubernetes Service als Ziel verwenden. Weitere Informationen finden Sie unter Auswählen der richtigen Azure-Dienste für Ihre Java-Anwendungen.

In diesem Tutorial wird die Vorgehensweise zum Kombinieren von Kubernetes und Docker zum Entwickeln und Bereitstellen einer Spring Boot-Anwendung in Microsoft Azure erläutert. Genauer gesagt verwenden Sie Spring Boot für die Anwendungsentwicklung, Kubernetes für die Containerbereitstellung und Azure Kubernetes Service (AKS), um Ihre Anwendung zu hosten.

Kubernetes und Docker sind Open Source-Lösungen, mit denen Entwickelnde die Bereitstellung, Skalierung und Verwaltung ihrer in Containern ausgeführten Anwendungen automatisieren können.

Voraussetzungen

• Ein Azure-Abonnement – wenn Sie noch kein Azure-Abonnement besitzen, können Sie Ihre MSDN-Abonnentenvorteile anwenden oder sich für ein Kostenloses Azure-Konto registrieren
• Die Azure-Befehlszeilenschnittstelle (CLI)
• Ein unterstütztes Java Development Kit (JDK). Weitere Informationen zu den JDKs, die für die Entwicklung in Azure verfügbar sind, finden Sie im Artikel zur Java-Unterstützung in Azure und Azure Stack.
• Das Erstellungstool Apache Maven (Version 3)
• Einen Git-Client
• Einen Docker-Client
• Das Hilfsprogramm für ACR-Docker-Anmeldeinformationen

Hinweis

Aufgrund der Virtualisierungsanforderungen dieses Tutorials können Sie die Schritte in diesem Artikel nicht auf einem virtuellen Computer ausführen; Sie müssen einen physischen Computer mit aktivierten Virtualisierungsfunktionen verwenden.

Erstellen der Web-App für erste Schritte mit Spring Boot in Docker

Im Folgenden werden die Schritte zum Erstellen einer Spring Boot-Webanwendung und zum lokalen Testen dieser Anwendung beschrieben.

1. Öffnen Sie eine Eingabeaufforderung, erstellen Sie ein lokales Verzeichnis zum Speichern Ihrer Anwendung, und wechseln Sie in dieses Verzeichnis. Beispiel:

   mkdir C:\SpringBoot
   cd C:\SpringBoot
   

   – oder –

   mkdir /users/$USER/SpringBoot
   cd /users/$USER/SpringBoot
   

2. Klonen Sie das Beispielprojekt Spring Boot on Docker Getting Started in das Verzeichnis.

   git clone https://github.com/spring-guides/gs-spring-boot-docker.git
   

3. Wechseln Sie in das Verzeichnis mit dem abgeschlossenen Projekt.

   cd gs-spring-boot-docker
   cd complete
   

4. Verwenden Sie Maven zum Erstellen und Ausführen der Beispiel-App.

   mvn package spring-boot:run
   

5. Testen Sie die Web-App, indem Sie zu http://localhost:8080navigieren oder den folgenden Befehl curl verwenden:

   curl http://localhost:8080
   

6. Die folgende Meldung sollte angezeigt werden: Hello Docker World!

   

Erstellen einer Azure Container Registry-Instanz über die Azure-Befehlszeilenschnittstelle

1. Öffnen Sie eine Eingabeaufforderung.

2. Melden Sie sich bei Ihrem Azure-Konto an:

   az login
   

3. Wählen Sie Ihr Azure-Abonnement aus:

   az account set -s <YourSubscriptionID>
   

4. Erstellen Sie eine Ressourcengruppe für die Azure-Ressourcen, die in diesem Lernprogramm verwendet werden.

   az group create --name=wingtiptoys-kubernetes --location=eastus
   

5. Erstellen Sie eine private Azure Container Registry-Instanz in der Ressourcengruppe. Die Beispiel-App wird in diesem Tutorial in späteren Schritten als Docker-Image per Push in diese Registrierung übertragen. Ersetzen Sie wingtiptoysregistry durch einen eindeutigen Namen für die Registrierung.

   az acr create --resource-group wingtiptoys-kubernetes --location eastus \
    --name wingtiptoysregistry --sku Basic
   

Pushen der App in die Containerregistrierung über Jib

1. Melden Sie sich über die Azure-Befehlszeilenschnittstelle bei Ihrer Azure Container Registry-Instanz an.

   # set the default name for Azure Container Registry, otherwise you need to specify the name in "az acr login"
   az config set defaults.acr=wingtiptoysregistry
   az acr login
   

2. Öffnen Sie die Datei pom.xml mit einem Text-Editor, z. B. Visual Studio Code.

   code pom.xml
   

3. Aktualisieren Sie die Sammlung <properties> in der Datei pom.xml mit dem Registrierungsnamen für Ihre Azure Container Registry-Instanz und der aktuellen Version von jib-maven-plugin.

   <properties>
      <!-- Note: If your ACR name contains upper case characters, be sure to convert them to lower case characters. -->
      <docker.image.prefix>wingtiptoysregistry.azurecr.io</docker.image.prefix>
      <jib-maven-plugin.version>2.5.2</jib-maven-plugin.version>
      <java.version>1.8</java.version>
   </properties>
   

4. Aktualisieren Sie die <plugins>-Sammlung in der Datei pom.xml so, dass das <plugin>-Element einen Eintrag für die jib-maven-pluginenthält, wie im folgenden Beispiel gezeigt. Beachten Sie, dass ein Basisimage aus der Microsoft Container Registry (MCR) „mcr.microsoft.com/openjdk/jdk:11-ubuntu“ verwendet wird, das eine offiziell unterstützte JDK-Version für Azure enthält. Weitere MCR-Basisimages mit offiziell unterstützten JDKs finden Sie unter Installieren des Microsoft Build von OpenJDK..

   <plugin>
     <artifactId>jib-maven-plugin</artifactId>
     <groupId>com.google.cloud.tools</groupId>
     <version>${jib-maven-plugin.version}</version>
     <configuration>
        <from>
            <image>mcr.microsoft.com/openjdk/jdk:11-ubuntu</image>
        </from>
        <to>
            <image>${docker.image.prefix}/gs-spring-boot-docker</image>
        </to>
     </configuration>
   </plugin>
   

5. Navigieren Sie zum Verzeichnis des abgeschlossenen Projekts für Ihre Spring Boot-Anwendung, und führen Sie den folgenden Befehl aus, um das Image zu erstellen und per Push in die Registrierung zu übertragen:

   az acr login && mvn compile jib:build
   

Hinweis

Aufgrund von Sicherheitsbedenken bezüglich Azure Cli und Azure Container Registry sind die von az acr login erstellten Anmeldeinformationen für 1 Stunde gültig. Wenn ein 401 Unauthorized-Fehler angezeigt wird, können Sie den az acr login --name <your registry name>-Befehl erneut ausführen, um sich erneut zu authentifizieren. Wenn ein Read timed out-Fehler angezeigt wird, können Sie versuchen, Timeouts mit mvn -Djib.httpTimeout=7200000 jib:dockerBuild oder -Djib.httpTimeout=0 für ein unendliches Timeout zu erhöhen.

Erstellen eines Kubernetes-Clusters in AKS über die Azure-Befehlszeilenschnittstelle

1. Erstellen Sie einen Kubernetes-Cluster in Azure Kubernetes Service. Mit dem folgenden Befehl wird ein Kubernetes-Cluster in der Ressourcengruppe wingtiptoys-kubernetes erstellt, mit wingtiptoys-akscluster als Clustername, dem angehängten Azure Container Registry (ACR) wingtiptoysregistry und wingtiptoys-kubernetes als DNS-Präfix.

   az aks create --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster \
    --attach-acr wingtiptoysregistry \
    --dns-name-prefix=wingtiptoys-kubernetes --generate-ssh-keys
   

   Dieser Befehl kann eine Weile dauern, bis er erfolgreich abgeschlossen ist.

2. Installieren Sie kubectl über die Azure-Befehlszeilenschnittstelle. Linux-Benutzer müssen diesem Befehl möglicherweise das Präfix sudo voranstellen, da er die Kubernetes-Befehlszeilenschnittstelle in /usr/local/bin bereitstellt.

   az aks install-cli
   

3. Laden Sie die Konfigurationsinformationen des Clusters herunter, damit Sie den Cluster über die Kubernetes-Weboberfläche und kubectl verwalten können.

   az aks get-credentials --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster
   

Stellen Sie das Image in Ihrem Kubernetes-Cluster bereit

In diesem Tutorial wird die App mit kubectl bereitgestellt. Anschließend können Sie die Bereitstellung über die Kubernetes-Weboberfläche erkunden.

Bereitstellen mit kubectl

1. Öffnen Sie eine Eingabeaufforderung.

2. Führen Sie den Container im Kubernetes-Cluster mit dem Befehl kubectl run aus. Geben Sie einen Dienstnamen für die App in Kubernetes und den vollständigen Imagenamen an. Zum Beispiel:

   kubectl run gs-spring-boot-docker --image=wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

   In diesem Befehl:

   • Der Containername gs-spring-boot-docker wird direkt nach dem Befehl run angegeben.

   • Der Parameter --image gibt die Kombination aus Anmeldeserver und Imagename als wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest an.

3. Machen Sie den Kubernetes-Cluster mit dem Befehl kubectl expose extern verfügbar. Geben Sie den Dienstnamen, den öffentlichen TCP-Port für den Zugriff auf die App und den internen Zielport, auf dem die App lauscht, an. Zum Beispiel:

   kubectl expose pod gs-spring-boot-docker --type=LoadBalancer --port=80 --target-port=8080
   

   In diesem Befehl:

   • Der Containername gs-spring-boot-docker wird direkt nach dem Befehl expose pod angegeben.

   • Der Parameter --type gibt an, dass der Cluster einen Lastenausgleicher verwendet.

   • Der Parameter --port gibt den öffentlichen TCP-Port 80 an. Sie greifen über diesen Port auf die App zu.

   • Der Parameter --target-port gibt den internen TCP-Port 8080 an. Der Load Balancer leitet über diesen Port Anforderungen an die App weiter.

4. Nachdem die App im Cluster bereitgestellt wurde, fragen Sie die externe IP-Adresse ab, und öffnen Sie sie im Webbrowser:

   kubectl get services -o=jsonpath='{.items[*].status.loadBalancer.ingress[0].ip}'
   

   

Bereitstellen über die Kubernetes-Ressourcenansicht

1. Wählen Sie in einer der Ressourcenansichten („Namespace“, „Workloads“ oder „Dienste und Eingänge“, „Speicher“ und „Konfiguration“) Hinzuzufügen aus.

   

2. Fügen Sie den folgenden YAML-Code ein:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gs-spring-boot-docker
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gs-spring-boot-docker
     template:
       metadata:
         labels:
           app: gs-spring-boot-docker
       spec:
         containers:
         - name: gs-spring-boot-docker
           image: wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

3. Wählen Sie unten im YAML-Editor Hinzufügen aus, um die Anwendung bereitzustellen.

   

   Wählen Sie nach der Bereitstellung von Deployment genau wie oben die Option Hinzufügen unten im YAML-Editor aus, um Service mithilfe des folgenden YAML bereitzustellen:

   apiVersion: v1
   kind: Service
   metadata:
     name: gs-spring-boot-docker
   spec:
     type: LoadBalancer
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: gs-spring-boot-docker
   

4. Nachdem die YAML-Datei hinzugefügt wurde, zeigt der Ressourcenanzeiger Ihre Spring Boot-Anwendung an. Der externe Dienst umfasst eine verknüpfte externe IP-Adresse, sodass Sie die Anwendung bequem in Ihrem Browser anzeigen können.

   

   

5. Wählen Sie Externe IP aus. Sie sehen dann, dass Ihre Spring Boot-Anwendung in Azure ausgeführt wird.

   

Nächste Schritte

Weitere Informationen zu Spring und Azure finden Sie im Dokumentationscenter zu Spring in Azure.

Spring in Azure

Weitere Informationen

Weitere Informationen zur Verwendung von Spring Boot in Azure finden Sie im folgenden Artikel:

• Bereitstellen einer Spring Boot-Anwendung für Linux in Azure App Service

Weitere Informationen zur Verwendung von Azure mit Java finden Sie in den Anleitungen "Azure für Java-Entwickler" und "Arbeiten mit Azure DevOps und Java".

Weitere Informationen zum Bereitstellen einer Java-Anwendung in Kubernetes mit Visual Studio Code finden Sie in den Visual Studio Code-Tutorials für Java.

Weitere Informationen zum Spring Boot-Beispielprojekt in Docker finden Sie unter Spring Boot on Docker Getting Started (Erste Schritte mit Spring Boot in Docker).

Über die folgenden Links erhalten Sie weitere Informationen zur Erstellung von Spring Boot-Anwendungen:

• Weitere Informationen zum Erstellen einer einfachen Spring Boot-Anwendung finden Sie im Spring Initializr unter https://start.spring.io/.

Über die folgenden Links erhalten Sie weitere Informationen zur Verwendung von Kubernetes mit Azure:

• Erste Schritte mit einem Kubernetes-Cluster in Azure Kubernetes Service

Weitere Informationen zur Verwendung der Kubernetes-Befehlszeilenschnittstelle stehen im Benutzerhandbuch für kubectl unter https://kubernetes.io/docs/reference/kubectl/ zur Verfügung.

Die Kubernetes-Website umfasst mehrere Artikel zur Verwendung von Images in privaten Registrierungen:

• Konfigurieren von Dienstkonten für Pods
• Namespaces
• Pullen eines Images aus einer privaten Registrierung

Weitere Beispiele zur Vorgehensweise bei der Verwendung benutzerdefinierter Docker-Images mit Azure finden Sie unter Verwenden eines benutzerdefinierten Docker-Images für Azure-Web-Apps unter Linux.

Weitere Informationen zum iterativen Ausführen und Debuggen von Containern mit Azure Dev Spaces direkt in Azure Kubernetes Service (AKS) finden Sie unter Erste Schritte in Azure Dev Spaces mit Java.