Bereitstellen von Spring Boot-Anwendungen in Azure Kubernetes Service

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) zum Hosten der Anwendung.

Kubernetes und Docker sind Open Source-Lösungen, mit denen Entwickler 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

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 durch Navigieren zu http://localhost:8080 oder mit dem folgenden curl-Befehl:

   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 in diesem Tutorial verwendeten Azure-Ressourcen.

   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 pom.xml-Datei 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 Sammlung <plugins> in der Datei pom.xml, sodass das <plugin>-Element einen Eintrag für jib-maven-plugin enthält, wie im Beispiel unten 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 of 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
   

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 mit wingtiptoys-akscluster als Clustername, wingtiptoysregistry als angefügter Azure Container Registry-Instanz (ACR) und wingtiptoys-kubernetes als DNS-Präfix erstellt:

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

   Die Ausführung des Befehls kann eine Weile dauern.

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
   

Bereitstellen des Images in Ihrem Kubernetes-Cluster

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 Lastenausgleich 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 DeploymentBereitstellung wie oben die Option "Hinzufügen" am unteren Rand des YAML-Editors aus, um sie mithilfe des folgenden YAML bereitzustellen Service :

   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, wird Ihre Spring Boot-Anwendung in der Ressourcenansicht angezeigt. 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. Dann wird Ihre Spring Boot-Anwendung auf Azure ausgeführt.

   

Nächste Schritte

Weitere Informationen zu Spring und Azure finden Sie im Dokumentationscenter zu 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 unter Azure für Java-Entwickler und Working with Azure DevOps and Java (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:

• Configuring Service Accounts for Pods (Konfigurieren von Dienstkonten für Pods)
• Namespaces
• Pulling an Image from a Private Registry (Übertragen eines Images aus einer privaten Registrierung per Pull)

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.