Oktatóanyag: Spring Boot-alkalmazás üzembe helyezése AKS-fürtön az Azure Database for MySQL-ben – Rugalmas kiszolgáló virtuális hálózaton

Cikk
06/18/2024

A következőkre vonatkozik: Azure Database for MySQL – rugalmas kiszolgáló

Ebben az oktatóanyagban megtudhatja, hogyan helyezhet üzembe Spring Boot-alkalmazást az Azure Kubernetes Service (AKS) fürtön rugalmas Azure Database for MySQL-kiszolgálóval a háttérrendszerben, és hogyan kommunikálhat biztonságosan egymással egy Azure-beli virtuális hálózaton belül.

Feljegyzés

Ez az oktatóanyag alapszintű ismereteket feltételez a Kubernetes fogalmairól, a Java Spring Bootról és a MySQL-ről. Spring Boot-alkalmazások esetén az Azure Spring Apps használatát javasoljuk. Az Azure Kubernetes Servicest azonban továbbra is használhatja célként. Tanácsért tekintse meg a Java számítási feladatok célhelyének útmutatását .

Előfeltételek

Azure-előfizetés Ha nem rendelkezik Azure-előfizetéssel, a kezdés előtt hozzon létre egy ingyenes Azure-fiókot . Jelenleg ingyenes Azure-fiókkal 12 hónapig ingyenesen kipróbálhatja a Rugalmas Azure Database for MySQL-kiszolgálót. További információ: Azure Database for MySQL – Rugalmas kiszolgáló ingyenes kipróbálás.
Az Azure parancssori felület (CLI).
Támogatott Java Development Kit, 8-es verzió (az Azure Cloud Shell része).
Az Apache Maven buildelési eszköze.
Egy Git-ügyfél.
Egy Docker-ügyfél.

Rugalmas Azure Database for MySQL-kiszolgáló létrehozása

Erőforráscsoport létrehozása

Az Azure-erőforráscsoport olyan logikai csoport, amelyben az Azure-erőforrások üzembe helyezése és kezelése zajlik. Hozzunk létre egy rg-mysqlaksdemo erőforráscsoportot az eastus helyen található az group create paranccsal.

Nyissa meg a parancssort.
Jelentkezzen be Azure-fiókjába.
```
az login
```

Válassza ki az Azure-előfizetését.

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

Hozza létre az erőforráscsoportot.

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

Rugalmas Azure Database for MySQL-kiszolgálópéldány létrehozása

Most létrehozunk egy rugalmas Azure Database for MySQL-kiszolgálópéldányt egy virtuális hálózaton (privát hozzáférési kapcsolati módszer).

Hozzon létre egy Azure-beli virtuális hálózat vnet-mysqlaksdemo-t az oktatóanyag összes erőforrásához, valamint egy alhálózati alhálózat-mysql-t a rugalmas Azure Database for MySQL-kiszolgálópéldányhoz.
```
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 
```
Hozzon létre egy rugalmas Azure Database for MySQL-kiszolgálópéldányt a fenti létrehozott alhálózatban a mysql-mysqlaksdemo kiszolgálón az az mysql flexible-server create paranccsal. Cserélje le az értékeket a rendszergazdai felhasználónévre és jelszóra.
```
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
```
Most létrehozott egy rugalmas Azure Database for MySQL-kiszolgálópéldányt az Eastus régióban a Burstable B1MS számítással, a 32 GB-os tárterülettel, a 7 napos biztonsági mentési megőrzési idővel és a megadott alhálózati alhálózati mysql-ben. Ebben az alhálózatban nem lehet más erőforrás üzembe helyezve, és delegálva lesz a Microsoft.DBforMySQL/flexibleServers szolgáltatásba.
Konfiguráljon egy új rugalmas Azure Database for MySQL-kiszolgálóadatbázist demo a Spring Boot-alkalmazással való használatra.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Azure tárolóregisztrációs adatbázis létrehozása

Hozzon létre egy privát Azure Container Registryt az erőforráscsoportban. Ez az oktatóanyag a mintaalkalmazást Docker-rendszerképként küldi el a beállításjegyzékbe a későbbi lépésekben. Cserélje le az mysqlaksdemoregistry elemet az adatbázis egyedi nevére.

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

Az alkalmazás kódolása

Ebben a szakaszban a demóalkalmazást kódjuk. Ha gyorsabban szeretne haladni, letöltheti a következő szakaszban elérhető https://github.com/Azure-Samples/tutorial-springboot-mysql-aks kódolt alkalmazást, és ugorjon a következő szakaszra – A rendszerkép létrehozása és leküldés az ACR-be.

