Självstudie: Distribuera ett Spring Boot-program i AKS-kluster med Azure Database for MySQL – flexibel server i ett virtuellt nätverk

Artikel
08/15/2024

GÄLLER FÖR: Azure Database for MySQL – flexibel server

I den här självstudien får du lära dig hur du distribuerar ett Spring Boot-program i Azure Kubernetes Service-kluster (AKS) med Azure Database for MySQL– flexibel server i serverdelen och kommunicerar säkert med varandra i ett virtuellt Azure-nätverk.

Kommentar

Den här självstudien förutsätter en grundläggande förståelse av Kubernetes-begrepp, Java Spring Boot och MySQL. För Spring Boot-program rekommenderar vi att du använder Azure Spring Apps. Du kan dock fortfarande använda Azure Kubernetes Services som mål. Mer information finns i Vägledning för Java-arbetsbelastningsmål.

Förutsättningar

En Azure-prenumeration Om du inte har en Azure-prenumeration skapar du ett kostnadsfritt Azure-konto innan du börjar. Med ett kostnadsfritt Azure-konto kan du prova Azure Database for MySQL – flexibel server kostnadsfritt i 12 månader. Mer information finns i Prova Azure Database for MySQL – flexibel server kostnadsfritt.
Azures kommandoradsgränssnitt (CLI).
Ett Java Development Kit som stöds, version 8 (ingår i Azure Cloud Shell).
Apache Maven-byggverktyget.
En Git-klient.
En Docker-klient.

Skapa en flexibel Azure Database for MySQL-server

Skapa en resursgrupp

En Azure-resursgrupp är en logisk grupp där Azure-resurser distribueras och hanteras. Nu ska vi skapa en resursgrupp rg-mysqlaksdemo med kommandot az group create på platsen eastus .

Öppna kommandotolken.
Logga in på ditt Azure-konto.
```
az login
```

Välj din Azure-prenumeration.

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

Skapa resursgruppen.

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

Skapa en flexibel Azure Database for MySQL-serverinstans

Nu ska vi skapa en flexibel Azure Database for MySQL-serverinstans i ett virtuellt nätverk (privat åtkomstanslutningsmetod).

Skapa ett virtuellt Azure-nätverk vnet-mysqlaksdemo för alla resurser i den här självstudien och ett undernätsundernät-mysql för azure database for MySQL– flexibel serverinstans.

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

Skapa en flexibel Azure Database for MySQL-serverinstans mysql-mysqlaksdemo i det ovan skapade undernätet med kommandot az mysql flexible-server create . Ersätt dina värden för administratörens användarnamn och lösenord.
```
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
```
Nu har du skapat en flexibel Azure Database for MySQL-serverinstans i regionen eastus med Burstable B1MS-beräkning, 32 GB lagring, 7 dagars kvarhållningsperiod för säkerhetskopiering och i det angivna undernätet mysql. Det här undernätet bör inte ha någon annan resurs distribuerad i det och delegeras till Microsoft.DBforMySQL/flexibleServers.

Konfigurera en ny flexibel Azure Database for MySQL-serverdatabas demo som ska användas med Spring Boot-programmet.

az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo

Skapa ett Azure-containerregister

Skapa ett privat Azure-containerregister i resursgruppen. I den här självstudien skickas exempelappen som en Docker-avbildning till det här registret i senare steg. Ersätt mysqlaksdemoregistry med ett unikt namn för ditt register.

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

Koda appen

I det här avsnittet kodar vi demoprogrammet. Om du vill gå snabbare kan du ladda ned det kodade programmet som är tillgängligt på https://github.com/Azure-Samples/tutorial-springboot-mysql-aks och gå vidare till nästa avsnitt – Skapa avbildningen och skicka till ACR.

Generera programmet med 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 -

Ett grundläggande Spring Boot-program genereras i springboot-mysql-aks mappen.

Använd din favorittextredigerare som VSCode eller valfri IDE för följande steg.

Konfigurera Spring Boot för att använda azure database for MySQL – flexibel server.

Öppna filen src/main/resources/application.properties och lägg till kodfragmentet nedan. Den här koden läser databasvärden, databasnamnet, användarnamnet och lösenordet från Kubernetes-manifestfilen.
```
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
```
Varning

Konfigurationsegenskapen spring.datasource.initialization-mode=always innebär att Spring Boot automatiskt genererar ett databasschema med hjälp av filen schema.sql som vi skapar senare, varje gång servern startas. Detta är bra för testning, men kom ihåg att detta tar bort dina data vid varje omstart, så detta bör inte användas i produktion!

Kommentar

Lägg till ?serverTimezone=UTC i konfigurationsegenskapen spring.datasource.url så att JDBC-drivrutinen använder datumformatet UTC (koordinerad universell tid) vid anslutning till databasen. Annars skulle inte Java-servern använda samma datumformat som databasen, vilket ger ett fel.
Skapa databasschemat.

Spring Boot körs src/main/resources/schema.sql automatiskt för att skapa ett databasschema. Skapa filen med följande innehåll:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Koda Java Spring Boot-programmet.

Lägg till Java-koden som använder JDBC för att lagra och hämta data från MySQL-servern. Skapa en ny Todo Java-klass bredvid DemoApplication klassen och lägg till följande kod:

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

Den här klassen är en domänmodell som är mappad på den todo-tabell som du skapade tidigare.

Om du vill hantera den här klassen behöver du en lagringsplats. Definiera ett nytt TodoRepository-gränssnitt i samma paket:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

