Schnellstart: Erstellen und Pushen von Containerimages der Java Spring Boot-App in Azure Container Registry

2024-10-16

In diesem Schnellstart erfahren Sie, wie Sie Containerimages der Java Spring Boot-App erstellen und diese mithilfe von Maven und Jib per Push an Azure Container Registry übertragen. Maven und Jib sind eine Möglichkeit zur Nutzung von Entwicklertools für die Interaktion mit einer Azure-Containerregistrierung.

Voraussetzungen

Ein Azure-Abonnement. Wenn Sie noch kein Azure-Abonnement besitzen, können Sie sich für ein kostenloses Azure-Konto registrieren oder Ihre MSDN-Abonnentenvorteile aktivieren.
Ein unterstütztes Java Development Kit (JDK). Weitere Informationen zu verfügbaren JDKs für die Entwicklung in Azure finden Sie im Artikel zur Java-Unterstützung in Azure und Azure Stack.
Die Azure CLI
Das Erstellungstool Maven von Apache (Version 3 oder höher)
Einen Git-Client
Einen Docker-Client
Das Hilfsprogramm für ACR-Docker-Anmeldeinformationen

Erstellen und Kompilieren einer Spring Boot-Anwendung in Docker

Im Folgenden werden die Schritte zum Erstellen einer containerisierten Java Spring Boot-Webanwendung und zum lokalen Testen dieser Anwendung beschrieben.

Geben Sie in der Eingabeaufforderung den folgenden Befehl ein, um das Beispielprojekt Spring Boot on Docker Getting Started zu klonen.
```
git clone https://github.com/spring-guides/gs-spring-boot-docker.git
```
Wechseln Sie in das Verzeichnis mit dem abgeschlossenen Projekt.
```
cd gs-spring-boot-docker/complete
```
Verwenden Sie Maven zum Erstellen und Ausführen der Beispiel-App.
```
mvn package spring-boot:run
```
Testen Sie die Web-App durch Navigieren zu http://localhost:8080 oder mit dem folgenden curl-Befehl:
```
curl http://localhost:8080
```

Die folgende Meldung sollte angezeigt werden: Hello Docker World!

Erstellen einer Azure Container Registry-Instanz über die Azure-Befehlszeilenschnittstelle

Als Nächstes erstellen Sie mithilfe der folgenden Schritte eine Azure-Ressourcengruppe und die ACR-Instanz:

Melden Sie sich mithilfe des folgenden Befehls bei Ihrem Azure-Konto an:
```
az login
```
Geben Sie an, welches Azure-Abonnement verwendet werden soll:
```
az account set -s <subscription ID>
```
Erstellen Sie eine Ressourcengruppe für die in diesem Tutorial verwendeten Azure-Ressourcen. Im folgenden Befehl müssen Sie die Platzhalter durch Ihren eigenen Ressourcennamen und einen Speicherort wie eastus ersetzen.
```
az group create \
    --name=<your resource group name> \
    --location=<location>
```
Erstellen Sie mit dem folgenden Befehl eine private Azure-Containerregistrierung in der Ressourcengruppe. Ersetzen Sie die Platzhalter durch tatsächliche Werte. Die Beispiel-App wird in diesem Tutorial in späteren Schritten als Docker-Image per Push in diese Registrierung übertragen.
```
az acr create \
    --resource-group <your resource group name> \
    --location <location> \
    --name <your registry name> \
    --sku Basic
```

Pushen der App in die Containerregistrierung über Jib

Abschließend aktualisieren Sie Ihre Projektkonfiguration und verwenden die Eingabeaufforderung, um Ihr Image zu erstellen und bereitzustellen.

Hinweis

Der Docker-Daemon muss ausgeführt werden, damit Sie sich bei der eben erstellten Azure-Containerregistrierung anmelden können. Wenn Sie Docker auf Ihrem Computer installieren möchten, finden Sie hier die offizielle Docker-Dokumentation.

