Spring Boot-alkalmazás üzembe helyezése Azure Kubernetes Service

Jegyzet

Spring Boot-alkalmazásokhoz használja a Azure Container Apps. Az Azure Kubernetes Service azonban továbbra is használható célként. További információ: Java-alkalmazások megfelelő Azure-szolgáltatásainak kiválasztása.

Ez az oktatóanyag bemutatja, hogyan fejleszthet és helyezhet üzembe Spring Boot-alkalmazásokat a Kubernetes és a Docker használatával a Microsoft Azure. Pontosabban az alkalmazásfejlesztéshez Spring Boot, a tároló üzembe helyezéséhez Kubernetes, az alkalmazás üzemeltetéséhez pedig Azure Kubernetes Service (AKS).

Kubernetes és A Docker olyan nyílt forráskódú megoldások, amelyek segítségével a fejlesztők automatizálhatják a tárolókban futó alkalmazások üzembe helyezését, méretezését és felügyeletét.

Előfeltételek

• Azure előfizetés; ha még nem rendelkezik Azure előfizetéssel, aktiválja az MSDN-előfizetői előnyöket, vagy regisztráljon egy ingyenes Azure-fiókra.
• Az Azure Command-Line Interface (CLI).
• Egy támogatott Java Development Kit (JDK). Az Azure-beli fejlesztés során használható JDK-kkal kapcsolatos további információkért lásd Java-támogatást az Azure-ban és az Azure Stack.
• Az Apache Maven buildelési eszköze (3. verzió).
• Egy Git ügyfél.
• Egy Docker--ügyfél.
• Az ACR Docker hitelesítő segéd.

Jegyzet

Az oktatóanyag virtualizálási követelményei miatt nem tudja követni a jelen cikkben szereplő lépéseket egy virtuális gépen. Olyan fizikai számítógépet kell használnia, amelyen engedélyezve van a virtualizálási funkció.

A Spring Boot létrehozása a Docker Első lépések webalkalmazásban

Az alábbi lépések végigvezetik egy Spring Boot-webalkalmazás létrehozásán és helyi tesztelésén.

1. Nyisson meg egy parancssort, és hozzon létre egy helyi könyvtárat az alkalmazás tárolásához, és váltson erre a könyvtárra; például:

   mkdir C:\SpringBoot
   cd C:\SpringBoot
   

   --vagy--

   mkdir /users/$USER/SpringBoot
   cd /users/$USER/SpringBoot
   

2. Klónozza a Spring Boott a Docker első lépésein mintaprojektet a könyvtárba.

   git clone https://github.com/spring-guides/gs-spring-boot-docker.git
   

3. Módosítsa a könyvtárat a befejezett projektre.

   cd gs-spring-boot-docker
   cd complete
   

4. A Maven használatával hozza létre és futtassa a mintaalkalmazást.

   mvn package spring-boot:run
   

5. Tesztelje a webalkalmazást úgy, hogy a http://localhost:8080-ra böngészik, vagy a következő curl paranccsal:

   curl http://localhost:8080
   

6. A következő üzenet jelenik meg: Hello Docker World

   

Azure Container Registry létrehozása az Azure CLI használatával

1. Nyisson meg egy parancssort.

2. Jelentkezzen be az Azure-fiókjába:

   az login
   

3. Válassza ki Azure előfizetését:

   az account set -s <YourSubscriptionID>
   

4. Hozzon létre egy erőforráscsoportot az oktatóanyagban használt Azure-erőforrásokhoz.

   az group create --name=wingtiptoys-kubernetes --location=eastus
   

5. Hozzon létre egy privát Azure-tárolóregisztrációs adatbázist az erőforráscsoportban. Az oktatóanyag későbbi lépésekben Docker-rendszerképként küldi le a mintaalkalmazást ebbe a beállításjegyzékbe. Cserélje le a wingtiptoysregistry-t egyedi névre a beállításjegyzékben.

   az acr create --resource-group wingtiptoys-kubernetes --location eastus \
    --name wingtiptoysregistry --sku Basic
   

Az alkalmazás leküldése a tárolóregisztrációs adatbázisba a Jib használatával

1. Jelentkezzen be az Azure CLI-ből az Azure Container Registrybe.

   # set the default name for Azure Container Registry, otherwise you need to specify the name in "az acr login"
   az config set defaults.acr=wingtiptoysregistry
   az acr login
   

2. Nyissa meg a pom.xml fájlt egy szövegszerkesztővel, például Visual Studio Code.

   code pom.xml
   

