Kurz: Nasazení aplikace Spring Boot v clusteru AKS s flexibilním serverem Azure Database for MySQL ve virtuální síti

Článek
08/15/2024

PLATÍ PRO: Flexibilní server Azure Database for MySQL

V tomto kurzu se dozvíte, jak nasadit aplikaci Spring Boot do clusteru Azure Kubernetes Service (AKS) s flexibilním serverem Azure Database for MySQL v back-endu a bezpečně komunikovat mezi sebou ve virtuální síti Azure.

Poznámka:

V tomto kurzu se předpokládá základní znalost konceptů Kubernetes, Java Spring Boot a MySQL. Pro aplikace Spring Boot doporučujeme používat Azure Spring Apps. Azure Kubernetes Services ale můžete dál používat jako cíl. Rady najdete v pokynech k cíli úloh v Javě.

Požadavky

Předplatné Azure Pokud nemáte předplatné Azure, vytvořte si před zahájením bezplatný účet Azure. V současné době můžete s bezplatným účtem Azure vyzkoušet flexibilní server Azure Database for MySQL zdarma po dobu 12 měsíců. Další informace najdete v tématu Bezplatné vyzkoušení flexibilního serveru Azure Database for MySQL.
Rozhraní příkazového řádku Azure (CLI)
Podporovaná sada Java Development Kit verze 8 (součástí Azure Cloud Shellu).
Nástroj pro sestavení Apache Maven .
Klient Git
Klient Dockeru

Vytvoření flexibilního serveru Azure Database for MySQL

Vytvoření skupiny zdrojů

Skupina prostředků Azure je logická skupina, ve které se nasazují a spravují prostředky Azure. Pojďme vytvořit skupinu prostředků rg-mysqlaksdemo pomocí příkazu az group create v umístění eastus.

Otevřete příkazový řádek.
Přihlaste se ke svému účtu Azure.
```
az login
```

Zvolte svoje předplatné Azure.

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

Vytvořte skupinu prostředků.

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

Vytvoření instance flexibilního serveru Azure Database for MySQL

Teď vytvoříme instanci flexibilního serveru Azure Database for MySQL ve virtuální síti (metoda připojení privátního přístupu).

Vytvořte virtuální síť Azure vnet-mysqlaksdemo pro všechny prostředky v tomto kurzu a podsíť podsíť mysql pro instanci flexibilního serveru Azure Database for MySQL.

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

Pomocí příkazu az mysql flexible-server create vytvořte instanci flexibilního serveru Azure Database for MySQL mysql-mysqlaksdemo ve výše vytvořené podsíti. Nahraďte hodnoty uživatelského jména a hesla správce.
```
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
```
Teď jste vytvořili instanci flexibilního serveru Azure Database for MySQL v oblasti eastus s výpočetními prostředky B1MS s možností nárazového provozu, úložištěm 32 GB, 7denní dobou uchovávání záloh a v poskytnuté podsíti podsítě mysql. Tato podsíť by neměla mít nasazený žádný jiný prostředek a bude delegována na Microsoft.DBforMySQL/flexibleServers.
Nakonfigurujte novou flexibilní serverovou databázi demo Azure Database for MySQL, která se bude používat s aplikací Spring Boot.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Vytvoření registru kontejneru Azure

Vytvořte privátní registr kontejneru Azure v této skupině prostředků. Tento kurz odešle ukázkovou aplikaci jako image Dockeru do tohoto registru v dalších krocích. Nahraďte položku mysqlaksdemoregistry jedinečným názvem pro svůj registr.

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

Vytvoření kódu aplikace

V této části zakódujeme ukázkové aplikace. Pokud chcete pokračovat rychleji, můžete si stáhnout programovou aplikaci dostupnou na https://github.com/Azure-Samples/tutorial-springboot-mysql-aks webu a přeskočit na další část – Sestavte image a nasdílejte ji do ACR.

Vygenerujte aplikaci pomocí aplikace 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 -

