Samouczek: wdrażanie aplikacji Spring Boot w klastrze usługi AKS przy użyciu usługi Azure Database for MySQL — serwer elastyczny w sieci wirtualnej

Z tego samouczka dowiesz się, jak wdrożyć aplikację Spring Boot w klastrze usługi Azure Kubernetes Service (AKS) przy użyciu funkcji Co to jest usługa Azure Database for MySQL — serwer elastyczny? w zapleczu, bezpiecznie komunikując się ze sobą w sieci wirtualnej platformy Azure.

Uwaga

W tym samouczku zakłada się podstawową znajomość pojęć związanych z Kubernetes, frameworka Java Spring Boot oraz bazy danych MySQL. W przypadku aplikacji Spring Boot zalecamy używanie usługi Azure Spring Apps. Można jednak nadal używać usług Azure Kubernetes Services jako miejsca docelowego. Zobacz Wskazówki dotyczące miejsca docelowego obciążenia Java, aby uzyskać porady.

Wymagania wstępne

Subskrypcja platformy Azure Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto platformy Azure. Obecnie za pomocą bezpłatnego konta platformy Azure możesz wypróbować usługę Azure Database for MySQL — serwer elastyczny bezpłatnie przez 12 miesięcy. Aby uzyskać więcej informacji, zobacz Używanie bezpłatnego konta platformy Azure do bezpłatnego wypróbowania usługi Azure Database for MySQL — serwer elastyczny bezpłatnie.
Interfejs wiersza polecenia platformy Azure.
Obsługiwany zestaw Java Development Kit w wersji 8 (dołączony do usługi Azure Cloud Shell).
Narzędzie kompilacji Apache Maven.
Klient usługi Git.
Klient platformy Docker.

Tworzenie elastycznego serwera usługi Azure Database for MySQL

Tworzenie grupy zasobów

Grupa zasobów platformy Azure to logiczna grupa przeznaczona do wdrażania zasobów platformy Azure i zarządzania nimi. Utwórzmy grupę zasobów rg-mysqlaksdemo za pomocą polecenia az group create w lokalizacji eastus.

Otwórz wiersz polecenia.
Zaloguj się do swojego konta platformy Azure.
```
az login
```

Wybierz subskrypcję platformy Azure.

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

Utwórz grupę zasobów.

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

Tworzenie wystąpienia serwera elastycznego usługi Azure Database for MySQL

Teraz utworzymy wystąpienie serwera elastycznego usługi Azure Database for MySQL w sieci wirtualnej (metoda łączności z dostępem prywatnym).

Utwórz sieć wirtualną platformy Azure vnet-mysqlaksdemo dla wszystkich zasobów w tym samouczku oraz podsieć subnet-mysql dla wystąpienia usługi Azure Database for MySQL Flexible 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
```
Utwórz wystąpienie Azure Database for MySQL Flexible Server o nazwie mysql-mysqlaksdemo w utworzonej wcześniej podsieci za pomocą polecenia az mysql flexible-server create. Zastąp wartości nazwy użytkownika i hasła administratora.
```
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
```
Utworzono już wystąpienie serwera elastycznego usługi Azure Database for MySQL w regionie eastus z warstwą obliczeniową Burstable B1MS, magazynem o pojemności 32 GB, 7-dniowym okresem przechowywania kopii zapasowych oraz w podanej podsieci subnet-mysql. Ta podsieć nie powinna mieć żadnego innego zasobu wdrożonego w nim i zostanie delegowana do serwera Microsoft.DBforMySQL/flexibleServers.

Skonfiguruj nową bazę danych demo serwera elastycznego usługi Azure Database for MySQL do użycia z aplikacją Spring Boot.

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

Tworzenie rejestru kontenerów platformy Azure

W grupie zasobów utwórz prywatny rejestr kontenerów platformy Azure. W tym samouczku w kolejnych krokach przykładowa aplikacja zostanie przesłana do tego rejestru jako obraz Docker. Zastąp wartość mysqlaksdemoregistry unikatową nazwą rejestru.

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

Kodowanie aplikacji

W tej sekcji kodujemy aplikację demonstracyjną. Jeśli chcesz przyspieszyć, możesz pobrać gotową aplikację z kodem dostępną pod adresem https://github.com/Azure-Samples/tutorial-springboot-mysql-aks i przejść do następnej sekcji — Skompiluj obraz i wypchnij go do ACR.

Wygeneruj aplikację przy użyciu narzędzia 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 -

W folderze springboot-mysql-aks zostanie wygenerowana podstawowa aplikacja Spring Boot.

Aby wykonać poniższe kroki, użyj ulubionego edytora tekstów, takiego jak VSCode lub dowolne środowisko IDE.

Skonfiguruj platformę Spring Boot do korzystania z usługi Azure Database for MySQL — serwer elastyczny.

Otwórz plik src/main/resources/application.properties i dodaj poniższy fragment kodu. Ten kod odczytuje host bazy danych, nazwę bazy danych, nazwę użytkownika i hasło z pliku 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
```
Ostrzeżenie

