Wie man eine Java EE-Webanwendung in einem Docker-Container erstellt

Einführung

In diesem Tutorial lernen Sie, wie Sie eine Java EE-Webanwendung erstellen und in einem Docker-Container bereitstellen. Docker ist eine beliebte Containerisierungstechnologie (Containerization Platform), die es Ihnen ermöglicht, Ihre Anwendung und ihre Abhängigkeiten in eine einzelne, portierbare Einheit zu verpacken. Dies erleichtert die Entwicklung, das Testen und die Bereitstellung Ihrer Software. Am Ende dieses Leitfadens werden Sie besser verstehen, wie Sie Docker nutzen können, um die Entwicklung und Bereitstellung Ihrer Java EE-Webanwendungen zu rationalisieren.

Einführung in Docker und Java EE

Was ist Docker?

Docker ist eine Open-Source-Plattform, die es Entwicklern ermöglicht, Anwendungen in Containern zu erstellen, bereitzustellen und auszuführen. Container sind leichte, eigenständige und ausführbare Softwarepakete, die alles enthalten, was zur Ausführung einer Anwendung benötigt wird, einschließlich des Codes, der Laufzeitumgebung, der Systemtools und der Bibliotheken. Docker vereinfacht den Prozess der Erstellung, Bereitstellung und Verwaltung von Anwendungen, indem es eine konsistente und zuverlässige Umgebung auf verschiedenen Rechenplattformen bietet.

Was ist Java EE?

Java EE (Java Enterprise Edition) ist eine Sammlung von Java-APIs und Laufzeitumgebungen zur Entwicklung und Ausführung von groß angelegten Unternehmensanwendungen. Es bietet einen Standard-Satz von Diensten, APIs und Protokollen zur Erstellung verteilter, mehrschichtiger Java-Anwendungen. Java EE umfasst Funktionen wie Web Services, Sicherheit, Transaktionsverwaltung und mehr, was es zu einer beliebten Wahl für die Entwicklung von Unternehmens-Webanwendungen macht.

Vorteile der Containerisierung von Java EE-Anwendungen mit Docker

Die Containerisierung von Java EE-Anwendungen mit Docker bietet mehrere Vorteile:

Konsistente Bereitstellung: Docker-Container stellen sicher, dass die Anwendung und ihre Abhängigkeiten zusammen verpackt werden, was eine konsistente und zuverlässige Umgebung auf verschiedenen Rechenplattformen gewährleistet.
Skalierbarkeit: Docker erleichtert es, Anwendungen je nach Bedarf zu skalieren, was die Gesamtleistung des Systems und die Ressourcennutzung verbessert.
Isolation: Container bieten ein hohes Maß an Isolation und stellen sicher, dass die Abhängigkeiten oder die Konfiguration einer Anwendung nicht mit anderen Anwendungen auf demselben Host interferieren.
Portabilität: Docker-Container können einfach zwischen verschiedenen Umgebungen (z. B. Entwicklung, Staging, Produktion) verschoben werden, ohne dass komplexe Konfigurationsänderungen erforderlich sind.
Effizienz: Docker-Container sind leichtgewichtig und nutzen im Vergleich zu traditionellen virtuellen Maschinen weniger Ressourcen, was sie effizienter für die Bereitstellung und Ausführung von Anwendungen macht.

Erste Schritte mit Docker und Java EE

