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

VAN TOEPASSING OP: Azure Database for MySQL - Flexible Server

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

Vereisten

• Een Azure-abonnement Als u geen Azure-abonnement hebt, maakt u een gratis Azure-account voordat u begint. Met een gratis Azure-account kunt u nu Azure Database for MySQL - Flexible Server 12 maanden gratis uitproberen. Zie Flexibele server gratis 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.

Azure Database for MySQL - flexibele server maken

Een resourcegroep maken

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

1. Open de opdrachtprompt.
2. Meld u aan bij uw Azure-account.

   az login
   

3. Kies uw Azure-abonnement.

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

4. Maak de resourcegroep.

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

Een flexibele MySQL-server maken

We gaan nu een flexibele server maken in een virtueel netwerk (verbindingsmethode voor privétoegang).

1. Maak een virtueel Azure-netwerk vnet-mysqlaksdemo voor alle resources in deze zelfstudie en een subnetsubnet-mysql voor de flexibele MySQL-server.

   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 
   

2. Maak een Azure Database for MySQL - Flexible Server mysql-mysqlaksdemo in het hierboven 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 flexibele server gemaakt in de regio eastus met Burstable B1MS compute, 32 GB opslag, 7 dagen back-upretentieperiode en in het opgegeven subnet subnet-mysql. In dit subnet mogen geen andere resources zijn geïmplementeerd en deze worden gedelegeerd aan Microsoft.DBforMySQL/flexibleServers.

3. Configureer een nieuwe MySQL-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 zelfstudie wordt de voorbeeld-app in latere stappen als een Docker-afbeelding naar dit register pusht. 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 coderen we de demotoepassing. Als u sneller wilt gaan, kunt u de gecodeerde toepassing downloaden die beschikbaar is op en naar de volgende sectie gaan: De afbeelding bouwen en https://github.com/Azure-Samples/tutorial-springboot-mysql-aks naar ACR pushen.

1. Genereer de toepassing met behulp van 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 Spring Boot basistoepassing gegenereerd in de springboot-mysql-aks map .

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

2. Configureer Spring Boot om Azure Database for MySQL - Flexible Server te gebruiken.

   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 betekent dat Spring Boot automatisch een databaseschema genereert, met behulp van het bestand dat we later zullen maken, telkens wanneer de spring.datasource.initialization-mode=always schema.sql server wordt gestart. Dit is geweldig om te testen, maar vergeet niet dat uw gegevens bij elke herstart worden verwijderd, dus deze mogen niet in productie worden gebruikt.

   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.

3. Maak het databaseschema.

   Spring Boot wordt automatisch uitgevoerd om src/main/resources/schema.sql 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);
   

4. 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 toe te staan aan de todo tabel 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 beheert.

   U kunt de toepassing voltooien 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();
       }
   }
   

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

6. Ga naar het pom.xml en werk de verzameling in het pom.xml-bestand bij met de registernaam voor uw Azure Container Registry en de nieuwste <properties> 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>
   

7. Werk de verzameling in hetpom.xmlbij zodat er een -element is met een <plugins> vermelding voor de , zoals hieronder wordt <plugin> jib-maven-plugin 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 Java SE JDK, Java SE JRE, Java SE Headless JRE en Java SE JDK en Maven 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 afbeelding 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 in ), de afbeelding bouwen en vervolgens de afbeelding naar het register az acr login 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 gaan nu een AKS-cluster maken in het virtuele netwerk vnet-mysqlaksdemo.

In deze zelfstudie gebruiken we Azure CNI netwerken in AKS. Zie Kubenet-netwerken gebruiken in AKS als u in plaats daarvan kubenet-netwerken wilt configureren.

1. Maak een subnetsubnet-aks die door het AKS-cluster kunnen 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
   

2. 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)
   

3. Maak een AKS-cluster in het virtuele netwerk, met Azure Container Registry (ACR) mysqlaksdemoregistry 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 proces voor het maken van het cluster:

   • 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
     • Mag niet overlappen met andere virtuele netwerken waarmee het virtuele netwerk van het cluster peers is
     • Mag niet overlappen met on-premises IP's
     • Mag zich niet binnen het bereik 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 of 192.0.2.0/24

   • Het --dns-service-ip-adres 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 uw subnetbereik wordt gebruikt voor het adres kubernetes.default.svc.cluster.local.

   • Het --docker-bridge-address is het docker bridge-netwerkadres dat het standaardnetwerkadres docker0 bridge vertegenwoordigt dat aanwezig is in alle Docker-installaties. U moet een adresruimte kiezen die niet in contact komt met de rest van de CIDR's in uw netwerken, met inbegrip van de CIDR van de service van het cluster en de CIDR voor pods.

De toepassing implementeren in een AKS-cluster

1. Ga naar uw AKS-clusterresource op Azure Portal.

2. Selecteer Toevoegen en toevoegen met YAML in een van de resourceweergaven (Naamruimte, Workloads, Services en ingresses, Storage of Configuratie).

   

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

4. Selecteer Toevoegen onderaan de YAML-editor om de toepassing te implementeren.

   

5. 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 geven.

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

Met deze opdracht wordt de lijst met 'todo'-items, inclusief het item dat u hebt gemaakt, weergegeven.

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

Hier ziet u een schermopname van deze cURL-aanvragen: Schermopname van de

U ziet een vergelijkbare uitvoer via uw browser:

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

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

Volgende stappen