3. Frissítse a <properties> gyűjteményt a pom.xml fájlban az Azure Container Registry regisztrációs nevével és a jib-maven-plugin legújabb verziójával.

   <properties>
      <!-- Note: If your ACR name contains upper case characters, be sure to convert them to lower case characters. -->
      <docker.image.prefix>wingtiptoysregistry.azurecr.io</docker.image.prefix>
      <jib-maven-plugin.version>2.5.2</jib-maven-plugin.version>
      <java.version>1.8</java.version>
   </properties>
   

4. Frissítse a <plugins> gyűjteményt a pom.xml fájlban, hogy a <plugin> elem tartalmazhassa a jib-maven-pluginbejegyzését, ahogyan az az alábbi példában is látható. Használjon egy alaprendszerképet a Microsoft Tárolóregisztrációs adatbázisból (MCR): mcr.microsoft.com/openjdk/jdk:11-ubuntuamely egy hivatalosan támogatott JDK-t tartalmaz Azure számára. A hivatalosan támogatott JDK-kkal rendelkező többi MCR-alaprendszerképről lásd: A Microsoft Build – OpenJDK telepítése.

   <plugin>
     <artifactId>jib-maven-plugin</artifactId>
     <groupId>com.google.cloud.tools</groupId>
     <version>${jib-maven-plugin.version}</version>
     <configuration>
        <from>
            <image>mcr.microsoft.com/openjdk/jdk:11-ubuntu</image>
        </from>
        <to>
            <image>${docker.image.prefix}/gs-spring-boot-docker</image>
        </to>
     </configuration>
   </plugin>
   

5. Nyissa meg a Spring Boot-alkalmazás befejezett projektkönyvtárát, és futtassa a következő parancsot a rendszerkép létrehozásához és a lemezkép beállításjegyzékbe való leküldéséhez:

   az acr login && mvn compile jib:build
   

Jegyzet

Biztonsági okokból a használatával az acr login létrehozott hitelesítő adatok egy óráig érvényesek. Ha hibaüzenet jelenik 401 Unauthorized meg, futtassa újra a az acr login --name <your registry name> parancsot az újrahitelesítéshez. Ha Read timed out hiba jelenik meg, próbálja meg növelni az időtúllépési értékeket a(z) mvn -Djib.httpTimeout=7200000 jib:dockerBuild használatával, vagy használja a(z) -Djib.httpTimeout=0 beállítást végtelen időtúllépéshez.

Kubernetes-fürt létrehozása az AKS-ben az Azure CLI használatával

1. Hozzon létre egy Kubernetes-fürtöt az Azure Kubernetes Service-ben. Az alábbi parancs létrehoz egy Kubernetes-fürtöt az wingtiptoys-kubernetes erőforráscsoportban, wingtiptoys-akscluster a fürt neveként, a Azure Container Registry (ACR) wingtiptoysregistry csatolásával, valamint wingtiptoys-kubernetes DNS-előtagként:

   az aks create --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster \
    --attach-acr wingtiptoysregistry \
    --dns-name-prefix=wingtiptoys-kubernetes --generate-ssh-keys
   

   A parancs végrehajtása eltarthat egy ideig.

2. Telepítse kubectl az Azure CLI használatával. Előfordulhat, hogy a Linux-felhasználóknak a parancs elé kell írniuk a(z) sudo elemet, mivel ez a Kubernetes parancssori eszközt a(z) /usr/local/bin helyre telepíti.

   az aks install-cli
   

3. Töltse le a fürt konfigurációs adatait, hogy a fürtöt a Kubernetes webes felületéről és kubectl-ból kezelhesse.

   az aks get-credentials --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster
   

A kép üzembe helyezése a Kubernetes-fürtben

Ez az oktatóanyag üzembe helyezi az alkalmazást a Kubernetes kubectlwebes felületén keresztül, majd áttekintheti az üzembe helyezést.

Üzembe helyezés a kubectl használatával

1. Nyisson meg egy parancssort.

2. Futtassa a tárolót a Kubernetes-fürtben a kubectl run paranccsal. Adja meg az alkalmazás szolgáltatásnevét a Kubernetesben, valamint a teljes rendszerkép nevét. Például:

   kubectl run gs-spring-boot-docker --image=wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

   Ebben a parancsban:

   • A gs-spring-boot-docker parancs után közvetlenül adja meg a run tároló nevét.

   • A --image paraméter a kombinált bejelentkezési kiszolgálót és a rendszerkép nevét adja meg.wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest

