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

DOTYCZY: Azure Database for MySQL — serwer elastyczny

Z tego samouczka dowiesz się, jak wdrożyć aplikację Spring Boot w klastrze usługi Azure Kubernetes Service (AKS) przy użyciu elastycznego serwera usługi Azure Database for MySQL w zapleczu, bezpiecznie komunikując się ze sobą w sieci wirtualnej platformy Azure.

Uwaga

W tym samouczku założono, że podstawowa wiedza na temat pojęć związanych z platformą Kubernetes, środowiska Java Spring Boot i 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. Aby uzyskać porady, zobacz Wskazówki dotyczące miejsca docelowego obciążenia w języku Java.

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 Wypróbuj bezpłatnie usługę Azure Database for MySQL — serwer elastyczny.
• 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 przy użyciu polecenia az group create w lokalizacji eastus .

1. Otwórz wiersz polecenia.
2. Zaloguj się do swojego konta platformy Azure.

   az login
   

3. Wybierz subskrypcję platformy Azure.

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

4. Utwórz grupę zasobów.

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

Tworzenie wystąpienia elastycznego serwera 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).

1. Utwórz sieć wirtualną platformy Azure vnet-mysqlaksdemo dla wszystkich zasobów w tym samouczku oraz podsieć podsieci mysql dla wystąpienia serwera elastycznego usługi Azure Database for 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. Utwórz wystąpienie serwera elastycznego usługi Azure Database for MySQL mysql-mysqlaksdemo w powyższej utworzonej podsieci przy użyciu 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 wystąpienie serwera elastycznego usługi Azure Database for MySQL w regionie eastus z obliczeniami B1MS z możliwością burstable B1MS, magazynem 32 GB, 7-dniowym okresem przechowywania kopii zapasowych oraz w podanej podsieci podsieci-mysql. Ta podsieć nie powinna mieć żadnego innego zasobu wdrożonego w nim i zostanie delegowana do serwera Microsoft.DBforMySQL/flexibleServers.

3. 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. Ten samouczek wypycha przykładową aplikację jako obraz platformy Docker do tego rejestru w kolejnych krokach. 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 szybciej przejść, możesz pobrać kodowana aplikację 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 usługi ACR.

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

2. Skonfiguruj platformę Spring Boot do korzystania z elastycznego serwera usługi Azure Database for MySQL.

   Otwórz plik src/main/resources/application.properties i dodaj poniższy fragment kodu. Ten kod odczytuje hosta 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.

3. Utwórz schemat bazy danych.

   Narzędzie Spring Boot zostanie wykonane src/main/resources/schema.sql automatycznie w celu utworzenia schematu 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);
   

4. 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 repozytorium, które zarządza rozwiązaniem 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();
       }
   }
   

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

6. Przejdź do pliku pom.xml i zaktualizuj <properties> kolekcję w pliku pom.xml przy użyciu nazwy rejestru usługi Azure Container Registry i najnowszej wersji programu 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>
   

7. <plugins> Zaktualizuj kolekcję w pliku pom.xml, aby istniał <plugin> element zawierający wpis dla jib-maven-pluginelementu , jak pokazano poniżej. Pamiętaj, że korzystamy z obrazu podstawowego z usługi 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 zestawami JDK zobacz centrum platformy Docker.

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

Kompilowanie obrazu i wypychanie do usługi ACR

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

Upewnij się, że demon platformy Docker 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 usługi AKS w sieci wirtualnej vnet-mysqlaksdemo.

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

1. Utwórz podsieć podsieci aks dla klastra usługi AKS do użycia.

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

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

3. Utwórz klaster usługi AKS w sieci wirtualnej za pomocą dołączonej usługi 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 usług wewnętrznych w klastrze usługi AKS jako adresu IP. 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 inne sieci wirtualne, z którymi klastra wirtualne sieci równorzędne
     • 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 dla adresu 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 zderza się z resztą ciDR w sieciach, w tym ciDR usługi klastra i ciDR zasobnika.

Wdrażanie aplikacji w klastrze usługi AKS

1. Przejdź do zasobu klastra usługi AKS w witrynie Azure Portal.

2. Wybierz pozycję Dodaj i dodaj z dowolnego z widoków zasobów (przestrzeń nazw, obciążenia, usługi i ruch przychodzący, magazyn lub konfiguracja).

   

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

4. Wybierz pozycję Dodaj w dolnej części edytora YAML, aby wdrożyć aplikację.

   

5. 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 przy użyciu nowego żądania cURL lub wprowadzając zewnętrzny adres IP klastra w przeglądarce.

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żono aplikację Spring Boot w klastrze usługi Azure Kubernetes Service (AKS) przy użyciu elastycznego serwera usługi Azure Database for MySQL w zapleczu!

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

Uwaga

Po usunięciu klastra jednostka usługi Microsoft Entra używana przez klaster usługi AKS nie zostanie usunięta. Aby sprawdzić, jak usunąć jednostkę usługi, zobacz AKS service principal considerations and deletion (Uwagi dotyczące jednostki usługi AKS i jej usuwanie). Jeśli użyto tożsamości zarządzanej, tożsamość jest zarządzana przez platformę i nie wymaga usunięcia.

Następne kroki

Wdrażanie aplikacji WordPress w usłudze AKS za pomocą elastycznego serwera usługi Azure Database for MySQL

Tworzenie aplikacji internetowej w języku PHP (Laravel) przy użyciu elastycznego serwera usługi Azure Database for MySQL