Kurz: Nasazení Spring Boot aplikace v clusteru AKS s flexibilním serverem MySQL ve virtuální síti

platí pro: Azure Database for MySQL – flexibilní Server

V tomto kurzu se dozvíte, jak nasadit aplikaci Spring Boot v clusteru Azure Kubernetes Service (AKS) s flexibilním serverem Azure Database for MySQL na back-endu a zabezpečeně komunikovat v rámci virtuální sítě Azure.

Požadavky

• Předplatné Azure Pokud ještě nemáte předplatné Azure, vytvořte si bezplatný účet Azure před tím, než začnete. S bezplatným účtem Azure si teď můžete vyzkoušet Azure Database for MySQL – flexibilní server na 12 měsíců zdarma. Další podrobnosti najdete v tématu Vyzkoušejte si flexibilní server zdarma.
• Rozhraní azure Command-Line (CLI).
• Podporovaná sada Java Development Kitverze 8 (zahrnutá v Azure Cloud Shell).
• Nástroj pro sestavování Apache Maven.
• Klient Git.
• Klient Docker.

Vytvoření Azure Database for MySQL – flexibilní server

Vytvoření skupiny prostředků

Skupina prostředků Azure je logická skupina, ve které se nasazují a spravují prostředky Azure. Pojďme vytvořit skupinu prostředků rg-mysqlaksdemo pomocí příkazu az group create v umístění eastus.

1. Otevřete příkazový řádek.
2. Přihlaste se ke svému účtu Azure.

   az login
   

3. Zvolte svoje předplatné Azure.

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

4. Vytvořte skupinu prostředků.

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

Vytvoření flexibilního serveru MySQL

Teď vytvoříme flexibilní server ve virtuální síti (metoda připojení s privátním přístupem).

1. Vytvořte virtuální síť Azure vnet-mysqlaksdemo pro všechny prostředky v tomto kurzu a podsíť subnet-mysql pro flexibilní server 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 
   

2. Ve výše Azure Database for MySQL podsíti vytvořte pomocí příkazu az mysql flexible-server create nový flexibilní server mysql-mysqlaksdemo. Nahraďte hodnoty uživatelského jména a hesla správce.

   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
   

   Právě jste vytvořili flexibilní server v oblasti eastus s výpočetními funkcemi Burstable B1MS, 32GB úložištěm, 7denním obdobím uchovávání záloh a v poskytnuté podsíti subnet-mysql. Tato podsíť by neměla mít nasazený žádný jiný prostředek a bude delegovaná na Microsoft.DBforMySQL/flexibleServers.

3. Nakonfigurujte novou databázi MySQL demo pro použití s Spring Boot aplikací.

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

Vytvoření registru kontejneru Azure

Vytvořte privátní registr kontejneru Azure v této skupině prostředků. V tomto kurzu se ukázková aplikace do tohoto registru v pozdějších krocích nas nabízené jako image Dockeru. Nahraďte položku mysqlaksdemoregistry jedinečným názvem pro svůj registr.

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

Vytvoření kódu aplikace

V této části načtoume ukázku aplikace. Pokud chcete jít rychleji, můžete si stáhnout programovou aplikaci dostupnou na adrese a přeskočit k další části – Sestavení image a nas nabízené oznámení https://github.com/Azure-Samples/tutorial-springboot-mysql-aks do ACR.

1. Vygenerování aplikace pomocí aplikace 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 -
   

   Základní Spring Boot se vygeneruje uvnitř springboot-mysql-aks složky .

   Pomocí oblíbeného textového editoru, jako je VSCode nebo jakékoli integrované vývojové prostředí (IDE), postupujte následovně.

2. Nakonfigurujte Spring Boot, aby Azure Database for MySQL flexibilní server.

   Otevřete soubor src/main/resources/application.properties a přidejte následující fragment kódu. Tento kód čte hostitele databáze, název databáze, uživatelské jméno a heslo ze souboru manifestu Kubernetes.

   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
   

   Upozornění

   Vlastnost konfigurace znamená, Spring Boot automaticky vygeneruje schéma databáze pomocí souboru, který vytvoříme později při každém spring.datasource.initialization-mode=always schema.sql spuštění serveru. To je skvělé pro testování, ale nezapomeňte, že se tím při každém restartování odstraní vaše data, takže byste je neměli používat v produkčním prostředí.

   Poznámka

   Tím, že ke konfigurační vlastnosti spring.datasource.url přidáme ?serverTimezone=UTC, ovladači JDBC sdělíme, aby při připojování k databázi používal datum ve formátu UTC (koordinovaný univerzální čas). V opačném případě by server Java nepoužíval stejný datumový formát jako databáze, což by způsobilo chybu.

3. Vytvořte schéma databáze.

   Spring Boot se automaticky spustí, src/main/resources/schema.sql aby se vytvořilo schéma databáze. Vytvořte tento soubor s následujícím obsahem:

   DROP TABLE IF EXISTS todo;
   CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
   

