Wie erstelle ich einen Spring Boot image docker

Docker ist eine der beliebtesten Technologien im Bereich Virtualisierung und Containerisierung. Docker bietet Effizienz und Zuverlässigkeit, indem es Entwicklern ermöglicht, Anwendungen und ihre Abhängigkeiten in leichte, tragbare Behälter zu packen. Eines der beliebtesten Frameworks für die Entwicklung von Java-Anwendungen ist Spring Boot.

Spring Boot - Es ist ein Framework, das die Entwicklung von Java-Anwendungen vereinfacht, indem es eine breite Palette von Tools und Funktionen für die Bereitstellung skalierbarer und stabiler Anwendungen bereitstellt.

In diesem Artikel erfahren Sie, wie Sie erstellen image Docker für Anwendungen, die mit entwickelt wurden Spring Boot. Wir werden uns den Prozess des Verpackens einer Anwendung in einen Container genauer ansehen und sie mit Docker bereitstellen.

Installieren von Docker auf einem Computer

Um mit Docker zu beginnen, müssen Sie es auf Ihrem Computer installieren. Hier ist eine Schritt-für-Schritt-Anleitung:

Schritt 1: Gehen Sie zur offiziellen Docker-Website und laden Sie die Installationsdatei für Ihr Betriebssystem herunter.

Schritt 2: Führen Sie die Installationsdatei aus und folgen Sie den Anweisungen auf dem Bildschirm. Wählen Sie den Ordner aus, in dem Docker installiert werden soll.

Schritt 3: Führen Sie es nach der Installation von Docker aus, um sicherzustellen, dass alles ordnungsgemäß funktioniert. Überprüfen Sie, ob der Docker-Client fehlerfrei gestartet wurde.

Schritt 4: Um Docker ohne die Befehlszeile zu verwenden, installieren Sie eine Docker-GUI wie Docker Desktop für Windows oder Docker Desktop für Mac.

Schritt 5: Geben Sie Ihre Docker Hub-Anmeldeinformationen ein, um ein Docker Hub-Konto zu erstellen. Dadurch können Sie Ihre Docker-Images und -Container speichern und freigeben.

Jetzt haben Sie Docker auf Ihrem Computer installiert und können mit dem Erstellen und Verwenden von Docker-Images und Containern beginnen!

Spring Boot-Abbild wird geladen

Der Prozess zum Erstellen und Verwenden von Docker-Images für Spring Boot-Anwendungen umfasst die folgenden Schritte:

1. Erstellen von Dockerfile- und Dockerfile-Dateien.dockerignore zum Definieren von Abbildeinstellungen und zum Ausschließen von Dateien aus dem Build-Kontext.
2. Erstellen Sie ein Docker-Abbild mit dem Befehl docker build, indem Sie den Pfad zur Dockerfile und das Tag zum Identifizieren des Abbilds angeben.
3. Laden Sie das Image mithilfe des Docker Push-Befehls in einen Docker Hub oder eine private Registrierung hoch.
4. Laden Sie das Image mit dem Befehl docker pull auf die Zielmaschine hoch.

Nachdem Sie das Image auf den Zielcomputer geladen haben, können Sie den Container basierend auf diesem Image mit dem Befehl docker run ausführen. Der Container enthält alle erforderlichen Abhängigkeiten und Einstellungen, damit die Spring Boot-Anwendung erfolgreich ausgeführt wird.

Erstellen einer Dockerfile

Um ein Docker-Image für eine Spring Boot-Anwendung zu erstellen, müssen Sie eine Dockerfile erstellen und konfigurieren. Die Dockerfile enthält Anweisungen zum Erstellen eines Abbilds, zur Konfiguration und den erforderlichen Abhängigkeiten.

Hier ist ein Beispiel für eine einfache Dockerfile für Spring Boot:

FROM openjdk:8

ADD target/myproject.jar myproject.jar

# Parameter, die über Befehlszeilenargumente angegeben werden können

ARG SPRING_PROFILES_ACTIVE=prod

ENV SPRING_PROFILES_ACTIVE $SPRING_PROFILES_ACTIVE

ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/myproject.jar"]

