Zelfstudie: Een Spring Boot-toepassing implementeren in een AKS-cluster met Azure Database for MySQL - Flexible Server in een VNet

Artikel
12/19/2023

VAN TOEPASSING OP: Azure Database for MySQL - Flexibele server

In deze zelfstudie leert u hoe u een Spring Boot-toepassing implementeert in een AKS-cluster (Azure Kubernetes Service) met flexibele Azure Database for MySQL-server in de back-end en veilig met elkaar communiceert binnen een virtueel Azure-netwerk.

Notitie

In deze zelfstudie wordt ervan uitgegaan dat u basiskennis hebt van Kubernetes-concepten, Java Spring Boot en MySQL. Voor Spring Boot-toepassingen raden we u aan Azure Spring Apps te gebruiken. U kunt Echter nog steeds Azure Kubernetes Services als bestemming gebruiken. Zie de richtlijnen voor java-workloadbestemmingen voor advies.

Vereisten

Als u geen Azure-abonnement hebt, maakt u een gratis Azure-account voordat u begint. Op dit moment kunt u met een gratis Azure-account Azure Database for MySQL - Flexible Server 12 maanden gratis proberen. Zie Azure Database for MySQL - Flexible Server gratis uitproberen voor meer informatie.
De Azure-opdrachtregelinterface (CLI).
Een ondersteunde Java Development Kitversie 8 (opgenomen in Azure Cloud Shell).
De compilatietool Apache Maven.
Een Git-client.
Een Docker-client.

Een flexibele Azure Database for MySQL Flexible Server maken

Een brongroep maken

Een Azure-resourcegroep is een logische groep waarin Azure-resources worden geïmplementeerd en beheerd. We gaan een resourcegroep maken rg-mysqlaksdemo met behulp van de opdracht az group create in de locatie eastus.

Open de opdrachtprompt.
Meld u aan bij uw Azure-account.
```
az login
```

Kies uw Azure-abonnement.

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

Maak de resourcegroep.

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

Een exemplaar van een flexibele Azure Database for MySQL-server maken

We maken nu een exemplaar van een flexibele Azure Database for MySQL-server in een virtueel netwerk (connectiviteitsmethode voor privétoegang).

Maak een virtueel Azure-netwerk vnet-mysqlaksdemo voor alle resources in deze zelfstudie en een subnetsubnet-mysql voor het flexibele serverexemplaren van 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

Maak een azure Database for MySQL Flexible Server-exemplaar mysql-mysqlaksdemo in het bovenstaande gemaakte subnet met behulp van de opdracht az mysql flexible-server create . Vervang uw waarden voor de gebruikersnaam en het wachtwoord van de beheerder.
```
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
```
U hebt nu een exemplaar van een flexibele Azure Database for MySQL-server gemaakt in de regio Eastus met Burstable B1MS-rekenkracht, 32 GB opslag, 7 dagen back-upretentieperiode en in het opgegeven subnetsubnet-mysql. Dit subnet mag geen andere resource hebben geïmplementeerd en wordt gedelegeerd aan Microsoft.DBforMySQL/flexibleServers.
Configureer een nieuwe flexibele Azure Database for MySQL-serverdatabase demo die moet worden gebruikt met de Spring Boot-toepassing.
```
az mysql flexible-server db create \
--resource-group rg-mysqlaksdemo \
--server-name mysql-mysqlaksdemo \
--database-name demo
```

Een Azure-containerregister maken

Maak een privé-Azure-containerregister in de resourcegroep. In deze zelfstudie wordt de voorbeeld-app in latere stappen naar dit register gepusht als docker-installatiekopieën. Vervang mysqlaksdemoregistry door een unieke naam voor uw register.

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

De toepassing coderen

In deze sectie codeert u de demotoepassing. Als u sneller wilt gaan, kunt u de gecodeerde toepassing downloaden die beschikbaar is op https://github.com/Azure-Samples/tutorial-springboot-mysql-aks en verdergaan naar de volgende sectie: de installatiekopieën bouwen en naar ACR pushen.

