Distribuera Spring Boot-programmet till Azure Kubernetes Service

Not

För Spring Boot-program använder du Azure Container Apps. Du kan dock fortfarande använda Azure Kubernetes Service som mål. Mer information finns i Välj rätt Azure-tjänster för dina Java-program.

Den här handledningen visar hur du använder Kubernetes och Docker för att utveckla och distribuera en Spring Boot-applikation till Microsoft Azure. Mer specifikt använder du Spring Boot för programutveckling, Kubernetes för containerdistribution och Azure Kubernetes Service (AKS) som värd för ditt program.

Kubernetes och Docker är lösningar med öppen källkod som hjälper utvecklare att automatisera distribution, skalning och hantering av sina program som körs i containrar.

Förutsättningar

En Azure prenumeration. Om du inte redan har en Azure prenumeration aktiverar du dina MSDN-prenumerantförmåner eller registrerar dig för ett kostnadsfritt Azure konto.
Azure Command-Line Interface (CLI).
Ett Java Development Kit (JDK) som stöds. Mer information om de JDK:er som är tillgängliga för användning när du utvecklar i Azure finns i Java-support på Azure och Azure Stack.
Apaches Maven build-verktyg (version 3).
En Git-klient.
En Docker--klient.
ACR Docker-referenshjälpverktyg.

Not

På grund av virtualiseringskraven i den här handledningen kan du inte följa stegen i den här artikeln på en virtuell dator. Du måste använda en fysisk dator med virtualiseringsfunktioner aktiverade.

Skapa Webbappen Spring Boot på Docker Komma igång

Följande steg beskriver hur du skapar ett Spring Boot-webbprogram och testar det lokalt.

Öppna en kommandotolk och skapa en lokal katalog för att lagra ditt program och ändra till den katalogen. till exempel:
```
mkdir C:\SpringBoot
cd C:\SpringBoot
```
--eller--
```
mkdir /users/$USER/SpringBoot
cd /users/$USER/SpringBoot
```

Kopiera Spring Boot på Docker Kom igång exempelprojekt i katalogen.

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

Byt katalog till det slutförda projektet.
```
cd gs-spring-boot-docker
cd complete
```
Använd Maven för att skapa och köra exempelappen.
```
mvn package spring-boot:run
```
Testa webbappen genom att bläddra till http://localhost:8080eller med följande curl kommando:
```
curl http://localhost:8080
```
Följande meddelande visas: Hello Docker World

Skapa ett Azure Container Registry med hjälp av Azure CLI

Öppna kommando-prompten.
Logga in på ditt Azure-konto:
```
az login
```
Välj din Azure prenumeration:
```
az account set -s <YourSubscriptionID>
```
Skapa en resursgrupp för de Azure-resurser som används i den här självstudien.
```
az group create --name=wingtiptoys-kubernetes --location=eastus
```
Skapa ett privat Azure-containerregister i resursgruppen. Handledningen skickar exempelappen som en Docker-avbildning till en register i senare skeden. Ersätt wingtiptoysregistry med ett unikt namn för registret.
```
az acr create --resource-group wingtiptoys-kubernetes --location eastus \
 --name wingtiptoysregistry --sku Basic
```

Skicka appen till containerregistret via Jib

Logga in på din Azure Container Registry från Azure CLI.

# 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

Öppna filenpom.xml med en textredigerare, till exempel Visual Studio Code.
```
code pom.xml
```

Uppdatera <properties>-samlingen i filen pom.xml med registernamnet för ditt Azure Container Registry och den senaste versionen av jib-maven-plugin.

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

Uppdatera <plugins>-samlingen i pom.xml-filen så att <plugin>-elementet innehåller en post för jib-maven-plugin, enligt följande exempel. Använd en basavbildning från Microsoft Container Registry (MCR): mcr.microsoft.com/openjdk/jdk:11-ubuntu, som innehåller en officiellt stödd JDK för Azure. Andra MCR-basavbildningar med officiellt stödda JDK:er finns i Installera Microsoft Build för OpenJDK.
```
<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>
```
Gå till den slutförda projektkatalogen för Spring Boot-programmet och kör följande kommando för att skapa avbildningen och skicka avbildningen till registret:
```
az acr login && mvn compile jib:build
```

Not

Av säkerhetsskäl är autentiseringsuppgifterna som du skapar med az acr login giltiga i en timme. Om du ser felet 401 Unauthorized, kör kommandot az acr login --name <your registry name> igen för att autentisera på nytt. Om du ser ett Read timed out fel kan du prova att öka tidsgränserna med mvn -Djib.httpTimeout=7200000 jib:dockerBuildeller använda -Djib.httpTimeout=0 för en oändlig timeout.

Skapa ett Kubernetes-kluster på AKS med hjälp av Azure CLI