Właściwość spring.datasource.initialization-mode=always konfiguracji oznacza, że narzędzie Spring Boot automatycznie wygeneruje schemat bazy danych przy użyciu schema.sql pliku, który zostanie utworzony później, za każdym razem, gdy serwer zostanie uruchomiony. Jest to doskonałe rozwiązanie do testowania, ale pamiętaj, że dane zostaną usunięte po każdym ponownym uruchomieniu, więc nie należy ich używać w środowisku produkcyjnym.

Uwaga

Dodaliśmy ?serverTimezone=UTC do właściwości konfiguracji spring.datasource.url, aby poinformować sterownik JDBC o konieczności użycia formatu daty UTC (lub uniwersalnego czasu koordynowanego) podczas nawiązywania połączenia z bazą danych. W przeciwnym razie nasz serwer Java nie użyje tego samego formatu daty co baza danych, co spowoduje błąd.
Utwórz schemat bazy danych.

Spring Boot automatycznie wykona src/main/resources/schema.sql, aby utworzyć schemat bazy danych. Utwórz ten plik z następującą zawartością:
```
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
```

Kod aplikacji Java Spring Boot.

Dodaj kod Java, który będzie używać narzędzia JDBC do przechowywania i pobierania danych z serwera MySQL. Utwórz nową Todo klasę Java obok DemoApplication klasy i dodaj następujący 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;
    }
}

Ta klasa jest modelem domeny zamapowanym na utworzonej wcześniej tabeli todo.

Do zarządzania tą klasą będziesz potrzebować repozytorium. Zdefiniuj nowy interfejs TodoRepository w tym samym pakiecie:

package com.example.springbootmysqlaks;

import org.springframework.data.repository.CrudRepository;

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

To repozytorium jest zarządzane przez Spring Data JDBC.

Zakończ aplikację, tworząc kontroler, który może przechowywać i pobierać dane. Zaimplementuj klasę TodoController w tym samym pakiecie i dodaj następujący 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();
    }
}

Utwórz nowy plik Dockerfile w katalogu podstawowym springboot-mysql-aks i skopiuj ten fragment kodu.

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

Przejdź do pliku pom.xml i zaktualizuj kolekcję <properties> w pliku pom.xml, podając nazwę rejestru usługi Azure Container Registry i najnowszą wersję jib-maven-plugin. Uwaga: jeśli nazwa usługi ACR zawiera wielkie litery, pamiętaj, aby przekonwertować je na małe litery.
```
<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>
```
Zaktualizuj kolekcję <plugins> w pliku pom.xml, tak aby zawierała element <plugin> z wpisem dla elementu jib-maven-plugin, jak pokazano poniżej. Używamy obrazu podstawowego z rejestru Microsoft Container Registry (MCR): mcr.microsoft.com/java/jdk:8-zulu-alpine, który zawiera oficjalnie obsługiwany zestaw JDK dla platformy Azure. W przypadku innych obrazów podstawowych MCR z oficjalnie obsługiwanymi środowiskami JDK, zobacz Docker Hub.
```
<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>
```

Zbuduj obraz i wypchnij go do ACR

W wierszu polecenia przejdź do folderu springboot-mysql-aks i uruchom następujące polecenia, aby najpierw ustawić domyślną nazwę dla usługi Azure Container Registry (w przeciwnym razie musisz określić nazwę w az acr login), następnie zbudować obraz, a potem wypchnąć go do rejestru.