4. Kód aplikace java Spring Boot.

   Přidejte kód Java, který bude používat JDBC k ukládání a načítání dat ze serveru MySQL. Vytvořte novou třídu Java vedle třídy a Todo DemoApplication přidejte následující kód:

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

   Tato třída je doménový model mapovaný na todo tabulku, kterou jste vytvořili dříve.

   Ke správě této třídy budete potřebovat úložiště. Ve stejném balíčku definujte nové rozhraní TodoRepository:

   package com.example.springbootmysqlaks;
   
   import org.springframework.data.repository.CrudRepository;
   
   public interface TodoRepository extends CrudRepository<Todo, Long> {
   }
   

   Toto úložiště je úložiště, které spravuje Spring Data JDBC.

   Dokončete aplikaci vytvořením kontroleru, který může ukládat a načítat data. Ve stejném balíčku implementujte třídu TodoController a přidejte následující kód:

   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. Vytvořte nový soubor Dockerfile v základním adresáři springboot-mysql-aks a zkopírujte tento fragment kódu.

   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. Přejděte do souborupom.xml a aktualizujte kolekci v souboru pom.xml názvem registru pro vaši Azure Container Registry a nejnovější verzí nástroje <properties> jib-maven-plugin . Poznámka: Pokud název ACR obsahuje velká písmena, nezapomeňte je převést na malá písmena.

   <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. Aktualizujte kolekci v souborupom.xmltak, aby byl prvek obsahující položku pro , jak <plugins> <plugin> je jib-maven-plugin znázorněno níže. Všimněte si, že používáme základní image z Microsoft Container Registry (MCR): , která obsahuje oficiálně podporovanou mcr.microsoft.com/java/jdk:8-zulu-alpine JDK pro Azure. Další základní image MCR s oficiálně podporovanými JDK najdete v tématu Java SE JDK, Java SE JRE, Java SE Headless JREa Java SE JDK a Maven.

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

Sestavení image a nas nabízené oznámení do ACR

Na příkazovém řádku přejděte do složky springboot-mysql-aks a spuštěním následujících příkazů nejprve nastavte výchozí název pro Azure Container Registry (jinak budete muset zadat název v souboru ), sestavte image a pak image nastavte do az acr login registru.

Ujistěte se, že je během provádění tohoto kroku spuštěný démon Dockeru.

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

Vytvoření clusteru Kubernetes v AKS

Teď ve virtuální síti vnet-mysqlaksdemo vytvoříme cluster AKS.

V tomto kurzu použijeme virtuální Azure CNI v AKS. Pokud chcete místo toho nakonfigurovat síť kubenet, podívejte se na použití sítí kubenet v AKS.

1. Vytvořte podsíť aks pro cluster AKS, který se má použít.

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

2. Získejte ID prostředku podsítě.

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

3. Vytvořte cluster AKS ve virtuální síti s připojeným Azure Container Registry (ACR) mysqlaksdemoregistry.

       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
   

   Následující rozsahy IP adres jsou také definovány jako součást procesu vytváření clusteru:

   • --service-cidr slouží k přiřazení IP adresy interním službám v clusteru AKS. Můžete použít libovolný rozsah privátních adres, který splňuje následující požadavky:

     • Nesmí být v rozsahu IP adres virtuální sítě vašeho clusteru.
     • Nesmí se překrývat s žádnými jinými virtuálními sítěmi, se jinými partnerskými uzly virtuálních sítí clusteru.
     • Nesmí se překrývat s žádnými místními IP adresy.
     • Nesmí být v rozsahu 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 nebo 192.0.2.0/24.

   • --dns-service-ip adresa je IP adresa služby DNS clusteru. Tato adresa musí být v rozsahu adres služby Kubernetes. Nepoužívejte první IP adresu v rozsahu adres. První adresa v rozsahu podsítě se používá pro adresu kubernetes.default.svc.cluster.local.

   • --docker-bridge-address je síťová adresa mostu Dockeru, která představuje výchozí síťovou adresu mostu Docker0 přítomnou ve všech instalacích Dockeru. Musíte vybrat adresní prostor, který se nesbývá se zbytkem CIDR ve vašich sítích, včetně CIDR služby clusteru a CIDR podu.

Nasazení aplikace do clusteru AKS

1. Přejděte k prostředku clusteru AKS na Azure Portal.

2. Vyberte Přidat a přidat pomocí YAML z libovolného zobrazení prostředků (obor názvů, úlohy, služby a příchozí přenosy dat, Storage nebo konfigurace).

   

3. Vložte následující YAML. Nahraďte hodnoty uživatelského jména a hesla správce flexibilního serveru 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
   

4. V dolní části editoru YAML vyberte Přidat a nasaďte aplikaci.

   

5. Po přidání souboru YAML se v prohlížeči prostředků zobrazí vaše Spring Boot aplikace. Poznamenejte si propojenou externí IP adresu, která je součástí externí služby.

   

Testování aplikace

K otestování aplikace můžete použít cURL.

Nejprve pomocí následujícího příkazu vytvořte v databázi novou položku "todo".

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>

Dále načtěte data pomocí nové žádosti o kudrlinkou nebo zadáním externí IP adresy clusteru do prohlížeče.

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

Tento příkaz vrátí seznam položek todo, včetně položky, kterou jste vytvořili.

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

Tady je snímek obrazovky s těmito požadavky na oblé: .

Podobný výstup si můžete prohlédnout v prohlížeči:

Gratulujeme! Úspěšně jste nasadili aplikaci jaře boot v clusteru Azure Kubernetes Service (AKS) s Azure Database for MySQLm flexibilním serverem v back-endu.

Vyčištění prostředků

Abyste se vyhnuli poplatkům za Azure, měli byste vyčistit nepotřebné prostředky. Pokud už cluster nepotřebujete, použijte k odebrání skupiny prostředků, služby kontejneru a všech souvisejících prostředků příkaz az group delete.

az group delete --name rg-mysqlaksdemo

Další kroky