Skapa ett Kubernetes-kluster i Azure Kubernetes Service. Följande kommando skapar ett Kubernetes-kluster i wingtiptoys-kubernetes resursgruppen, med wingtiptoys-akscluster som klusternamn, med Azure Container Registry (ACR) wingtiptoysregistry kopplat och wingtiptoys-kubernetes som DNS-prefix:
```
az aks create --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster \
 --attach-acr wingtiptoysregistry \
 --dns-name-prefix=wingtiptoys-kubernetes --generate-ssh-keys
```
Det här kommandot kan ta en stund att slutföra.
Installera kubectl med hjälp av Azure CLI. Linux-användare kan behöva prefixet för det här kommandot eftersom sudo det distribuerar Kubernetes CLI till /usr/local/bin.
```
az aks install-cli
```
Ladda ned klusterkonfigurationsinformationen så att du kan hantera klustret från Kubernetes-webbgränssnittet och kubectl.
```
az aks get-credentials --resource-group=wingtiptoys-kubernetes --name=wingtiptoys-akscluster
```

Distribuera avbildningen till ditt Kubernetes-kluster

I den här självstudien distribuerar du appen genom att använda kubectl, och sedan kan du utforska distributionen via Kubernetes-webbgränssnittet.

Distribuera med kubectl

Öppna kommando-prompten.
Kör containern i Kubernetes-klustret med hjälp av kommandot kubectl run. Ange ett tjänstnamn för din app i Kubernetes och det fullständiga bildnamnet. Till exempel:
```
kubectl run gs-spring-boot-docker --image=wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest
```
I det här kommandot:
- Du anger containernamnet gs-spring-boot-docker direkt efter run kommandot.
- Parametern --image anger den kombinerade inloggningsservern och avbildningsnamnet som wingtiptoysregistry.azurecr.io/gs-spring-boot-docker:latest.
Exponera Kubernetes-klustret externt med hjälp av kommandot kubectl expose. Ange tjänstnamnet, den offentliga TCP-port som används för att komma åt appen och den interna målport som appen lyssnar på. Till exempel:
```
kubectl expose pod gs-spring-boot-docker --type=LoadBalancer --port=80 --target-port=8080
```
I det här kommandot:
- Du anger containernamnet gs-spring-boot-docker direkt efter expose pod kommandot.
- Parametern --type anger att klustret använder lastbalanserare.
- Parametern --port anger den offentliga TCP-porten på 80. Du kommer åt appen på den här porten.
- Parametern --target-port anger den interna TCP-porten 8080. Lastbalanseraren vidarebefordrar begäranden till din app på den här porten.
När du har distribuerat appen till klustret frågar du den externa IP-adressen och öppnar den i webbläsaren:

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

Bläddra bland exempelappen i Azure

Distribuera med Kubernetes-resursvyn

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

Klistra in följande YAML:

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

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

När du har distribuerat Deployment, precis som i föregående steg, väljer du Lägg till längst ned i YAML-redigeraren för att distribuera Service med hjälp av följande YAML:
```
apiVersion: v1
kind: Service
metadata:
  name: gs-spring-boot-docker
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: gs-spring-boot-docker
```
När du har lagt till YAML-filen visar resursvisningsprogrammet ditt Spring Boot-program. Den externa tjänsten innehåller en länkad extern IP-adress så att du enkelt kan visa programmet i webbläsaren.
Välj Extern IP. Du ser ditt Spring Boot-program som körs på Azure.

Nästa steg

Om du vill veta mer om Spring och Azure fortsätter du till dokumentationscentret för Spring on Azure.

Spring på Azure

Se även

Mer information om hur du använder Spring Boot på Azure finns i följande artikel:

Distribuera ett Spring Boot-program till Linux på Azure App Service

Mer information om hur du använder Azure med Java finns i Azure for Java Developers och Working with Azure DevOps and Java.

Mer information om hur du distribuerar ett Java-program till Kubernetes med Visual Studio Code finns i Visual Studio Code Java-självstudier.

Mer information om exempelprojektet Spring Boot on Docker finns i Spring Boot on Docker Getting Started.

Följande länkar innehåller mer information om hur du skapar Spring Boot-program:

Mer information om hur du skapar ett enkelt Spring Boot-program finns i Spring Initializr på https://start.spring.io/.

Följande länkar innehåller mer information om hur du använder Kubernetes med Azure:

Kom igång med ett Kubernetes-kluster i Azure Kubernetes Service

Mer information om hur du använder Kubernetes kommandoradsgränssnitt finns i kubectl-användarhandboken på https://kubernetes.io/docs/reference/kubectl/.

Kubernetes webbplats innehåller flera artiklar som diskuterar hur du använder bilder i privata register:

Fler exempel på hur du använder anpassade Docker-avbildningar med Azure finns i Använda en anpassad Docker-avbildning för Azure Web App i Linux.

Mer information om hur du iterativt kör och felsöker containrar direkt i Azure Kubernetes Service (AKS) med Azure Dev Spaces finns i Komma igång med Azure Dev Spaces med Java.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-09-03