Tutorial: Bereitstellen einer Spring Boot-Anwendung in einem AKS-Cluster mit Azure Database for MySQL – Flexible Server in einem VNET

Artikel
02/06/2024

GILT FÜR: Azure Database for MySQL – Flexible Server

In diesem Tutorial erfahren Sie, wie Sie eine Spring Boot-Anwendung in einem Azure Kubernetes Service-Cluster (AKS) mit Azure Database for MySQL – Flexible Server im Back-End bereitstellen und dabei sicherstellen, dass alle Komponenten in einem virtuellen Azure-Netzwerk sicher miteinander kommunizieren.

Hinweis

In diesem Tutorial werden grundlegende Kenntnisse von Kubernetes-Konzepten, Java Spring Boot und MySQL vorausgesetzt. Für Spring Boot-Anwendungen empfehlen wir die Verwendung von Azure Spring Apps. Sie können Azure Kubernetes Service jedoch weiterhin als Ziel verwenden. Weitere Informationen finden Sie unter Java-Workload-Zielleitfaden.

Voraussetzungen

Ein Azure-Abonnement: Sollten Sie über kein Azure-Abonnement verfügen, können Sie ein kostenloses Azure-Konto erstellen, bevor Sie beginnen. Mit einem kostenlosen Azure-Konto können Sie Azure Database for MySQL – Flexible Server derzeit 12 Monate lang kostenlos testen. Weitere Informationen finden Sie unter Kostenlose Testversion von Azure Database for MySQL – Flexibler Server.
Die Azure-Befehlszeilenschnittstelle (CLI)
Ein unterstütztes Java Development Kit, Version 8 (in Azure Cloud Shell enthalten).
Das Apache Maven-Buildtool
Einen Git-Client
Einen Docker-Client

Erstellen einer Azure Database for MySQL Flexible Server-Instanz

Erstellen einer Ressourcengruppe

Eine Azure-Ressourcengruppe ist eine logische Gruppe, in der Azure-Ressourcen bereitgestellt und verwaltet werden. Erstellen Sie mithilfe des Befehls az group create eine Ressourcengruppe namens rg-mysqlaksdemo am Standort eastus.

Öffnen Sie die Eingabeaufforderung.
Melden Sie sich bei Ihrem Azure-Konto an.
```
az login
```

Wählen Sie Ihr Azure-Abonnement aus.

az account set -s <your-subscription-ID>

Erstellen Sie die Ressourcengruppe.

az group create --name rg-mysqlaksdemo --location eastus

Erstellen einer Azure Database for MySQL Flexible Server-Instanz

Sie erstellen nun eine Azure Database for MySQL – Flexible Server-Instanz in einem virtuellen Netzwerk (Methode für private Zugriffskonnektivität).

Erstellen Sie das virtuelle Azure-Netzwerk vnet-mysqlaksdemo für alle Ressourcen in diesem Tutorial sowie das Subnetz subnet-mysql für die Azure Database for MySQL – Flexible Server-Instanz.
```
az network vnet create \
--resource-group rg-mysqlaksdemo \
--name vnet-mysqlaksdemo \
--address-prefixes 155.55.0.0/16 \
--subnet-name subnet-mysql \
--subnet-prefix 155.55.1.0/24 
```
Erstellen Sie eine Azure Database for MySQL – Flexible Server-Instanz mit dem Namen mysql-mysqlaksdemo in dem oben erstellten Subnetz. Verwenden Sie dazu den Befehl az mysql flexible-server create. Ersetzen Sie Ihre Werte für Administratorbenutzername und -kennwort.
```
az mysql flexible-server create \
--name mysql-mysqlaksdemo \
--resource-group rg-mysqlaksdemo \
--location eastus \
--admin-user <your-admin-username> \
--admin-password <your-admin-password> \
--vnet vnet-mysqlaksdemo \
--subnet subnet-mysql
```
Sie haben nun in der Region „eastus“ im angegebenen Subnetz subnet-mysql eine Azure Database for MySQL – Flexible Server-Instanz mit einer burstfähigen B1MS-Computeressource, 32 GB Speicher und einer Aufbewahrungsdauer von sieben Tagen für Sicherungen erstellt. Dieses Subnetz sollte keine anderen Ressourcen enthalten, und es wird an „Microsoft.DBforMySQL/flexibleServers“ delegiert.
Konfigurieren Sie die neue Azure Database for MySQL – Flexible Server-Datenbank demo für die Verwendung mit der Spring Boot-Anwendung.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Erstellen einer Azure-Containerregistrierung

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 mysqlaksdemoregistry durch einen eindeutigen Namen für die Registrierung.

