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

In deze zelfstudie leert u hoe u een Spring Boot-toepassing implementeert in een AKS-cluster (Azure Kubernetes Service) met Wat is Azure Database for MySQL - Flexible Server? in de back-end en veilig met elkaar communiceren 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-workloaddoelen 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 Een gratis Azure-account gebruiken om Gratis Azure Database for MySQL - Flexible Server te proberen 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 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. Laten we een resourcegroep rg-mysqlaksdemo maken met de opdracht az group create op 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 Azure Database for MySQL Flexible Server-exemplaar maken

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

Maak een Azure Virtual Network vnet-mysqlaksdemo voor alle resources in deze zelfstudie en een subnet subnet-mysql voor het Azure Database for MySQL Flexible Server-exemplaar.

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 hierboven gemaakte subnet met 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 Azure Database for MySQL Flexible Server-exemplaar gemaakt in de regio eastus met Burstable B1MS-rekenproceskracht, 32 GB opslag, een back-upretentieperiode van 7 dagen en in het opgegeven subnet subnet-mysql. Dit subnet mag geen andere resources bevatten en zal worden gedelegeerd aan Microsoft.DBforMySQL/flexibleServers.
Configureer een nieuwe Azure Database for MySQL Flexible Server-database 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 tutorial wordt de voorbeeld-app in latere stappen als Docker-image naar dit containerregister gepusht. 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 gaan we de demotoepassing programmeren. Als u sneller te werk wilt gaan, kunt u de uitgewerkte toepassing downloaden die beschikbaar is op https://github.com/Azure-Samples/tutorial-springboot-mysql-aks en doorgaan naar de volgende sectie - De image 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 Azure Database for MySQL Flexible 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 zal automatisch src/main/resources/schema.sql uitvoeren 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);
```

Programmeer de Java Spring Boot-applicatie.

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. We gebruiken een basisimage uit het Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, die een officieel ondersteund JDK voor Azure bevat. 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 image bouwen en naar ACR pushen

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-netwerkintegratie in AKS. Als u in plaats daarvan kubenet-netwerken wilt configureren, zie Kubenet-netwerken gebruiken in AKS.

Maak een subnet subnet-aks dat door het AKS-cluster kan 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 netwerk van het cluster is gekoppeld
  - Mag niet overlappen met on-premises IP-adressen
  - Mag niet in de reeksen 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 of 192.0.2.0/24 liggen
- 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 overlapt met de overige CIDR-reeksen in uw netwerken, waaronder de service-CIDR en pod-CIDR van het cluster.

De toepassing implementeren in een AKS-cluster

Ga naar je AKS-clusterresource in de 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-code. Vervang uw waarden voor de gebruikersnaam en het wachtwoord van de beheerder van Azure Database for MySQL Flexible Server.

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>

Deze opdracht retourneert de lijst met "todo"-items, inclusief het item dat u hebt aangemaakt.

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

Hier volgt een schermopname van deze cURL-aanvragen:

U kunt een vergelijkbare uitvoer zien via uw browser:

Gefeliciteerd. U hebt een Spring Boot-toepassing geïmplementeerd in een AKS-cluster (Azure Kubernetes Service) met Azure Database for MySQL Flexible 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