Um mit Docker und Java EE zu beginnen, müssen Sie Docker auf Ihrem System installiert haben. Sie können Docker von der offiziellen Docker-Website (https://www.docker.com/get-started) herunterladen und installieren. Sobald Docker installiert ist, können Sie beginnen, Ihre Java EE-Anwendungen in Docker-Containern zu erstellen und auszuführen.

graph TD
    A[Java EE Application] --> B[Docker Container]
    B --> C[Docker Host]
    C --> D[Docker Engine]
    D --> E[Host Operating System]

Im nächsten Abschnitt gehen wir näher auf den Prozess der Entwicklung einer Java EE-Webanwendung und ihrer Containerisierung mit Docker ein.

Entwicklung einer Java EE-Webanwendung

Erstellen einer Java EE-Webanwendung

Um eine Java EE-Webanwendung zu entwickeln, können Sie eine integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) wie IntelliJ IDEA, Eclipse oder NetBeans verwenden. Diese IDEs bieten Tools und Frameworks, um den Entwicklungsprozess zu vereinfachen.

Hier ist ein Beispiel, wie Sie eine einfache Java EE-Webanwendung mit Jakarta EE (früher Java EE) erstellen können:

Erstellen eines neuen Projekts: Erstellen Sie in Ihrer IDE ein neues Maven- oder Gradle-Projekt und wählen Sie die Projektvorlage "Java EE" oder "Jakarta EE".
Hinzufügen von Abhängigkeiten: Fügen Sie in der pom.xml- oder build.gradle-Datei Ihres Projekts die erforderlichen Abhängigkeiten für Ihre Java EE-Webanwendung hinzu, wie z. B. jakarta.servlet-api, jakarta.faces-api und alle anderen Bibliotheken, die Sie verwenden möchten.
Entwicklung der Anwendungslogik: Erstellen Sie Ihre Java-Klassen, JSF (JavaServer Faces)- oder Servlet-Komponenten sowie alle anderen erforderlichen Dateien, um die Geschäftslogik Ihrer Webanwendung zu implementieren.
Konfiguration der Webanwendung: Erstellen Sie in Ihrem Projekt eine web.xml-Datei (oder verwenden Sie Annotations), um das Servlet, die Filter und andere Einstellungen der Webanwendung zu konfigurieren.
Erstellen und Testen der Anwendung: Verwenden Sie die Build- und Ausführungsfunktionen Ihrer IDE, um Ihre Java EE-Webanwendung lokal zu kompilieren, zu verpacken und zu testen.

graph TD
    A[Java EE Web Application] --> B[Jakarta EE API]
    B --> C[Servlet Container]
    C --> D[Application Server]
    D --> E[Host Operating System]

Bereitstellen der Java EE-Webanwendung

Sobald Sie Ihre Java EE-Webanwendung entwickelt haben, können Sie sie auf einem Anwendungsserver wie Apache Tomcat, WildFly oder GlassFish bereitstellen. Der Bereitstellungsprozess umfasst typischerweise die folgenden Schritte:

Verpacken der Anwendung: Verwenden Sie Ihre IDE oder ein Build-Tool (z. B. Maven, Gradle), um Ihre Java EE-Webanwendung in eine WAR-Datei (Web Application Archive) zu verpacken.
Bereitstellen der WAR-Datei: Kopieren Sie die WAR-Datei in das Bereitstellungsverzeichnis Ihres Anwendungsservers oder verwenden Sie die Verwaltungs-Konsole des Servers, um die Anwendung bereitzustellen.
Starten des Anwendungsservers: Wenn der Anwendungsserver noch nicht läuft, starten Sie ihn, um Ihre Java EE-Webanwendung bereitzustellen und auszuführen.