az acr create --resource-group rg-mysqlaksdemo \
--location eastus \
--name mysqlaksdemoregistry \
--sku Basic

Codieren der Anwendung

In diesem Abschnitt wird die Demoanwendung programmiert. Wenn Sie schneller vorgehen möchten, können Sie die programmierte Anwendung herunterladen, die unter https://github.com/Azure-Samples/tutorial-springboot-mysql-aks verfügbar ist, und gleich mit dem nächsten Abschnitt fortfahren: Erstellen des Images und Pushen an ACR.

Erstellen Sie die Anwendung mit Spring Initializr:

curl https://start.spring.io/starter.tgz \
-d dependencies=web,data-jdbc,mysql \
-d baseDir=springboot-mysql-aks \
-d bootVersion=2.5.6.RELEASE \
-d artifactId=springboot-mysql-aks \
-d description="Spring Boot on AKS connecting to Azure DB for MySQL" \
-d javaVersion=1.8 | tar -xzvf -

Eine Spring Boot-Basisanwendung wird im Ordner springboot-mysql-aks generiert.

Verwenden Sie für die folgenden Schritte Ihren bevorzugten Text-Editor (etwa VSCode) oder eine beliebige IDE.

Konfigurieren Sie Spring Boot für die Verwendung von Azure Database for MySQL – Flexible Server.

Öffnen Sie die Datei „src/main/resources/application.properties“, und fügen Sie den folgenden Codeausschnitt hinzu. Dieser Code liest den Datenbankhost, den Datenbanknamen, den Benutzernamen und das Kennwort aus der Kubernetes-Manifestdatei.
```
logging.level.org.springframework.jdbc.core=DEBUG
spring.datasource.url=jdbc:mysql://${DATABASE_HOST}:3306/${DATABASE_NAME}?serverTimezone=UTC
spring.datasource.username=${DATABASE_USERNAME}
spring.datasource.password=${DATABASE_PASSWORD}
spring.datasource.initialization-mode=always
```
Warnung

Die Konfigurationseigenschaft spring.datasource.initialization-mode=always bedeutet, dass Spring Boot mithilfe der Datei schema.sql, die Sie später erstellen, bei jedem Start des Servers automatisch ein Datenbankschema generiert. Dies eignet sich hervorragend für Tests. Denken Sie jedoch daran, dass Ihre Daten bei jedem Neustart gelöscht werden, daher sollte diese Eigenschaft nicht in der Produktion verwendet werden.

Hinweis

Sie fügen ?serverTimezone=UTC an die Konfigurationseigenschaft spring.datasource.url an, um den JDBC-Treiber anzuweisen, beim Herstellen einer Verbindung mit der Datenbank das Datumsformat UTC (Coordinated Universal Time, koordinierte Weltzeit) zu verwenden. Andernfalls verwendet Ihr Java-Server nicht das gleiche Datumsformat wie die Datenbank, was zu einem Fehler führen würde.
Erstellen Sie das Datenbankschema.

Spring Boot führt automatisch src/main/resources/schema.sql aus, um ein Datenbankschema zu erstellen. Erstellen Sie diese Datei mit folgendem Inhalt:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Programmieren Sie die Java Spring Boot-Anwendung.