Diese Dockerfile verwendet die folgenden Anweisungen:

FROM: gibt das Basisabbild für das neue Abbild an, in diesem Fall openjdk:8.

ADD: kopiert die myproject-Datei.jar aus dem Zielordner innerhalb des Images.

ARG: legt die Variable SPRING_PROFILES_ACTIVE fest, die beim Erstellen eines Images über Befehlszeilenargumente überschrieben werden kann.

ENV: setzt die Umgebungsvariable SPRING_PROFILES_ACTIVE auf den Wert der Variablen SPRING_PROFILES_ACTIVE.

ENTRYPOINT: gibt den auszuführenden Befehl innerhalb des Containers an.

Nachdem Sie die Dockerfile erstellt haben, müssen Sie den Befehl ausführen docker build erstellen eines Images:

docker build -t myproject .

Wo myproject - der Name des Images und der Punkt bedeutet das aktuelle Verzeichnis.

Das Abbild kann jetzt mit dem Befehl als Container ausgeführt werden docker run:

docker run -p 8080:8080 myproject

Wo -p 8080:8080 legt den Portpfad fest: 8080 für den Container und 8080 für den Hostcomputer, myproject - der Name des Bildes.

Jetzt wird Ihre Spring Boot-Anwendung innerhalb des Docker-Containers ausgeführt und ist unter der folgenden Adresse verfügbar http://localhost:8080 .

Erstellen eines Docker-Images

Hier ist ein Beispiel für eine einfache Dockerfile für eine Spring Boot-Anwendung:

FROM openjdk:8-jdk-alpineVOLUME /tmpARG JAR_FILECOPY $ app.jarENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

* FROM openjdk:8-jdk-alpine - Diese Anweisung gibt das Basisabbild an, auf dem Ihr Abbild basieren soll. In diesem Fall verwenden wir openjdk:8-jdk-alpine, das OpenJDK 8 auf einem leichten Alpine Linux-Betriebssystem enthält.

* VOLUME /tmp - Mit dieser Anweisung wird ein Mount-Punkt für temporäre Dateien erstellt.

* ARG JAR_FILE - Diese Anweisung definiert das JAR_FILE-Argument, das beim Erstellen des Images übergeben wird. Sie müssen den Namen der JAR-Datei an dieses Argument übergeben.

• COPY $ app.jar - Diese Anweisung kopiert die JAR-Datei in das Image und benennt sie in app um.jar.

• ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"] - diese Anweisung definiert einen Einstiegspunkt für Ihre Anwendung. Sie weist Docker auf den Befehl an, den Sie ausführen müssen, um Ihre Anwendung beim Starten des Containers auszuführen.

Um ein Image zu erstellen, speichern Sie diese Dockerfile im Stammverzeichnis Ihres Projekts. Öffnen Sie eine Eingabeaufforderung und navigieren Sie zum Stammverzeichnis des Projekts. Führen Sie dann den folgenden Befehl aus:

docker build -t my-spring-boot-app .

Dieser Befehl erstellt das Abbild und benennt es my-spring-boot-app. Hier. gibt das aktuelle Verzeichnis an, in dem sich die Dockerfile befindet.

Nachdem das Abbild erstellt wurde, können Sie den Container basierend auf diesem Abbild mit dem Befehl ausführen:

docker run -p 8080:8080 my-spring-boot-app

Dieser Befehl führt den Container basierend auf dem my-spring-boot-app-Image aus und bindet Port 8080 des Containers an Port 8080 des Hostcomputers.

Jetzt ist Ihre Spring Boot-Anwendung unter http verfügbar://localhost:8080.

Starten eines Containers

Nachdem wir ein Docker-Image für eine Spring Boot-basierte Anwendung erstellt haben, können wir den Container mit dem Befehl docker run ausführen. Im einfachsten Fall können Sie einfach den folgenden Befehl ausführen:

Wenn wir beispielsweise ein Image namens myapp auf dem Host an Port 8080 ausführen möchten und der Container auf Port 8080 ausgeführt werden soll, können wir den folgenden Befehl ausführen:

