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

Feljegyzés

Spring Boot-alkalmazások esetén az Azure Spring Apps használatát javasoljuk. Azonban továbbra is dönthet úgy, hogy az Azure Kubernetes Service-t használja célként. További információ: A Java-alkalmazásokhoz megfelelő Azure-szolgáltatások kiválasztása.

Ez az oktatóanyag végigvezeti a Kubernetes és a Docker kombinálásán egy Spring Boot-alkalmazás fejlesztéséhez és a Microsoft Azure-ban való üzembe helyezéséhez. Pontosabban a Spring Bootot használhatja alkalmazásfejlesztéshez, a Kubernetes-t a tárolók üzembe helyezéséhez, az Azure Kubernetes Service-t (AKS) pedig az alkalmazás üzemeltetéséhez.

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

Előfeltételek

• Egy Azure-előfizetés. Ha még nincs Azure-előfizetése, aktiválhatja MSDN-előfizetői előnyeit, vagy regisztrálhat egy ingyenes Azure-fiókot.
• Az Azure parancssori felület (CLI).
• Egy támogatott Java fejlesztői készlet (JDK). Az Azure-beli fejlesztés során használható JDK-król további információt az Azure-ban és az Azure Stackben elérhető Java-támogatásban talál.
• Az Apache Maven buildelőeszköz (3-as verzió).
• Egy Git-ügyfél.
• Egy Docker-ügyfél.
• Az ACR Docker hitelesítőadat-segéd.

Feljegyzés

A jelen oktatóanyag virtualizálási követelményei miatt nem fogja tudni követni és virtuális gépeken alkalmazni a cikkben leírt egyes lépéseket. Egy olyan fizikai számítógépet kell használnia, amelyen a virtualizálási funkciók engedélyezve vannak.

A Spring Boot on Docker – Első lépések webalkalmazás létrehozása

A következő lépések végigvezetik egy Spring Boot-webalkalmazás összeállításán és helyszíni tesztelésén.

1. Nyisson meg egy parancssort, és hozzon létre egy helyi könyvtárat az alkalmazás tárolásához, majd 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 Docker Getting Started Spring Boot-mintaprojektet ebbe a könyvtárba.

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

3. Váltsa a könyvtárat a befejezett projektre.

   cd gs-spring-boot-docker
   cd complete
   

4. Használja a Mavent a mintaalkalmazás összeállításához és futtatásához.

   mvn package spring-boot:run
   

5. Tesztelje a webalkalmazást. Ehhez lépjen a http://localhost:8080 címre, vagy a használja a curl parancsot:

   curl http://localhost:8080
   

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

   

Azure Container Registry létrehozása az Azure CLI-vel

1. Nyisson meg egy parancssorablakot.

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

   az login
   

3. Válassza ki az 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ások számára.

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

5. Hozzon létre egy privát Azure Container Registryt az erőforráscsoportban. Az oktatóanyag a mintaalkalmazást Docker-lemezképként küldi le ennek a regisztrációs adatbázisnak a későbbi lépésekben. Cserélje le az wingtiptoysregistry elemet az adatbázis egyedi nevére.

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

Az alkalmazás leküldése a regisztrációs adatbázisnak a Jibbel

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

   # 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 a Visual Studio Code-ot.

   code pom.xml
   

3. Frissítse a <properties> gyűjteményt a pom.xml fájlban az Azure Container Registry regisztrációs adatbázisának nevével, valamint 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 pom.xml fájlban lévő <plugins> gyűjteményt, hogy a <plugin> tartalmazzon egy bejegyzést a jib-maven-plugin számára, ahogyan a következő példa mutatja. Vegye figyelembe, hogy a Microsoft Container Registry (MCR) egy alaprendszerképét használjuk: mcr.microsoft.com/openjdk/jdk:11-ubuntu. Ez tartalmaz egy hivatalosan támogatott JDK-t az Azure-hoz. A hivatalosan támogatott JDK-kkal rendelkező többi MCR-alaprendszerképről lásd: Az OpenJDK Microsoft buildjének 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. Lépjen a Spring Boot-alkalmazás befejezett projektkönyvtárába, és futtassa a következő parancsot a lemezkép elkészítéséhez, majd a könyvtárba való leküldéséhez:

   az acr login && mvn compile jib:build
   

Feljegyzés

Az Azure Cli és az Azure Container Registry biztonsági aggályai miatt a létrehozott az acr login hitelesítő adatok 1 órán át érvényesek. Ha a 401-es nem engedélyezett hiba jelenik meg, újra futtathatja a parancsot az az acr login --name <your registry name> újrahitelesítéshez. Ha olvasási időtúllépésihibát lát, megpróbálhatja növelni az időtúllépéseket a végtelen -Djib.httpTimeout=0 időtúllépésselmvn -Djib.httpTimeout=7200000 jib:dockerBuild.