Melden Sie sich mit dem folgenden Befehl über die Azure-Befehlszeilenschnittstelle bei Ihrer Azure Container Registry-Instanz an. Ersetzen Sie den Platzhalter durch den Namen Ihrer eigenen Registrierung.
```
az config set defaults.acr=<your registry name>
az acr login
```
Der Befehl az config legt den Standardregistrierungsnamen fest, der mit den az acr-Befehlen verwendet wird.
Navigieren Sie zum Verzeichnis des abgeschlossenen Projekts für Ihre Spring Boot-Anwendung (z.B.„C:\SpringBoot\gs-spring-boot-docker\complete“ oder „ /users/robert/SpringBoot/gs-spring-boot-docker/complete“), und öffnen Sie die Datei pom.xml mit einem Text-Editor.
Aktualisieren Sie die Auflistung <properties> in der Datei pom.xml mit der folgenden XML. Ersetzen Sie den Platzhalter durch Ihren Registrierungsnamen, und fügen Sie eine Eigenschaft vom Typ <jib-maven-plugin.version> mit dem Wert 2.2.0 oder eine neuere Version von jib-maven-plugin hinzu.
```
<properties>
   <docker.image.prefix><your registry name>.azurecr.io</docker.image.prefix>
   <java.version>1.8</java.version>
   <jib-maven-plugin.version>2.2.0</jib-maven-plugin.version>
</properties>
```
Aktualisieren Sie die Sammlung <plugins> in der Datei pom.xml, sodass das <plugin>-Element einen Eintrag für jib-maven-plugin enthält, wie im Beispiel unten gezeigt. Beachten Sie, dass ein Basisimage aus der Microsoft Container Registry (MCR) „mcr.microsoft.com/openjdk/jdk:11-ubuntu“ verwendet wird, das eine offiziell unterstützte JDK-Version für Azure enthält. Weitere MCR-Basisimages mit offiziell unterstützten JDKs finden Sie unter Installieren des Microsoft Build von 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}/${project.artifactId}</image>
     </to>
  </configuration>
</plugin>
```
Navigieren Sie zum Verzeichnis des abgeschlossenen Projekts für Ihre Spring Boot-Anwendung, und führen Sie den folgenden Befehl aus, um das Image zu erstellen und per Push in die Registrierung zu übertragen:
```
az acr login && mvn compile jib:build
```

Hinweis

Aus Sicherheitsgründen sind die mit az acr login erstellten Anmeldeinformationen nur 1 Stunde lang gültig. Wenn Sie den Fehler 401 – Nicht autorisiert erhalten, können Sie den Befehl az acr login -n <your registry name> nochmals ausführen, um sich noch mal zu authentifizieren.

Verifizieren des Containerimages

Glückwunsch! Sie haben nun Ihre in Azure erstellte Java-App in einem Container, der JDK unterstützt, in Ihre ACR-Instanz gepusht. Jetzt können Sie das Image testen, indem Sie es im Azure App Service bereitstellen oder es mit einem Befehl (in dem die Platzhalter ersetzt sind) auf die lokale Ebene pullen:

docker pull <your registry name>.azurecr.io/gs-spring-boot-docker

Nächste Schritte

Weitere Versionen der offiziellen, von Microsoft unterstützten Java-Basisimages finden Sie unter:

Installieren des Microsoft-Builds von OpenJDK

Weitere Informationen zu Spring und Azure finden Sie im Dokumentationscenter zu Spring in Azure.

Spring Framework in Azure

Weitere Ressourcen

Weitere Informationen finden Sie in den folgenden Ressourcen:

Azure für Java-Entwickler
Working with Azure DevOps and Java (Arbeiten mit Azure DevOps und Java)
Spring Boot on Docker Getting Started (Erste Schritte mit Spring Boot in Docker)
Spring Initializr
Bereitstellen von Spring Boot-Anwendungen in Azure App Service
Verwenden eines benutzerdefinierten Docker-Images für Azure-Web-Apps unter Linux

Freigeben über