Uvnitř složky se vygeneruje springboot-mysql-aks základní aplikace Spring Boot.

K následujícím krokům použijte oblíbený textový editor, jako je VSCode nebo jakékoli integrované vývojové prostředí (IDE).

Nakonfigurujte Spring Boot tak, aby používal flexibilní server Azure Database for MySQL.

Otevřete soubor src/main/resources/application.properties a přidejte následující fragment kódu. Tento kód čte z souboru manifestu Kubernetes hostitele databáze, název databáze, uživatelské jméno a heslo.
```
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
```
Upozorňující

Vlastnost spring.datasource.initialization-mode=always konfigurace znamená, že Spring Boot automaticky vygeneruje schéma databáze pomocí schema.sql souboru, který vytvoříme později při každém spuštění serveru. To je skvělé pro testování, ale nezapomeňte, že při každém restartování odstraníte vaše data, takže by se nemělo používat v produkčním prostředí.

Poznámka:

Tím, že ke konfigurační vlastnosti spring.datasource.url přidáme ?serverTimezone=UTC, ovladači JDBC sdělíme, aby při připojování k databázi používal datum ve formátu UTC (koordinovaný univerzální čas). V opačném případě by server Java nepoužíval stejný datumový formát jako databáze, což by způsobilo chybu.
Vytvořte schéma databáze.

Spring Boot se automaticky spustí src/main/resources/schema.sql a vytvoří schéma databáze. Vytvořte tento soubor s následujícím obsahem:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Naprogramujte aplikaci Java Spring Boot.

Přidejte kód Java, který bude používat JDBC k ukládání a načítání dat ze serveru MySQL. Vytvořte novou Todo třídu Java vedle DemoApplication třídy a přidejte následující kód:

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;
    }
}

Tato třída je doménový model mapovaný na tabulku todo, kterou jste vytvořili dřív.

Ke správě této třídy budete potřebovat úložiště. Ve stejném balíčku definujte nové rozhraní TodoRepository:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

Toto úložiště je úložiště, které spravuje Spring Data JDBC.

Dokončete aplikaci vytvořením kontroleru, který může ukládat a načítat data. Ve stejném balíčku implementujte třídu TodoController a přidejte následující kód:

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();
    }
}

V základním adresáři springboot-mysql-aks vytvořte nový soubor Dockerfile a zkopírujte tento fragment kódu.

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"]

Přejděte do souboru pom.xml a aktualizujte <properties> kolekci v souboru pom.xml názvem registru pro službu Azure Container Registry a nejnovější verzí jib-maven-plugin. Poznámka: Pokud název ACR obsahuje velká písmena, nezapomeňte je převést na malá písmena.
```
<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>
```
Aktualizujte kolekci <plugins> v souboru pom.xml tak, aby byl <plugin> prvek obsahující položku pro objekt jib-maven-plugin, jak je znázorněno níže. Všimněte si, že používáme základní image z Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, která obsahuje oficiálně podporovanou sadu JDK pro Azure. Další základní image MCR s oficiálně podporovanými sadami JDK najdete v centru Dockeru.
```
<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>
```

Sestavení image a nasdílení změn do ACR

Na příkazovém řádku přejděte do složky springboot-mysql-aks a spuštěním následujících příkazů nejprve nastavte výchozí název služby Azure Container Registry (jinak musíte zadat název az acr login), sestavte image a potom nasdílejte image do registru.

Ujistěte se, že je proces démon Dockeru spuštěný při provádění tohoto kroku.

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

Vytvoření clusteru Kubernetes v AKS

Teď vytvoříme cluster AKS ve virtuální síti vnet-mysqlaksdemo.

V tomto kurzu použijeme sítě Azure CNI v AKS. Pokud chcete místo toho nakonfigurovat sítě kubenet, přečtěte si téma Použití sítí kubenet v AKS.

Vytvořte podsíť aks podsítě pro cluster AKS, který se má použít.

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