Den här lagringsplatsen är en lagringsplats som Spring Data JDBC hanterar.

Slutför programmet genom att skapa en kontrollant som kan lagra och hämta data. Implementera en TodoController-klass i samma paket och lägg till följande kod:

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

Skapa en ny Dockerfile i baskatalogen springboot-mysql-aks och kopiera det här kodfragmentet.

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

Gå till pom.xml-filen och uppdatera <properties> samlingen i den pom.xml filen med registernamnet för Azure Container Registry och den senaste versionen av jib-maven-plugin. Obs! Om ditt ACR-namn innehåller versaler måste du konvertera dem till gemener.
```
<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>
```

<plugins> Uppdatera samlingen i filen pom.xml så att det finns ett <plugin> element som innehåller en post för jib-maven-plugin, enligt nedan. Observera att vi använder en basavbildning från Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, som innehåller en JDK som stöds officiellt för Azure. Andra MCR-basavbildningar med officiellt stödda JDK:er finns i docker-hubben.

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

Skapa avbildningen och push-överför till ACR

I kommandotolken går du till mappen springboot-mysql-aks och kör följande kommandon för att först ange standardnamnet för Azure Container Registry (annars måste du ange namnet i az acr login), skapa avbildningen och sedan skicka avbildningen till registret.

Kontrollera att docker-daemonen körs när du kör det här steget.

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

Skapa ett Kubernetes-kluster på AKS

Nu ska vi skapa ett AKS-kluster i det virtuella nätverket vnet-mysqlaksdemo.

I den här självstudien använder vi Azure CNI-nätverk i AKS. Om du vill konfigurera kubenet-nätverk i stället kan du läsa Använda kubenet-nätverk i AKS.

Skapa ett undernätsundernät-aks som AKS-klustret ska använda.

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

Hämta resurs-ID:t för undernätet.

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

Skapa ett AKS-kluster i det virtuella nätverket med Azure Container Registry (ACR) mysqlaksdemoregistry kopplat.
```
    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
```
Följande IP-adressintervall definieras också som en del av klusterskapandeprocessen:
- - -service-cidr används för att tilldela interna tjänster i AKS-klustret en IP-adress. Du kan använda alla privata adressintervall som uppfyller följande krav:
  - Får inte ligga inom ip-adressintervallet för det virtuella nätverket i klustret
  - Får inte överlappa med andra virtuella nätverk som klustrets virtuella nätverkskolleger har
  - Får inte överlappa med några lokala IP-adresser
  - Får inte ligga inom intervallen 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 eller 192.0.2.0/24
- Ip-adressen --dns-service-ip är IP-adressen för klustrets DNS-tjänst. Den här adressen måste ligga inom Kubernetes Service-adressintervallet. Använd inte den första IP-adressen i adressintervallet. Den första adressen i undernätsintervallet används för adressen kubernetes.default.svc.cluster.local .
- - -docker-bridge-address är Docker Bridge-nätverksadressen som representerar standardadressen för Docker0-bryggnätverket som finns i alla Docker-installationer. Du måste välja ett adressutrymme som inte kolliderar med resten av CIDR:erna i dina nätverk, inklusive klustrets tjänst-CIDR och podd-CIDR.

Distribuera programmet till AKS-kluster

Gå till aks-klusterresursen på Azure-portalen.
Välj Lägg till och lägg till med YAML från någon av resursvyerna (namnområde, arbetsbelastningar, tjänster och ingresser, lagring eller konfiguration).

Klistra in följande YAML. Ersätt dina värden för Azure Database for MySQL– användarnamn och lösenord för flexibel serveradministratör.

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älj Lägg till längst ned i YAML-redigeraren för att distribuera programmet.
När YAML-filen har lagts till visar resursvisningsprogrammet ditt Spring Boot-program. Anteckna den länkade externa IP-adressen som ingår i den externa tjänsten.

Testa programmet

Du kan testa appen med cURL.

Skapa först ett nytt "att göra"-objekt i databasen med hjälp av följande kommando.

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>

Hämta sedan data med hjälp av en ny cURL-begäran eller genom att ange klustrets externa IP-adress i webbläsaren.

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

Det här kommandot returnerar listan med "att göra"-objekt, inklusive det objekt som du har skapat.

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

Här är en skärmbild av dessa cURL-begäranden: Skärmbild som visar kommandoradsutdata för cURL-begäranden.

Du kan se liknande utdata via webbläsaren: Skärmbild som visar utdata för webbläsarbegäran.

Grattis! Du har distribuerat ett Spring Boot-program på Azure Kubernetes Service-kluster (AKS) med Azure Database for MySQL – flexibel server i serverdelen!

Rensa resurserna

För att undvika Azure-avgifter bör du rensa onödiga resurser. När klustret inte längre behövs kan du använda kommandot az group delete för att ta bort resursgruppen, containertjänsten och alla relaterade resurser.

az group delete --name rg-mysqlaksdemo

Kommentar

När du tar bort klustret tas inte microsoft Entra-tjänstens huvudnamn som används av AKS-klustret bort. Stegvisa instruktioner om hur du tar bort tjänstens huvudnamn finns i dokumentationen om viktiga överväganden och borttagning av AKS-tjänsten. Om du använde en hanterad identitet hanteras identiteten av plattformen och kräver inte borttagning.

Nästa steg

Distribuera WordPress-appen på AKS med en flexibel Azure Database for MySQL-server

Skapa en PHP-webbapp (Laravel) med Azure Database for MySQL – flexibel server

Dela via