Fügen Sie den Java-Code hinzu, der JDBC zum Speichern und Abrufen von Daten auf Ihrem MySQL-Server verwendet. Erstellen Sie neben der Klasse DemoApplication eine neue Todo-Java-Klasse, und fügen Sie den folgenden Code hinzu:

package com.example.springbootmysqlaks;

import org.springframework.data.annotation.Id;

public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    private Long id;

    private String description;

    private String details;

    private boolean done;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }
}

Bei dieser Klasse handelt es sich um ein Domänenmodell, das der zuvor erstellten todo-Tabelle zugeordnet ist.

Für die Verwaltung dieser Klasse ist ein Repository erforderlich. Definieren Sie eine neue TodoRepository-Schnittstelle im gleichen Paket:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

public interface TodoRepository extends CrudRepository<Todo, Long> {
}

Dieses Repository wird von Spring Data-JDBC verwaltet.

Stellen Sie die Anwendung fertig, indem Sie einen Controller erstellen, der Daten speichern und abrufen kann. Implementieren Sie eine TodoController-Klasse im gleichen Paket, und fügen Sie den folgenden Code hinzu:

package com.example.springbootmysqlaks;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Iterable<Todo> getTodos() {
        return todoRepository.findAll();
    }
}

Erstellen Sie eine neue Dockerfile-Datei im Basisverzeichnis springboot-mysql-aks, und kopieren Sie den folgenden Codeausschnitt:

FROM openjdk:8-jdk-alpine
RUN addgroup -S spring && adduser -S spring -G spring
USER spring:spring
ARG DEPENDENCY=target/dependency
COPY ${DEPENDENCY}/BOOT-INF/lib /app/lib
COPY ${DEPENDENCY}/META-INF /app/META-INF
COPY ${DEPENDENCY}/BOOT-INF/classes /app
ENTRYPOINT ["java","-cp","app:app/lib/*","com.example.springbootmysqlaks.DemoApplication"]

Navigieren Sie zur Datei pom.xml, und 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. Hinweis: Wenn Ihr ACR-Name Großbuchstaben enthält, ändern Sie diese unbedingt in Kleinbuchstaben.
```
<properties>
 	<docker.image.prefix>mysqlaksdemoregistry.azurecr.io</docker.image.prefix>
 	<jib-maven-plugin.version>3.1.4</jib-maven-plugin.version>
 	<java.version>1.8</java.version>
 </properties>
```
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/java/jdk:8-zulu-alpine“ verwendet wird, das eine offiziell unterstützte JDK-Version für Azure enthält. Weitere MCR-Basisimages mit offiziell unterstützten JDKs finden Sie im Docker-Hub.
```
<plugin>
    <artifactId>jib-maven-plugin</artifactId>
    <groupId>com.google.cloud.tools</groupId>
    <version>${jib-maven-plugin.version}</version>
    <configuration>
        <from>
            <image>mcr.microsoft.com/java/jdk:8-zulu-alpine</image>
        </from>
        <to>
            <image>${docker.image.prefix}/${project.artifactId}</image>
        </to>
    </configuration>
</plugin>
```

Erstellen des Images und Pushen an ACR

Navigieren Sie an der Eingabeaufforderung zum Ordner springboot-mysql-aks, und führen Sie die folgenden Befehle aus, um zuerst den Standardnamen für Azure Container Registry festzulegen, (andernfalls müssen Sie den Namen in az acr login angeben), erstellen Sie das Image, und pushen Sie das Image dann in die Registrierung.

Stellen Sie sicher, dass Ihr Docker-Daemon während dieses Schritts ausgeführt wird.

az config set defaults.acr=mysqlaksdemoregistry
az acr login && mvn compile jib:build

Erstellen eines Kubernetes-Clusters in AKS

Sie erstellen nun einen AKS-Cluster im virtuellen Netzwerk vnet-mysqlaksdemo.