Získejte ID prostředku podsítě.

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

Vytvořte ve virtuální síti cluster AKS s připojeným adresářem Azure Container Registry (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
```
Následující rozsahy IP adres jsou také definovány jako součást procesu vytváření clusteru:
- Cidr --service-cidr slouží k přiřazení interních služeb v clusteru AKS ip adresou. Můžete použít libovolný rozsah privátních adres, který splňuje následující požadavky:
  - Nesmí být v rozsahu IP adres virtuální sítě vašeho clusteru.
  - Nesmí se překrývat s jinými virtuálními sítěmi, se kterými partnerský vztah virtuálních sítí clusteru
  - Nesmí se překrývat s místními IP adresami.
  - Nesmí být v rozsahu 169,254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 nebo 192.0.2.0/24.
- IP adresa --dns-service-ip je IP adresa pro službu DNS clusteru. Tato adresa musí být v rozsahu adres služby Kubernetes. Nepoužívejte první IP adresu v rozsahu adres. První adresa v rozsahu podsítě se používá pro adresu kubernetes.default.svc.cluster.local .
- Adresa --docker-bridge-address je síťová adresa mostu Dockeru, která představuje výchozí síťovou adresu mostu Docker0 , která se nachází ve všech instalacích Dockeru. Musíte vybrat adresní prostor, který nekoliduje se zbytkem identifikátorůCIDR ve vašich sítích, včetně CIDR služby clusteru a CIDR podu.

Nasazení aplikace do clusteru AKS

Na webu Azure Portal přejděte k prostředku clusteru AKS.
V libovolném zobrazení prostředků (Namespace, úlohách, službách a příchozím přenosu dat, úložišti nebo konfiguraci) vyberte Přidat a přidat pomocí YAML .

Vložte následující YAML. Nahraďte hodnoty pro uživatelské jméno a heslo správce flexibilního serveru Azure Database for MySQL.

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

Aplikaci nasadíte výběrem možnosti Přidat v dolní části editoru YAML.
Po přidání souboru YAML se v prohlížeči prostředků zobrazí vaše aplikace Spring Boot. Poznamenejte si propojenou externí IP adresu, která je součástí externí služby.

Testování aplikace

K otestování aplikace můžete použít cURL.

Nejprve vytvořte novou položku "todo" v databázi pomocí následujícího příkazu.

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>

Potom načtěte data pomocí nového požadavku cURL nebo zadáním externí IP adresy clusteru v prohlížeči.

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

Tento příkaz vrátí seznam položek typu todo včetně položky, kterou jste vytvořili.

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

Tady je snímek obrazovky s těmito požadavky cURL: Snímek obrazovky znázorňující výstup příkazového řádku požadavků cURL

Podobný výstup si můžete prohlédnout v prohlížeči: Snímek obrazovky znázorňující výstup požadavku prohlížeče

Gratulujeme! Úspěšně jste nasadili aplikaci Spring Boot do clusteru Azure Kubernetes Service (AKS) s flexibilním serverem Azure Database for MySQL v back-endu.

Vyčištění prostředků

Abyste se vyhnuli poplatkům za Azure, měli byste vyčistit nepotřebné prostředky. Pokud už cluster nepotřebujete, použijte k odebrání skupiny prostředků, služby kontejneru a všech souvisejících prostředků příkaz az group delete.

az group delete --name rg-mysqlaksdemo

Poznámka:

Při odstranění clusteru se neodebere instanční objekt Microsoft Entra používaný clusterem AKS. Postup odebrání instančního objektu najdete v tématu věnovaném aspektům instančního objektu AKS a jeho odstranění. Pokud jste použili spravovanou identitu, identita se spravuje platformou a nevyžaduje odebrání.

Další kroky

Nasazení aplikace WordPress v AKS s flexibilním serverem Azure Database for MySQL

Vytvoření webové aplikace PHP (Laravel) s flexibilním serverem Azure Database for MySQL

Sdílet prostřednictvím