docker run -p 8080:8080 myapp

Dadurch wird Port 8080 auf dem Host an Port 8080 innerhalb des Containers gebunden und der Container mit dem myapp-Image gestartet.

Wenn wir möchten, dass der Container im Hintergrund ausgeführt wird (detached mode), können wir das Flag -d hinzufügen :

docker run -d -p 8080:8080 myapp

Der Container wird nun im Hintergrund ausgeführt und Sie können im Terminal weiterarbeiten.

Sie können die laufenden Container mit dem Befehl docker ps anzeigen :

docker ps

Dadurch wird eine Liste der laufenden Container angezeigt, und Sie können Informationen zu jedem Container sehen, einschließlich des Containernamens und des Ports, auf dem er ausgeführt wird.

Beachten Sie, dass Änderungen, die innerhalb des Containers vorgenommen wurden, nach dem Beenden des Containers nicht gespeichert werden, es sei denn, Sie haben den Container so konfiguriert, dass Daten auf externen Volumes gespeichert werden.

Konfiguration des Docker-Containers

Um ein Spring Boot-Docker-Abbild einer Anwendung zu erstellen, müssen Sie eine Dockerfile erstellen und ihre Konfiguration konfigurieren.

Hier ist eine Beispielkonfiguration für eine Dockerfile:

Nachdem Sie eine Dockerfile erstellt und die erforderlichen Anweisungen angegeben haben, können Sie das Docker-Image mit dem Befehl docker build erstellen und den Container mit dem Befehl docker run ausführen.

Mit der Verwaltung und Konfiguration des Docker-Containers können Sie die Anwendung und ihre Abhängigkeiten in einer Sandbox-Umgebung verpacken, was eine einfache Bereitstellung und Skalierung der Anwendung ermöglicht.

Bereitstellen einer Spring Boot-Anwendung in einem Docker-Container

Um eine Spring Boot-Anwendung in einem Docker-Container bereitzustellen, müssen mehrere Schritte ausgeführt werden. In diesem Abschnitt werden die grundlegenden Schritte zum Erstellen und Ausführen eines Docker-Images mit einer Spring Boot-Anwendung erläutert.

1. Erstellen einer Dockerfile Der erste Schritt besteht darin, eine Dockerfile zu erstellen, die Anweisungen zum Erstellen eines Docker-Images enthält. In der Dockerfile müssen Sie das Basisabbild angeben, alle Abhängigkeiten installieren und die Anwendungsdateien in das Docker-Abbild kopieren.
2. Erstellen eines Docker-Images Nachdem Sie eine Dockerfile erstellt haben, müssen Sie den Befehl zum Erstellen des Docker-Images ausführen. Durch Ausführen dieses Befehls wird ein Docker-Abbild erstellt, das alle erforderlichen Abhängigkeiten und Anwendungsdateien enthält.
3. Starten des Docker-Containers Nachdem das Docker-Image erfolgreich erstellt wurde, können Sie den Docker-Container starten, in dem die Spring Boot-Anwendung ausgeführt wird. Um den Container auszuführen, müssen Sie den Befehl docker run ausführen und den Port angeben, auf den die Anwendung zugreifen soll.
4. Überprüfen der Anwendungsintegrität Nachdem Sie den Docker-Container gestartet haben, können Sie die Anwendungsintegrität überprüfen. Öffnen Sie dazu einen Webbrowser und geben Sie die Localhost-Adresse und den Port ein, den Sie beim Starten des Containers angegeben haben. Wenn alles korrekt konfiguriert ist, wird die Seite mit der Spring Boot-Anwendung angezeigt.

Die Implementierung einer Spring Boot-Anwendung in einem Docker-Container vereinfacht den Bereitstellungsprozess, verbessert die Skalierbarkeit und erleichtert die Verwaltung der Anwendung. Docker bietet eine isolierte Laufzeitumgebung und ermöglicht das einfache Verschieben einer Anwendung zwischen verschiedenen Umgebungen.

Testen der Anwendung in Docker