In diesem Tutorial verwenden Sie das Azure CNI-Netzwerk in AKS. Wenn Sie stattdessen ein Kubenet-Netzwerk konfigurieren möchten, finden Sie weitere Informationen unter Verwenden von kubenet-Netzwerken mit Ihren eigenen IP-Adressbereichen in Azure Kubernetes Service (AKS).

Erstellen Sie das Subnetz subnet-aks, das vom AKS-Cluster verwendet werden soll.

az network vnet subnet create \
--resource-group rg-mysqlaksdemo \
--vnet-name vnet-mysqlaksdemo \
--name subnet-aks \
--address-prefixes 155.55.2.0/24

Rufen Sie die Subnetzressourcen-ID ab.

SUBNET_ID=$(az network vnet subnet show --resource-group rg-mysqlaksdemo --vnet-name vnet-mysqlaksdemo --name subnet-aks --query id -o tsv)

Erstellen Sie einen AKS-Cluster im virtuellen Netzwerk mit der angefügten Azure Container Registry-Instanz (ACR) mysqlaksdemoregistry.
```
    az aks create \
    --resource-group rg-mysqlaksdemo \
    --name aks-mysqlaksdemo \
    --network-plugin azure \
    --service-cidr 10.0.0.0/16 \
    --dns-service-ip 10.0.0.10 \
    --docker-bridge-address 172.17.0.1/16 \
    --vnet-subnet-id $SUBNET_ID \
    --attach-acr mysqlaksdemoregistry \
    --dns-name-prefix aks-mysqlaksdemo \
    --generate-ssh-keys
```
Die folgenden IP-Adressbereiche sind auch als Teil des Clustererstellungsprozesses definiert:
- Mit --service-cidr werden interne Dienste im AKS-Cluster einer IP-Adresse zugewiesen. Sie können jeden privaten Adressbereich verwenden, der die folgenden Anforderungen erfüllen:
  - Darf nicht innerhalb des IP-Adressbereichs des virtuellen Netzwerk Ihres Clusters liegen
  - Darf sich nicht mit anderen virtuellen Netzwerken überlappen, die Peers des virtuellen Netzwerks des Clusters sind
  - Er darf sich nicht mit lokalen IP-Adressen überlappen.
  - Er darf sich nicht in den Bereichen 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 oder 192.0.2.0/24 befinden.
- Die Adresse --dns-service-ip ist die IP-Adresse für den DNS-Dienst des Clusters. Diese Adresse muss innerhalb des Kubernetes-Dienstadressbereichs liegen. Verwenden Sie nicht die erste IP-Adresse Ihres Adressbereichs. Die erste Adresse Ihres Subnetzbereichs wird für die Adresse kubernetes.default.svc.cluster.local genutzt.
- --docker-bridge-address ist die Netzwerkadresse der Docker-Brücke, die die Standardnetzwerkadresse der Brücke docker0 darstellt, die in allen Docker-Installationen vorhanden ist. Wählen Sie einen Adressraum aus, der nicht mit den übrigen CIDRs in Ihrem Netzwerk in Konflikt steht (einschließlich Dienst-CIDR und Pod-CIDR des Clusters).

Bereitstellen der Anwendung einem AKS-Cluster

Navigieren Sie im Azure-Portal zu Ihrer AKS-Clusterressource.
Wählen Sie in einer der Ressourcenansichten („Namespace“, „Workloads“, „Dienste und Eingänge“, „Speicher“ oder „Konfiguration“) die Optionen Hinzuzufügen und Add with YAML (Mit YAML hinzufügen) aus.

Fügen Sie den folgenden YAML-Code ein. Fügen Sie Ihre Werte für den Administratorbenutzernamen und das Kennwort für Azure Database for MySQL – Flexible Server ein.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: springboot-mysql-aks
spec:
  replicas: 1
  selector:
    matchLabels:
      app: springboot-mysql-aks
  template:
    metadata:
      labels:
        app: springboot-mysql-aks
    spec:
      containers:
      - name: springboot-mysql-aks
        image: mysqlaksdemoregistry.azurecr.io/springboot-mysql-aks:latest
        env:
        - name: DATABASE_HOST
          value: "mysql-mysqlaksdemo.mysql.database.azure.com"
        - name: DATABASE_USERNAME
          value: "<your-admin-username>"
        - name: DATABASE_PASSWORD
          value: "<your-admin-password>"
        - name: DATABASE_NAME    
          value: "demo"     
