Docker Tutorial: Typischer Ablauf mit einer kleinen Java EE Webanwendung

Docker bietet eine hervorragende Möglichkeit, Java EE Webanwendungen effizient zu entwickeln, zu testen und bereitzustellen. In diesem Tutorial werde ich den typischen Ablauf einer Docker-basierten Entwicklung mit einer kleinen Java EE Webanwendung aufzeigen. Wir erstellen eine einfache Anwendung, paketieren sie in einem Docker-Container und führen sie aus.

Was ist Docker?

Docker ist eine Plattform zur Containerisierung, die es Entwicklern ermöglicht, Anwendungen in leichtgewichtigen, portablen Containern zu verpacken. Diese Container enthalten alle notwendigen Abhängigkeiten, um die Anwendung auszuführen. Das bedeutet, dass Docker eine einheitliche Umgebung schafft, die unabhängig von der Infrastruktur funktioniert.

Warum Docker für Java EE?

Java EE (Java Enterprise Edition) ist eine Plattform für Unternehmensanwendungen. Da Java EE-Anwendungen oft viele Abhängigkeiten und eine spezielle Serverumgebung benötigen (wie z.B. einen Java EE-Server), ist Docker ideal, um diese Anforderungen zu kapseln und in jeder Umgebung konsistent bereitzustellen. Vorteile der Docker-Nutzung für Java EE-Webanwendungen:

Portabilität: Container laufen überall, wo Docker unterstützt wird.
Isolierte Umgebung: Container sind voneinander und vom Host-System isoliert.
Leichtgewichtiger als virtuelle Maschinen: Docker-Container teilen sich den Kernel und sind daher ressourceneffizienter.
Einfache Bereitstellung: Anwendungen können in Containern nahtlos von der Entwicklungs- zur Produktionsumgebung übergehen.

Typischer Workflow mit einer Java EE-Webanwendung

Im Folgenden zeige ich den Ablauf vom Entwickeln bis zum Ausführen einer Java EE-Anwendung mit Docker. Wir werden:

Eine einfache Java EE-Webanwendung erstellen.
Ein Docker-Image für diese Anwendung schreiben und bauen.
Die Anwendung in einem Docker-Container ausführen.

Voraussetzungen

Docker installiert (Installationsanweisungen).
Java Development Kit (JDK) installiert.
Maven als Build-Tool installiert.

1. Erstellen der Java EE Webanwendung

Für dieses Beispiel erstellen wir eine einfache Java EE-Webanwendung, die nur eine kleine „Hello World“-Seite bereitstellt. Wir verwenden Maven, um das Projekt zu erstellen.

Schritt 1: Maven-Projekt initialisieren

Führe diesen Befehl aus, um ein Maven-Projekt zu erstellen:

mvn archetype:generate -DgroupId=com.example -DartifactId=javaee-app -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

Dieser Befehl erstellt eine Maven-basierte Java-Webanwendung mit den Grundgerüsten für den Code.

Schritt 2: Java EE-Komponenten hinzufügen

In der Datei src/main/webapp/WEB-INF/web.xml fügen wir eine einfache Servlet-Definition hinzu, um einen „Hello World“-Endpunkt zu implementieren.

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" version="3.1">
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>com.example.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
</web-app>

Erstelle das Servlet HelloServlet.java in src/main/java/com/example/HelloServlet.java:

package com.example;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");
        resp.getWriter().write("<h1>Hello, Docker and Java EE!</h1>");
    }
}

2. Dockerfile schreiben

Ein Dockerfile ist eine Skriptdatei, die die Schritte definiert, um ein Docker-Image zu bauen. Für unsere Java EE-Anwendung benötigen wir ein Dockerfile, das:

Ein Java EE-Server wie Tomcat oder Payara verwendet.
Unsere Anwendung in den Container packt.
Den Server so konfiguriert, dass er unsere Anwendung beim Start bereitstellt.

Wir verwenden Payara, einen leichten Java EE-Server, der gut für Docker geeignet ist.

Dockerfile erstellen

Erstelle eine Datei mit dem Namen Dockerfile im Stammverzeichnis deines Projekts mit folgendem Inhalt:

# Verwende ein offizielles Payara-Server-Image als Basis
FROM payara/server-full:5.2021.8

# Setze das Arbeitsverzeichnis
WORKDIR /opt/payara/deployments

# Kopiere die WAR-Datei der Anwendung in das Deploy-Verzeichnis von Payara
COPY target/javaee-app.war .

# Exponiere Port 8080 (Standardport für Payara)
EXPOSE 8080

# Starte den Payara-Server
CMD ["start-domain.sh"]

3. Anwendung mit Maven bauen

Um die WAR-Datei (Web Application Archive) zu erstellen, führen wir das Maven-Paketierungsziel aus:

mvn package

Dieser Befehl erstellt die javaee-app.war-Datei im Verzeichnis target/, die unsere Anwendung enthält.

4. Docker-Image bauen

Verwende den folgenden Befehl, um das Docker-Image für deine Java EE-Anwendung zu erstellen:

docker build -t javaee-app .

Dieser Befehl verwendet das Dockerfile, um ein Docker-Image mit dem Namen javaee-app zu erstellen.

5. Anwendung im Docker-Container ausführen

Um die Anwendung in einem Docker-Container auszuführen, verwende den folgenden Befehl:

docker run -d -p 8080:8080 javaee-app

Dieser Befehl startet einen Docker-Container im Hintergrund (-d) und verbindet den lokalen Port 8080 mit dem Port 8080 des Containers (-p 8080:8080). Dadurch kannst du die Anwendung über den Browser auf http://localhost:8080/hello aufrufen.

6. Anwendung testen

Öffne deinen Webbrowser und gehe zu:

http://localhost:8080/hello

Du solltest eine Seite sehen, die den Text „Hello, Docker and Java EE!“ anzeigt.

7. (Optional) Bereitstellung auf Docker Hub

Falls du dein Docker-Image in einem Repository wie Docker Hub bereitstellen möchtest, kannst du das Image mit den folgenden Befehlen hochladen:

Bei Docker anmelden:

docker login

2. Image taggen:

docker tag javaee-app dein-dockerhub-username/javaee-app:latest

3. Image hochladen:

docker push dein-dockerhub-username/javaee-app:latest

Fazit

In diesem Tutorial haben wir gesehen, wie man eine einfache Java EE-Webanwendung mit Docker containerisiert und ausführt. Docker bietet eine flexible, skalierbare und konsistente Möglichkeit, Java EE-Anwendungen zu entwickeln und bereitzustellen. Dieser Workflow kann problemlos erweitert werden, um komplexere Anwendungen zu unterstützen, und ist ideal für den Einsatz in Continuous Integration (CI) und Continuous Deployment (CD)-Pipelines.

Durch die Nutzung von Docker kann die Bereitstellung von Java EE-Anwendungen erheblich vereinfacht und beschleunigt werden, während gleichzeitig die Sicherheit und Konsistenz der Umgebung gewährleistet wird.