Nach der Bereitstellung der Anwendung können Sie sie über einen Webbrowser über die entsprechende URL (z. B. http://localhost:8080/your-app) zugreifen.

Nachdem Sie nun ein grundlegendes Verständnis der Entwicklung einer Java EE-Webanwendung haben, gehen wir zum nächsten Schritt über: die Containerisierung und Bereitstellung der Anwendung mit Docker.

Containerisierung und Bereitstellung der Java EE-Anwendung

Erstellen eines Docker-Images für die Java EE-Webanwendung

Um Ihre Java EE-Webanwendung mit Docker zu containerisieren, müssen Sie ein Docker-Image erstellen. Hier ist ein Beispiel für eine Dockerfile, die Sie verwenden können:

## Use a base image with Java and an application server
FROM openjdk:11-jdk-slim as builder

## Copy the Java EE web application WAR file into the container
COPY target/*.war /app.war

## Use a lightweight application server image as the final image
FROM tomcat:9.0-jdk11-openjdk-slim

## Copy the WAR file into the Tomcat webapps directory
COPY --from=builder /app.war /usr/local/tomcat/webapps/

## Expose the default Tomcat port
EXPOSE 8080

## Start the Tomcat server
CMD ["catalina.sh", "run"]

In diesem Beispiel verwenden wir einen mehrstufigen Build-Prozess. In der ersten Stufe, builder, wird die WAR-Datei der Java EE-Webanwendung in den Container kopiert. Die zweite Stufe, tomcat:9.0-jdk11-openjdk-slim, ist ein leichtgewichtiges Tomcat-Image, das als finales Image dient. Die WAR-Datei wird dann in das Tomcat-Webapps-Verzeichnis kopiert, und der Tomcat-Server wird gestartet.

Erstellen und Ausführen des Docker-Images

Um das Docker-Image zu erstellen, führen Sie den folgenden Befehl im Verzeichnis aus, in dem sich die Dockerfile befindet:

docker build -t my-java-ee-app .

Dadurch wird ein Docker-Image mit dem Tag my-java-ee-app erstellt.

Um den Docker-Container auszuführen, verwenden Sie den folgenden Befehl:

docker run -p 8080:8080 my-java-ee-app

Dadurch wird der Docker-Container gestartet, und der Port 8080 des Containers wird auf den Port 8080 des Hosts gemappt. Dadurch können Sie die Java EE-Webanwendung über Ihren Webbrowser unter http://localhost:8080 zugreifen.

Bereitstellen der Java EE-Anwendung in einem Docker Swarm oder Kubernetes

Sobald Sie Ihre Java EE-Webanwendung containerisiert und in einem Docker-Container ausgeführt haben, können Sie sie in einem Docker Swarm- oder Kubernetes-Cluster für Skalierbarkeit und Hochverfügbarkeit bereitstellen.

In einem Docker Swarm können Sie einen Dienst mit dem Befehl docker service create erstellen und dabei das Docker-Image und alle erforderlichen Konfigurationsoptionen angeben.

In einem Kubernetes-Cluster können Sie eine Deployment, einen Service und andere Kubernetes-Ressourcen erstellen, um die Bereitstellung und Skalierung Ihrer Java EE-Webanwendung zu verwalten.

graph TD
    A[Java EE Web App Docker Image] --> B[Docker Container]
    B --> C[Docker Swarm or Kubernetes]
    C --> D[Production Environment]

Indem Sie Ihre Java EE-Webanwendung containerisieren und auf einer Container-Orchestrierungsplattform bereitstellen, können Sie die Vorteile von Docker wie konsistente Bereitstellung, Skalierbarkeit und Portabilität nutzen, um den zuverlässigen und effizienten Betrieb Ihrer Unternehmens-Webanwendung sicherzustellen.

Zusammenfassung

Dieses Tutorial hat eine umfassende Anleitung dazu gegeben, wie Sie eine Java EE-Webanwendung erstellen und in einem Docker-Container bereitstellen können. Durch die Containerisierung Ihrer Java EE-Anwendung können Sie von einer verbesserten Portabilität, Skalierbarkeit und Konsistenz in verschiedenen Umgebungen profitieren. Docker vereinfacht den Bereitstellungsprozess und stellt sicher, dass Ihre Anwendung unabhängig von der zugrunde liegenden Infrastruktur immer gleich läuft. Mit den in diesem Tutorial erworbenen Kenntnissen können Sie nun mit Zuversicht Docker nutzen, um die Entwicklung und Bereitstellung Ihrer Java EE-Webanwendungen zu rationalisieren.