---
apiVersion: v1
kind: Service
metadata:
  name: springboot-mysql-aks
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: springboot-mysql-aks

Wählen Sie unten im YAML-Editor Hinzufügen aus, um die Anwendung bereitzustellen.
Nachdem die YAML-Datei hinzugefügt wurde, wird Ihre Spring Boot-Anwendung in der Ressourcenansicht angezeigt. Notieren Sie sich die verknüpfte externe IP-Adresse, die im externen Dienst enthalten ist.

Testen der Anwendung

Zum Testen der Anwendung können Sie cURL verwenden.

Erstellen Sie zunächst mit dem folgenden Befehl ein neues todo-Element in der Datenbank:

curl --header "Content-Type: application/json" \
--request POST \
--data '{"description":"configuration","details":"congratulations, you have deployed your application correctly!","done": "true"}' \
http://<AKS-service-external-ip>

Rufen Sie als Nächstes die Daten mithilfe einer neuen cURL-Anforderung oder durch Eingabe der externen IP-Adresse des Clusters im Browser ab.

curl http://<AKS-service-external-ip>

Mit dem folgenden Befehl wird die Liste der todo-Elemente zurückgegeben, einschließlich des von Ihnen erstellten Elements:

[{"id":1,"description":"configuration","details":"congratulations, you have deployed your application correctly!","done":true}]

Hier sehen Sie einen Screenshot dieser cURL-Anforderungen: Screenshot der Befehlszeilenausgabe von cURL-Anforderungen

Im Browser sehen Sie eine ähnliche Ausgabe: Screenshot: Anforderungsausgabe im Browser

Herzlichen Glückwunsch! Sie haben erfolgreich eine Spring Boot-Anwendung im Azure Kubernetes Service-Cluster (AKS) mit Azure Database for MySQL – Flexible Server im Back-End bereitgestellt.

Bereinigen der Ressourcen

Zum Vermeiden von Azure-Gebühren sollten Sie nicht benötigte Ressourcen bereinigen. Wenn der Cluster nicht mehr benötigt wird, entfernen Sie mit dem Befehl az group delete die Ressourcengruppe, den Containerdienst und alle zugehörigen Ressourcen.

az group delete --name rg-mysqlaksdemo

Hinweis

Wenn Sie den Cluster löschen, wird der vom AKS-Cluster verwendete Microsoft Entra-Dienstprinzipal nicht entfernt. Schritte zum Entfernen des Dienstprinzipals finden Sie unter den Überlegungen zum AKS-Dienstprinzipal und dessen Löschung. Wenn Sie eine verwaltete Identität verwendet haben, wird die Identität von der Plattform verwaltet und muss nicht entfernt werden.

Nächste Schritte

Bereitstellen einer WordPress-App in AKS mit Azure Database for MySQL – Flexible Server

Erstellen einer PHP-Web-App (Laravel) mit Azure Database for MySQL-Server – Flexible Server

Tutorial: Bereitstellen einer Spring Boot-Anwendung in einem AKS-Cluster mit Azure Database for MySQL – Flexible Server in einem VNET

Voraussetzungen

Erstellen einer Azure Database for MySQL Flexible Server-Instanz

Erstellen einer Ressourcengruppe

Erstellen einer Azure Database for MySQL Flexible Server-Instanz

Erstellen einer Azure-Containerregistrierung

Codieren der Anwendung

Erstellen des Images und Pushen an ACR

Erstellen eines Kubernetes-Clusters in AKS

Bereitstellen der Anwendung einem AKS-Cluster

Testen der Anwendung

Bereinigen der Ressourcen

Nächste Schritte

Zusätzliche Ressourcen