3. Tegye elérhetővé a Kubernetes-fürtöt külsőleg a kubectl expose paranccsal. Adja meg a szolgáltatás nevét, az alkalmazás eléréséhez használt nyilvános elérésű TCP-portot, valamint azt a belső célportot, amelyen az alkalmazás figyel. Például:

   kubectl expose pod gs-spring-boot-docker --type=LoadBalancer --port=80 --target-port=8080
   

   Ebben a parancsban:

   • A gs-spring-boot-docker parancs után közvetlenül adja meg a(z) expose pod tároló nevét.

   • A --type paraméter azt határozza meg, hogy a fürt terheléselosztót használ-e.

   • A --port paraméter a 80-ból álló nyilvános TCP-portot adja meg. Ezen a porton érheti el az alkalmazást.

   • A --target-port paraméter a 8080-ás belső TCP-portot adja meg. A terheléselosztó továbbítja a kéréseket az alkalmazásnak ezen a porton.

4. Miután telepítette az alkalmazást a fürtön, kérdezze le a külső IP-címet, és nyissa meg a webböngészőben:

kubectl get services -o=jsonpath='{.items[*].status.loadBalancer.ingress[0].ip}'

Üzembe helyezés a Kubernetes-erőforrásnézettel

1. Válassza a , majd a hozzáadását az erőforrás nézetek bármelyikéből (névterek, számítási feladatok, szolgáltatások, tároló vagy konfiguráció).

   

2. Illessze be a következő YAML-ként:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gs-spring-boot-docker
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gs-spring-boot-docker
     template:
       metadata:
         labels:
           app: gs-spring-boot-docker
       spec:
         containers:
         - name: gs-spring-boot-docker
           image: wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
   

3. A YAML-szerkesztő alján válassza a lehetőséget, majd adja hozzá a-et az alkalmazás üzembe helyezéséhez.

   

   A Deployment üzembe helyezése után, az előző lépéshez hasonlóan válassza a YAML-szerkesztő alján található Hozzáadás lehetőséget a Service üzembe helyezéséhez a következő YAML használatával:

   apiVersion: v1
   kind: Service
   metadata:
     name: gs-spring-boot-docker
   spec:
     type: LoadBalancer
     ports:
     - port: 80
       targetPort: 8080
     selector:
       app: gs-spring-boot-docker
   

4. A YAML-fájl hozzáadása után az erőforrás-megjelenítő megjeleníti a Spring Boot-alkalmazást. A külső szolgáltatás tartalmaz egy csatolt külső IP-címet, így könnyedén megtekintheti az alkalmazást a böngészőben.

   

   

5. Válassza ki a külső IP-címet. Látja, hogy a saját Spring Boot-alkalmazása az Azure-ban fut.

   

Következő lépések

Ha többet szeretne megtudni a Springről és az Azure-ról, lépjen tovább a Spring on Azure dokumentációs központjába.

Tavasz az Azuren

Lásd még:

A Spring Boot Azure-beli használatáról az alábbi cikkben talál további információt:

• Spring Boot-alkalmazás üzembe helyezése Linuxon az Azure App Service

Az Azure Java használatáról további információért tekintse meg az Azure fejlesztőknek Java-val kapcsolatos, valamint az Azure DevOps és Java-val kapcsolatoscímű cikkeket.

További információ a Java-alkalmazások Kubernetesben a Visual Studio Code-tal való üzembe helyezéséről: Visual Studio Code Java-oktatóanyagok.

További információ a Spring Boot on Docker mintaprojektről: Spring Boot on Docker – Első lépések.

Az alábbi hivatkozások további információt nyújtanak a Spring Boot-alkalmazások létrehozásáról:

• Az egyszerű Spring Boot-alkalmazások létrehozásáról további információt a „Spring Initializr” nevű alkalmazásban talál a következő helyen: https://start.spring.io/.

Az alábbi hivatkozások további információt nyújtanak a Kubernetes Azure való használatáról:

• Kubernetes-fürt használatának első lépései az Azure Kubernetes Service

A Kubernetes parancssori felületének használatáról további információt a kubectl felhasználói útmutatójában talál: https://kubernetes.io/docs/reference/kubectl/.

A Kubernetes webhelyén számos cikk található, amelyek a képek magánregisztrációs adatbázisokban való használatát ismertetik:

• Szolgáltatásfiókok konfigurálása podokhoz
• névterek
• Kép lehúzása privát regisztrárból

Az egyéni Docker-rendszerképek Azure való használatára vonatkozó további példákért lásd: Egyéni Docker-rendszerkép használata Azure Web Apphoz Linuxon.

A tárolók Azure Dev Spaces szolgáltatással való közvetlen Azure Kubernetes Service (AKS) iteratív futtatásáról és hibakereséséről további információt a Azure Dev Spaces és Java első lépéseit ismertető cikkben talál.