Um eine Anwendung in Docker zu testen, müssen Sie ein Docker-Abbild erstellen, in dem alle erforderlichen Komponenten für die Ausführung der Anwendung und die Ausführung der Tests konfiguriert werden. Anschließend können Sie dieses Abbild in einem Container ausführen und die erforderlichen Tests ausführen.

Einer der Hauptvorteile des Tests in Docker ist die Isolation der Umgebung. In einem Container können Sie eine Testumgebung einrichten und reproduzieren, die mit der Umgebung identisch ist, in der die Anwendung in der Produktionsumgebung ausgeführt wird. Auf diese Weise können Sie potenzielle Probleme und Fehler frühzeitig in der Entwicklung erkennen.

Ein wichtiger Teil des Tests in Docker besteht darin, einen Container einzurichten und auszuführen. Sie können dazu verschiedene Tools verwenden, z. B. Docker Compose oder Dockerfile, die alle erforderlichen Anweisungen zum Erstellen eines Images und zum Ausführen des Containers angeben.

Wenn Sie eine Anwendung in Docker testen, können Sie verschiedene Tools und Frameworks verwenden, um Tests zu schreiben und auszuführen. Zum Beispiel können Sie JUnit und Spring Boot Test Framework zum Testen von Java-Anwendungen verwenden. Es gibt auch viele Tools und Frameworks für andere Programmiersprachen, die in Verbindung mit Docker zum Testen von Anwendungen verwendet werden können.

Daher können Sie die Anwendung in Docker testen, um den Softwareentwicklungsprozess zuverlässiger und effizienter zu gestalten. Mit Docker können Sie die Testumgebung isolieren und den Entwicklungs- und Testprozess der Anwendung auf verschiedenen Plattformen und Konfigurationen vereinfachen.

Optimieren der Größe eines Docker-Images

• Verwenden Sie Alpine Linux- oder BusyBox-Basisabbilder: Diese Images sind minimal und enthalten nur das Nötigste, um den Container zu betreiben. Sie sind klein und eignen sich hervorragend zum Ausführen von Anwendungen auf Spring Boot.
• Stellen Sie sicher, dass Sie einen Multi-Stage-Build verwenden: Multi-Stage Build ermöglicht es Ihnen, den Build-Prozess in mehrere Phasen aufzuteilen, was die Größe des Images erheblich reduzieren kann. Sie können beispielsweise eine Anwendung in einer einzigen Ebene erstellen und sie dann in ein leichteres Basisabbild kopieren, um sie auszuführen.
• Löschen Sie temporäre Dateien und Cache: Temporäre Dateien und der Cache können beim Erstellen eines Images zusätzlichen Speicherplatz belegen. Stellen Sie sicher, dass sie nicht im endgültigen Bild verbleiben. Dies kann beispielsweise durch Hinzufügen des Befehls `RUN rm -rf /tmp/*` oder `RUN apt-get clean` zur Dockerfile erfolgen.
• Vermeiden Sie die Installation und Verwendung nicht verwendeter Abhängigkeiten: Analysieren Sie Ihre Abhängigkeiten und stellen Sie sicher, dass Sie nur die Bibliotheken und Komponenten verwenden, die für die Anwendung erforderlich sind. Vermeiden Sie es, ungenutzte Pakete zu installieren, um das Übergewicht der Images zu vermeiden.
• Verwenden Sie Caching-Strategien beim Erstellen: Docker ermöglicht die Verwendung von Caching beim Erstellen von Images. Verwenden Sie es mit Bedacht, um zu vermeiden, dass Abhängigkeiten bei jedem Build neu installiert und geladen werden.
• Legen Sie einen minimalen Satz von Abhängigkeiten fest: Wenn Sie Abhängigkeiten für Ihre Anwendung installieren, geben Sie nur die gewünschten Versionen an. Installieren Sie nicht alle möglichen Abhängigkeiten, auch wenn sie für einige Funktionen erforderlich sind.

Durch die Verwendung dieser Tipps wird die Größe des Docker-Images reduziert und die Leistung der Anwendung im Container verbessert. Verwenden Sie diese Optimierungen beim Erstellen von Images für Ihre Spring Boot-Anwendungen.