Hozza létre az alkalmazást a Spring Initializr használatával.

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 -

A rendszer létrehoz egy alap Spring Boot-alkalmazást a springboot-mysql-aks mappában.

A következő lépésekhez használja a kedvenc szövegszerkesztőt, például a VSCode-ot vagy bármely IDE-t.

Konfigurálja a Spring Boott a rugalmas Azure Database for MySQL-kiszolgáló használatára.

Nyissa meg az src/main/resources/application.properties fájlt, és adja hozzá az alábbi kódrészletet. Ez a kód beolvassa az adatbázis-gazdagépet, az adatbázis nevét, a felhasználónevet és a jelszót a Kubernetes jegyzékfájljából.
```
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
```
Figyelmeztetés

A konfigurációs tulajdonság spring.datasource.initialization-mode=always azt jelenti, hogy a Spring Boot automatikusan létrehoz egy adatbázissémát a schema.sql később létrehozott fájl használatával, a kiszolgáló minden indításakor. Ez kiválóan alkalmas tesztelésre, de ne feledje, hogy ez minden újraindításkor törli az adatokat, ezért ezt nem szabad éles környezetben használni!

Feljegyzés

A spring.datasource.url konfigurációs tulajdonsághoz fűzött ?serverTimezone=UTC érték a JDBC-illesztőprogramnak adja meg, hogy az UTC (egyezményes világidő) dátumformátumot használja az adatbázishoz való csatlakozáskor. Ellenkező esetben a Java-kiszolgáló az adatbázisétól eltérő dátumformátumot használna, ez pedig hibát eredményezne.
Hozza létre az adatbázissémát.

A Spring Boot automatikusan végrehajtja src/main/resources/schema.sql az adatbázisséma létrehozását. Hozza létre a fájlt a következő tartalommal:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Kódoljuk a Java Spring Boot-alkalmazást.

Adja hozzá azt a Java-kódot, amely A JDBC használatával tárolja és kéri le az adatokat a MySQL-kiszolgálóról. Hozzon létre egy új Todo Java-osztályt az DemoApplication osztály mellett, és adja hozzá a következő kódot:

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

Ez az osztály egy tartománymodell, amely az előzőleg létrehozott todo táblára van leképezve.

Ennek az osztálynak a kezeléséhez egy adattár szükséges. Definiáljon egy új TodoRepository interfészt ugyanebben a csomagban:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

Ez az adattár egy olyan adattár, amelyet a Spring Data JDBC kezel.

Fejezze be az alkalmazást egy olyan vezérlő létrehozásával, amely képes tárolni és lekérni az adatokat. Implementáljon ugyanebben a csomagban egy TodoController osztályt, és szúrja be az alábbi kódot:

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

Hozzon létre egy új Dockerfile-t a springboot-mysql-aks alapkönyvtárban, és másolja ezt a kódrészletet.

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

Lépjen a pom.xml fájlra, és frissítse a gyűjteményt a <properties> pom.xml fájlban az Azure Container Registry beállításjegyzék-nevével és a legújabb verziójával jib-maven-plugin. Megjegyzés: Ha az ACR-név nagybetűket tartalmaz, ügyeljen arra, hogy kisbetűkké alakítsa őket.
```
<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>
```
Frissítse a gyűjteményt <plugins> a pom.xml fájlban úgy, hogy az <plugin> elem tartalmazzon egy bejegyzést az jib-maven-pluginalábbi módon. Vegye figyelembe, hogy a Microsoft Container Registry (MCR) egy alaprendszerképét használjuk: mcr.microsoft.com/java/jdk:8-zulu-alpine. Ez tartalmaz egy hivatalosan támogatott JDK-t az Azure-hoz. A hivatalosan támogatott JDK-kkal rendelkező egyéb MCR-alapképekért lásd a Docker Hubot.
```
<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>
```

A rendszerkép létrehozása és leküldés az ACR-be

A parancssorban keresse meg a springboot-mysql-aks mappát, és futtassa a következő parancsokat az Azure Container Registry alapértelmezett nevének beállításához (ellenkező esetben meg kell adnia a nevet az acr login), hozza létre a lemezképet, majd küldje el a lemezképet a beállításjegyzékbe.

Győződjön meg arról, hogy a docker-démon fut a lépés végrehajtása során.

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

Kubernetes-fürt létrehozása az AKS-en

Most létrehozunk egy AKS-fürtöt a virtuális hálózat vnet-mysqlaksdemo hálózatában.

Ebben az oktatóanyagban az Azure CNI hálózatkezelését fogjuk használni az AKS-ben. Ha inkább a kubenet-hálózatkezelést szeretné konfigurálni, olvassa el a Kubenet-hálózatkezelés használata az AKS-ben című témakört.