Genereer de toepassing met 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 -

Er wordt een basis-Spring Boot-toepassing gegenereerd in de springboot-mysql-aks map.

Gebruik uw favoriete teksteditor zoals VSCode of een IDE voor de volgende stappen.

Configureer Spring Boot voor het gebruik van flexibele Azure Database for MySQL-server.

Open het bestand src/main/resources/application.properties en voeg het onderstaande fragment toe. Deze code leest de databasehost, databasenaam, gebruikersnaam en wachtwoord uit het Kubernetes-manifestbestand.
```
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
```
Waarschuwing

De configuratie-eigenschap spring.datasource.initialization-mode=always betekent dat Spring Boot automatisch een databaseschema genereert met behulp van het schema.sql bestand dat we later gaan maken, telkens wanneer de server wordt gestart. Dit is handig voor het testen, maar vergeet niet dat uw gegevens bij elke herstart worden verwijderd, dus dit mag niet worden gebruikt in productie!

Notitie

We voegen ?serverTimezone=UTC toe aan de configuratie-eigenschap spring.datasource.url om het JDBC-stuurprogramma te laten weten dat de UTC datumnotatie (of Coordinated Universal Time) moet worden gebruikt wanneer verbinding wordt gemaakt met de database. Anders gebruikt de Java-server niet dezelfde datumnotatie als de database, hetgeen resulteert in een fout.
Maak het databaseschema.

Spring Boot wordt automatisch uitgevoerd src/main/resources/schema.sql om een databaseschema te maken. Maak het bestand met de volgende inhoud:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Codeer de Java Spring Boot-toepassing.

Voeg de Java-code toe die JDBC gebruikt om gegevens op te slaan en op te halen van uw MySQL-server. Maak een nieuwe Java-klasse Todo, naast de klasse DemoApplication, en voeg de volgende code toe:

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

Deze klasse is een domeinmodel dat is toegewezen aan de tabel todo die u eerder hebt gemaakt.

Als u deze klasse wilt beheren, hebt u een opslagplaats nodig. Definieer een nieuwe TodoRepository-interface in hetzelfde pakket:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

Deze opslagplaats is een opslagplaats die door Spring Data JDBC wordt beheerd.

Voltooi de toepassing door een controller te maken die gegevens kan opslaan en ophalen. Implementeer een TodoController-klasse in hetzelfde pakket en voeg de volgende code toe:

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

Maak een nieuw Dockerfile in de basismap springboot-mysql-aks en kopieer dit codefragment.

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

Ga naar het bestand pom.xml en werk de <properties> verzameling in het pom.xml bestand bij met de registernaam voor uw Azure Container Registry en de nieuwste versie van jib-maven-plugin. Opmerking: Als uw ACR-naam hoofdletters bevat, moet u deze converteren naar kleine letters.
```
<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>
```
Werk de <plugins> verzameling in het pom.xml-bestand bij, zodat er een element is dat een <plugin> vermelding bevat voor de jib-maven-plugin, zoals hieronder wordt weergegeven. U ziet dat we een basisinstallatiekopie uit het MCR (Microsoft-containerregister) gebruiken: mcr.microsoft.com/java/jdk:8-zulu-alpine. Deze bevat een officieel ondersteunde JDK voor Azure. Zie de docker-hub voor andere MCR-basisinstallatiekopieën met officieel ondersteunde JDK's.
```
<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>
```

De installatiekopieën bouwen en pushen naar ACR

Navigeer in de opdrachtprompt naar de map springboot-mysql-aks en voer de volgende opdrachten uit om eerst de standaardnaam voor Azure Container Registry in te stellen (anders moet u de naam opgeven), az acr loginde installatiekopieën bouwen en de installatiekopieën vervolgens naar het register pushen.

Zorg ervoor dat uw Docker-daemon wordt uitgevoerd tijdens het uitvoeren van deze stap.

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