Kubernetes-fürt létrehozása az AKS-en az Azure CLI-vel

1. Hozzon létre egy Kubernetes-fürtöt az Azure Kubernetes Service-ben. A következő parancs létrehoz egy kubernetes-fürtöt a wingtiptoys-kubernetes erőforráscsoportban, a wingtiptoys-akscluster a fürt neveként, csatolva az Azure Container Registryt (ACR), wingtiptoysregistry a wingtiptoys-kubernetes pedig 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 hosszabb időt is igénybe vehet.

2. Telepítse a kubectl elemet az Azure CLI-vel. Előfordulhat, hogy a Linux-felhasználóknak el kell látniuk a parancsot a sudo előtaggal, mivel azzal a Kubernetes CLI telepítésére a /usr/local/bin helyen kerül sor.

   az aks install-cli
   

3. Töltse le a fürt konfigurációs adatait, hogy kezelni tudja a fürtöt a Kubernetes webes felületén és a kubectl keretein belül.

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

A lemezkép üzembe helyezése a Kubernetes-fürtön

Ez az oktatóanyag üzembe helyezi az alkalmazást a Kubernetes kubectlwebes felületén keresztül, majd lehetővé teszi az üzembe helyezés megismerését.

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

1. Nyisson meg egy parancssorablakot.

2. Futtassa a tárolót a Kubernetes-fürtben a kubectl run paranccsal. Adjon szolgáltatásnevet az alkalmazásnak a Kubernetes-ben és a teljes lemezkép nevében. Példa:

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

   Ebben a parancsban:

   • A tároló neve (gs-spring-boot-docker) közvetlenül a run parancs után van megadva

   • Az --imagewingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest értékként adja meg az összevont bejelentkezési kiszolgáló és a lemezkép nevét

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

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

   Ebben a parancsban:

   • A tároló neve (gs-spring-boot-docker) közvetlenül a expose pod parancs után van megadva.

   • A --type paraméter megszabja, hogy a fürt terheléselosztót használ.

   • A --port paraméter megszabja, hogy a nyilvános TCP-port a 80. Ezen a porton fér hozzá az alkalmazáshoz.

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

4. Miután üzembe helyezte az alkalmazást a fürtön, kérdezze le a külső IP-címet, majd 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 Hozzáadás lehetőséget bármelyik erőforrásnézetből (névtér, számítási feladatok, szolgáltatások és bejövő forgalom, Tárolás vagy konfiguráció).

   

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

   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. Válassza a YAML-szerkesztő alján található Hozzáadás lehetőséget az alkalmazás üzembe helyezéséhez.

   

   A fentihez hasonlóan a DeploymentYAML-szerkesztő alján található Hozzáadás elemet választva helyezze üzembe Service a következő YAML-et:

   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 a Külső IP-címet. Ezután látni fogja, hogy a Spring Boot-alkalmazás fut az Azure-ban.

   

Következő lépések

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

A Spring használata az Azure-ban

Lásd még

A Spring Boot Azure-beli használatával kapcsolatban további információt az alábbi cikkben olvashat:

• Spring Boot-alkalmazás üzembe helyezése Linuxon Azure-alkalmazás szolgáltatáson

Az Azure a Javával való együttes használatáról további információt az Azure Java-fejlesztőknek és Az Azure DevOps és a Java használata című cikkben találhat.

További információ Java-alkalmazások a Kubernetes-ben való, a Visual Studio Code-dal történő üzembe helyezéséről: Visual Studio Code – Java-oktatóanyagok.

További információ a Spring Boot Dockeres mintaprojektjéről: Spring Boot a Dockerben – Első lépések.

A következő hivatkozások további információt nyújtanak Spring boot-alkalmazások létrehozásáról:

• További információt egy egyszerű Spring Boot-alkalmazás létrehozásáról a Spring Initializr oldalán találhat: https://start.spring.io/.

A következő hivatkozások további információt nyújtanak a Kubernetes az Azure-ral való használatáról:

• Kubernetes-fürt létrehozása az Azure Kubernetes Service-ben – első lépések

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

A Kubernetes webhelye számos olyan cikket tartalmaz, amelyek a privát regisztrációs adatbázisokban található rendszerképek használatát ismertetik:

• Szolgáltatásfiókok konfigurálása podokhoz
• Névterek
• Lemezkép lekérése egy privát beállításjegyzékből

További példákat egyéni Docker-lemezképek az Azure-ral való használatáról az Egyéni Docker-lemezkép használata az Azure Web Apphoz Linux rendszeren című cikkben találhat.

További információ a tárolók az Azure Kubernetes Service-ben történő, az Azure Dev Spaces segítségével való iteratív futtatásáról és hibakereséséről: Azure Dev Spaces és Java – első lépések