Hozzon létre egy alhálózati alhálózat-akokat az AKS-fürt számára.

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

Kérje le az alhálózat erőforrás-azonosítóját.

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

Hozzon létre egy AKS-fürtöt a virtuális hálózaton az Azure Container Registry (ACR) mysqlaksdemoregistry csatolásával.
```
    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
```
A fürt létrehozási folyamatának részeként a következő IP-címtartományok is definiálva vannak:
- A --service-cidr az AKS-fürt belső szolgáltatásainak IP-cím hozzárendelésére szolgál. Bármilyen olyan magáncímtartományt használhat, amely megfelel az alábbi követelményeknek:
  - Nem lehet a fürt virtuális hálózati IP-címtartományában
  - Nem lehet átfedésben más olyan virtuális hálózatokkal, amelyekkel a fürt virtuális hálózati társhálózatai
  - Nem lehetnek átfedésben a helyszíni IP-címekkel
  - Nem lehet a 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 vagy 192.0.2.0/24 tartományban
- A --dns-service-IP-cím a fürt DNS-szolgáltatásának IP-címe. A címnek a Kubernetes szolgáltatási címtartományába kell tartoznia. Ne használja az első IP-címet a címtartományban. Az alhálózattartomány első címe a kubernetes.default.svc.cluster.local címhez használatos.
- A --docker-bridge-cím a Docker-híd hálózati címe, amely az összes Docker-telepítésben található alapértelmezett Docker0-híd hálózati címet jelöli. Olyan címteret kell választania, amely nem ütközik a hálózat többi CIDR-jével, beleértve a fürt CIDR szolgáltatását és a pod CIDR-jét.

Az alkalmazás üzembe helyezése az AKS-fürtben

Nyissa meg az AKS-fürterőforrást az Azure Portalon.
Válassza az Add and Add with YAML (Hozzáadás YAML-sel) lehetőséget bármelyik erőforrásnézetből (névtér, számítási feladatok, szolgáltatások és bejövő forgalom, Tárolás vagy konfiguráció).

Illessze be a következő YAML-be. Cserélje le a rugalmas Azure Database for MySQL-kiszolgáló rendszergazdai felhasználónevét és jelszavát.

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

Válassza a YAML-szerkesztő alján található Hozzáadás lehetőséget az alkalmazás üzembe helyezéséhez.
A YAML-fájl hozzáadása után az erőforrás-megjelenítő megjeleníti a Spring Boot-alkalmazást. Jegyezze fel a külső szolgáltatásban található csatolt külső IP-címet.

Az alkalmazás tesztelése

Az alkalmazást tesztelheti a cURL használatával.

Először hozzon létre egy új "teendő" elemet az adatbázisban az alábbi paranccsal.

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>

Ezután kérje le az adatokat egy új cURL-kérés használatával, vagy a fürt külső IP-címének beírásával a böngészőben.

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

Ez a parancs a "teendő" elemek listáját adja vissza, beleértve a létrehozott elemet is.

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

Az alábbi cURL-kérelmek képernyőképe: Képernyőkép a cURL-kérelmek parancssori kimenetéről.

Hasonló kimenetet láthat a böngészőben: Képernyőkép a böngészőkérelmek kimenetről.

Gratulálunk! Sikeresen üzembe helyezett egy Spring Boot-alkalmazást az Azure Kubernetes Service (AKS) fürtön rugalmas Azure Database for MySQL-kiszolgálóval a háttérrendszerben!

Az erőforrások eltávolítása

Az Azure-díjak elkerülése érdekében távolítsa el a szükségtelen erőforrásokat. Ha a fürtre már nincs szükség, az az group delete paranccsal törölheti az erőforráscsoportot, a tárolószolgáltatást és az összes kapcsolódó erőforrást.

az group delete --name rg-mysqlaksdemo

Feljegyzés

A fürt törlésekor az AKS-fürt által használt Microsoft Entra szolgáltatásnév nem lesz eltávolítva. A szolgáltatásnév eltávolításának lépéseiért lásd az AKS-szolgáltatásnevekre vonatkozó szempontokat és a szolgáltatásnevek törlését ismertető cikket. Ha felügyelt identitást használt, az identitást a platform kezeli, és nem igényel eltávolítást.

Következő lépések

WordPress-alkalmazás üzembe helyezése az AKS-ben rugalmas Azure Database for MySQL-kiszolgálóval

PHP-webalkalmazás (Laravel) létrehozása rugalmas Azure Database for MySQL-kiszolgálóval

Megosztás a következőn keresztül: