Självstudie: Distribuera ett Spring Boot på AKS-kluster med MySQL – flexibel server i ett VNet

  • Artikel
  • 8 minuter för att läsa

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 på ett Azure Kubernetes Service-kluster (AKS) med Azure Database for MySQL – flexibel server i serverdelar och på ett säkert sätt kommunicerar med varandra i ett virtuellt Azure-nätverk.

Anteckning

Den här självstudien förutsätter grundläggande kunskaper om Kubernetes-begrepp, Java Spring Boot och MySQL.

Förutsättningar

Skapa en Azure Database for MySQL – flexibel server

Skapa en resursgrupp

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

  1. Öppna kommandotolken.
  2. Logga in på ditt Azure-konto. 
    az login
  3. Välj din Azure-prenumeration. 
    az account set -s <your-subscription-ID>
  4. Skapa resursgruppen. 
    az group create --name rg-mysqlaksdemo --location eastus

Skapa en flexibel MySQL-server

Nu ska vi skapa en flexibel server i ett virtuellt nätverk (anslutningsmetod för privat åtkomst).

  1. 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 den flexibla MySQL-servern.

    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. Skapa en Azure Database for MySQL – flexibel server mysql-mysqlaksdemo i det undernät som skapades ovan med kommandot az mysql flexible-server create. Ersätt dina värden för användarnamn och lösenord för administratör.

    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 server i regionen eastus med burstable B1MS-beräkning, 32 GB lagring, kvarhållningsperiod på 7 dagar för säkerhetskopiering och i det angivna undernätets undernät-mysql. Det här undernätet bör inte ha någon annan resurs distribuerad i det och delegeras till Microsoft.DBforMySQL/flexibleServers.

  3. Konfigurera en ny MySQL-databas demo som ska användas med Spring Boot program.

    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 pushas 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å och gå vidare till nästa avsnitt – Skapa avbildningen och https://github.com/Azure-Samples/tutorial-springboot-mysql-aks push-överför till ACR.

  1. 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 basprogram Spring Boot skapas i springboot-mysql-aks mappen .

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

  2. Konfigurera Spring Boot 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 innebär Spring Boot automatiskt genererar ett databasschema med hjälp av filen som vi skapar spring.datasource.initialization-mode=always schema.sql 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!

    Anteckning

    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.

  3. Skapa databasschemat.

    Spring Boot körs automatiskt för src/main/resources/schema.sql 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);

  4. Koda Java Spring Boot programmet.

    Lägg till Java-koden som ska använda 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 mappats i todo tabellen 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 Hanteras av Spring Data JDBC.

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

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

  6. Gå till pom.xml och uppdatera samlingen i pom.xml med registernamnet för din Azure Container Registry och <properties> 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>

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

Skapa avbildningen och push-skicka till ACR

I kommandotolken navigerar 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 ), skapa avbildningen och sedan skicka avbildningen till az acr login 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 i 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 i stället vill konfigurera kubenet-nätverk kan du se Använda kubenet-nätverk i AKS.

  1. Skapa undernäts-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

  2. Hämta undernätets resurs-ID.

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

  3. 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 processen för att skapa kluster:

    • --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 vara inom det virtuella nätverkets IP-adressintervall för klustret
      • Får inte överlappa med andra virtuella nätverk som klustrets virtuella nätverk är peer-datorer med
      • Får inte överlappa med några lokala IP-adresser
      • Får inte vara inom intervallen 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 eller 192.0.2.0/24

    • --dns-service-ip-adressen ä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-bryggnätverksadressen som representerar standardadressen för docker0-bryggnätverket som finns i alla Docker-installationer. Du måste välja ett adressutrymme som inte krockar med resten av CIDR:erna i dina nätverk, inklusive klustrets tjänst-CIDR och podd-CIDR.

Distribuera programmet till AKS-kluster

  1. Gå till AKS-klusterresursen på Azure Portal.

  2. Välj Lägg till och lägg till med YAML från någon av resursvyerna (namnområde, arbetsbelastningar, tjänster och ingresser, Storage eller konfiguration).

    Skärmbild som visar Azure Kubernetes Service resursvy på Azure Portal.

  3. Klistra in följande YAML. Ersätt dina värden för användarnamn och lösenord för MySQL – 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

  4. Välj Lägg till längst ned i YAML-redigeraren för att distribuera programmet.

    Skärmbild som visar Lägg till med YAML-redigerare.

  5. När YAML-filen har lagts till visar resursvisningsprogrammet Spring Boot program. Anteckna den länkade externa IP-adressen som ingår i den externa tjänsten.

    Skärmbild som visar Azure Portal över extern IP-adress för Azure Kubernetes-klustertjänsten.

Testa programmet

Du kan testa appen med cURL.

Skapa först ett nytt "att göra"-objekt i databasen med 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 från webbläsarbegäran.

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

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

Anteckning

När du tar bort klustret tas Azure Active Directory-tjänstens huvudnamn, som används av AKS-klustret, inte 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-app på AKS med MySQL

Skapa en PHP-webbapp (Laravel) med MySQL