Upewnij się, że demon Dockera jest uruchomiony podczas wykonywania tego kroku.

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

Tworzenie klastra Kubernetes w usłudze AKS

Teraz utworzymy klaster AKS w sieci wirtualnej vnet-mysqlaksdemo.

W tym samouczku użyjemy sieci Azure CNI w AKS. Jeśli zamiast tego chcesz skonfigurować sieć kubenet, zobacz Używanie sieci kubenet w usłudze AKS.

Utwórz podsieć subnet-aks, której będzie używać klaster AKS.

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

Pobierz identyfikator zasobu podsieci.

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

Utwórz klaster AKS w sieci wirtualnej z dołączonym rejestrem 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
```
Następujące zakresy adresów IP są również definiowane w ramach procesu tworzenia klastra:
- Parametr --service-cidr służy do przypisywania adresów IP usługom wewnętrznym w klastrze AKS. Możesz użyć dowolnego zakresu prywatnych adresów, który spełnia następujące wymagania:
  - Nie może należeć do zakresu adresów IP sieci wirtualnej klastra
  - Nie może nakładać się na żadne inne sieci wirtualne, z którymi sieć wirtualna klastra jest połączona w relacji komunikacji równorzędnej.
  - Nie może nakładać się na żadne lokalne adresy IP
  - Nie może należeć do zakresów 169.254.0.0/16, 172.30.0.0/16, 172.31.0.0/16 lub 192.0.2.0/24
- Adres --dns-service-ip jest adresem IP usługi DNS klastra. Ten adres musi znajdować się w zakresie adresów usługi Kubernetes. Nie używaj pierwszego adresu IP w zakresie adresów. Pierwszy adres w zakresie podsieci jest używany jako adres kubernetes.default.svc.cluster.local.
- - -docker-bridge-address to adres sieciowy mostka platformy Docker, który reprezentuje domyślny adres sieciowy mostka platformy Docker0 znajdujący się we wszystkich instalacjach platformy Docker. Musisz wybrać przestrzeń adresową, która nie nakłada się z pozostałymi zakresami CIDR w Twoich sieciach, w tym z zakresem CIDR usług klastra i zakresem CIDR podów.

Wdrażanie aplikacji w klastrze usługi AKS

Przejdź do zasobu klastra AKS w witrynie Azure Portal.
Wybierz opcje Dodaj i Dodaj przy użyciu YAML w dowolnym z widoków zasobów (Przestrzenie nazw, Obciążenia, Usługi i reguły Ingress, Pamięć masowa lub Konfiguracja).

Wklej następujący kod YAML. Zastąp swoje wartości nazwy użytkownika administratora i hasła dla serwera elastycznego 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

Wybierz pozycję Dodaj w dolnej części edytora YAML, aby wdrożyć aplikację.
Po dodaniu pliku YAML przeglądarka zasobów wyświetli aplikację Spring Boot. Zanotuj połączony zewnętrzny adres IP uwzględniony w usłudze zewnętrznej.

Testowanie aplikacji

Do przetestowania aplikacji możesz użyć narzędzia cURL.

Najpierw utwórz nowy element "todo" w bazie danych przy użyciu następującego polecenia.

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>

Następnie pobierz dane za pomocą nowego żądania cURL lub wpisując w przeglądarce zewnętrzny adres IP klastra.

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

To polecenie zwróci listę elementów "todo", w tym utworzony element.

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

Oto zrzut ekranu przedstawiający te żądania cURL:

Podobne dane wyjściowe są widoczne w przeglądarce:

Gratulacje! Pomyślnie wdrożyłeś aplikację Spring Boot w klastrze usługi Azure Kubernetes Service (AKS), używając usługi Azure Database for MySQL — Serwer elastyczny jako zaplecza!

Oczyszczanie zasobów

Aby uniknąć opłat za platformę Azure, należy wyczyścić niepotrzebne zasoby. Gdy klaster nie będzie już potrzebny, usuń grupę zasobów, usługę kontenera i wszystkie pokrewne zasoby za pomocą polecenia az group delete.

az group delete --name rg-mysqlaksdemo