Een Kubernetes-cluster maken in AKS

We maken nu een AKS-cluster in het virtuele netwerk vnet-mysqlaksdemo.

In deze zelfstudie gebruiken we Azure CNI-netwerken in AKS. Als u in plaats daarvan kubenet-netwerken wilt configureren, raadpleegt u Kubenet-netwerken gebruiken in AKS.

Maak een subnetsubnet-aks voor het AKS-cluster dat moet worden gebruikt.

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

Haal de resource-id van het subnet op.

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

Maak een AKS-cluster in het virtuele netwerk, waarbij azure Container Registry (ACR) mysqlaksdemoregistry is gekoppeld.
```
    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
```
De volgende IP-adresbereiken worden ook gedefinieerd als onderdeel van het clustermaakproces:
- De --service-cidr wordt gebruikt om interne services in het AKS-cluster een IP-adres toe te wijzen. U kunt elk privéadresbereik gebruiken dat voldoet aan de volgende vereisten:
  - Mag zich niet binnen het IP-adresbereik van het virtuele netwerk van uw cluster bevinden
  - Mag niet overlappen met andere virtuele netwerken waarmee het virtuele clusternetwerk peers
  - Mag niet overlappen met on-premises IP-adressen
  - Mag niet binnen de bereiken 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 of 192.0.2.0/24 vallen
- Het IP-adres --dns-service-ip is het IP-adres voor de DNS-service van het cluster. Dit adres moet binnen het adresbereik van Kubernetes Service liggen. Gebruik niet het eerste IP-adres in uw adresbereik. Het eerste adres in het subnetbereik wordt gebruikt voor het adres kubernetes.default.svc.cluster.local .
- Het --docker-bridge-address is het docker bridge-netwerkadres dat het standaardnetwerkadres van docker0-brug vertegenwoordigt dat aanwezig is in alle Docker-installaties. U moet een adresruimte kiezen die niet botst met de rest van de CIDR's in uw netwerken, waaronder de CIDR van de service-CIDR van het cluster en de CIDR van de pod.

De toepassing implementeren in een AKS-cluster

Ga naar uw AKS-clusterresource in Azure Portal.
Selecteer Toevoegen en toevoegen met YAML in een van de resourceweergaven (naamruimte, workloads, services en ingresses, opslag of configuratie).

Plak de volgende YAML. Vervang uw waarden voor de gebruikersnaam en het wachtwoord van de flexibele serverbeheerder van 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

Selecteer Toevoegen onderaan de YAML-editor om de toepassing te implementeren.
Zodra het YAML-bestand is toegevoegd, toont de resourceviewer uw Spring Boot-toepassing. Noteer het gekoppelde externe IP-adres dat is opgenomen in de externe service.

De toepassing testen

Als u de toepassing wilt testen, kunt u cURL gebruiken.

Maak eerst een nieuw todo-item in de database met behulp van de volgende opdracht.

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>

Haal vervolgens de gegevens op met behulp van een nieuwe cURL-aanvraag of door het externe IP-adres van het cluster in uw browser in te voeren.

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

Met deze opdracht wordt de lijst met taken geretourneerd, inclusief het item dat u hebt gemaakt.

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

Hier volgt een schermopname van deze cURL-aanvragen: Schermopname van de opdrachtregeluitvoer van cURL-aanvragen.

U kunt een vergelijkbare uitvoer zien via uw browser: Schermopname van de uitvoer van browseraanvragen.

Gefeliciteerd U hebt een Spring Boot-toepassing geïmplementeerd in een AKS-cluster (Azure Kubernetes Service) met flexibele Azure Database for MySQL-server in de back-end.

De resources opschonen

Om Azure-kosten te vermijden, moet u overbodige resources opschonen. Gebruik de opdracht az group delete om de resourcegroep, de containerservice en alle gerelateerde resources te verwijderen wanneer u het cluster niet meer nodig hebt.

az group delete --name rg-mysqlaksdemo