DevOps Projekt 4: Containerisierung der Java Web App „Profile“

- Ziel:

Vorbereitung einer stabilen und reproduzierbaren Docker-Umgebung, um die Profile Java Web Application lokal zu containerisieren und Docker Images für Docker Hub zu bauen.

- Warum Docker Engine?

• Docker Engine ist die Laufzeitumgebung für Container
• Ermöglicht den Build, Run und Test von Images
• Grundlage für Docker Compose

- Vorgehen

1. Source Code klonen & neue Branch erstellen
   • Projekt aus GitHub in VS Code klonen
   • Im Projektverzeichnis eine neue Branch für Containerisierung erstellen

   git checkout -b containers

2. Lokale VM mit Vagrant vorbereiten
   • Im Projekt einen vagrant/-Ordner erstellen
   • Ubuntu VM für saubere Docker-Installation verwenden
   • Isolation vom Host-System (Best Practice)

   vagrant up
   vagrant ssh
   sudo -i

3. Docker Engine installieren (Dockerdocs)
   • Installation gemäß offizieller Docker-Dokumentation

   
   apt update -y
   apt install ca-certificates curl gnupg -y
   install -m 0755 -d /etc/apt/keyrings
   curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
   gpg --dearmor -o /etc/apt/keyrings/docker.gpg
   chmod a+r /etc/apt/keyrings/docker.gpg
   
   echo \
   "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
   https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) stable" | \
   tee /etc/apt/sources.list.d/docker.list > /dev/null
   
   apt update -y
   apt install docker-ce docker-ce-cli containerd.io -y
   systemctl status docker
   

   
4. Vagrant User zur Docker-Gruppe hinzufügen
   • Docker läuft als Root-Service. Ohne diese Einstellung müsste jeder Docker-Befehl mit sudo ausgeführt werden.

   
   usermod -aG docker vagrant
   newgrp docker
   

- Ziel:

Java Web App profile als Tomcat-Container bereitstellen: Build (WAR) → Deploy in Tomcat → Container starten.

- Multi-Stage Dockerfile, Warum?

• Stage 1 (Maven): nur zum Bauen des WAR-Artefakts
• Stage 2 (Tomcat): enthält nur Tomcat + WAR → Vorteile: kleineres Image
• Build-Tools (Maven, Git, Cache) landen nicht im finalen Runtime-Image

- Vorgehen (Schritt für Schritt)

1. Docker-Ordnerstruktur im Projekt anlegen

   profile/
   └── src/
   └── vagrant/
   └── Docker-files/
       └── app/
           └── Dockerfile

2. Basis-Images auf Docker Hub auswählen
   • maven:3.9.9-eclipse-temurin-21-jammy → Build-Stage
   • tomcat:10-jdk21 → Runtime-Stage

   Wir bauen diese Images nicht „from scratch“, weil sie bereits gepflegt und standardisiert sind.

3. Dockerfile erstellen (Multi-Stage->to reduce the size of image)
   • Stage 1 – BUILD (Maven)
     Verwendet ein Maven-Image mit JDK 21, ausschließlich zum Bauen des Java-Artefakts.
     FROM maven:3.9.9-eclipse-temurin-21-jammy AS BUILD_IMAGE
     Klont den Source Code der Profile-Anwendung aus GitHub in den Build-Container(BUILD_IMAGE).
     RUN git clone https://github.com/benutzername/profile.git
     Wechselt in das Projekt, nutzt den Branch containers und erzeugt das WAR-File im target/-Ordner.
     RUN cd profile && git checkout containers && mvn install
   • Stage 2 – RUNTIME (Tomcat)
     Verwendet Tomcat-Image mit JDK 21 für den produktiven Betrieb der Anwendung.
     FROM tomcat:10-jdk21
     Entfernt alle Standard-Tomcat-Applikationen (ROOT, docs, examples).
     RUN rm -rf /usr/local/tomcat/webapps/*
     Kopiert das gebaute WAR aus dem Build-Stage und deployed es als Hauptanwendung (ROOT).
     COPY --from=BUILD_IMAGE profile/target/profile-v2.war /usr/local/tomcat/webapps/ROOT.war
   • Stage 3 – Container starten
     Dokumentiert, dass die Anwendung innerhalb des Containers auf Port 8080 läuft.
     EXPOSE 8080
     Startet Tomcat im Vordergrund, damit der Container aktiv bleibt.
     CMD ["catalina.sh", "run"]
   Ergebnis: Das finale Image enthält nur Tomcat + ROOT.war. Maven/Git sind nur im Build-Stage vorhanden → sauber, klein, produktionsnah.

- Ziel:

Eine reproduzierbare MySQL-Datenbank als Container bereitstellen – inkl. automatischem Import des Schemas über db_backup.sql

- Warum:

• Vereinfachte Initialisierung (Schema & Daten)
• Vorbereitung für Cloud Native
• Daten unabhängig vom App-Container

- Vorgehen (Schritt für Schritt)

1) Projektstruktur vorbereiten

• Erstelle im Projektordner Docker-files/ einen Unterordner db/.
  Warum? So liegen DB-Dateien (SQL, Dockerfile) sauber getrennt von der App.
• Kopiere die Datei db_backup.sql in Docker-files/db/.
  Warum? Diese Datei initialisiert später automatisch das Datenbankschema + Daten.

Docker-files/
├── app/
│   └── Dockerfile
└── db/
    ├── Dockerfile
    └── db_backup.sql

2) Basis-Image auswählen

• Verwende das offizielle Image mysql:8.0.33 von Docker Hub.

3) Dockerfile schreiben (DB Image)

Dieses Dockerfile baut ein MySQL-Image, das beim ersten Start die Datenbank automatisch initialisiert.

• Nutzt das offizielle MySQL-Image in einer festen Version für reproduzierbare Builds
  FROM mysql:8.0.33
  
  Metadaten für Nachvollziehbarkeit im Portfolio/Team (wer, welches Projekt).
  LABEL "Project"="Profile"
LABEL "Author"="Steve"
  
  Setzt das root-Passwort für MySQL (wird beim ersten Container-Start verwendet)
  Hinweis: Werte müssen zur Anwendungskonfiguration passen (application.properties)
  ENV MYSQL_ROOT_PASSWORD="vprodbpass"
  
  Legt beim ersten Start automatisch eine Datenbank an ("accounts")
  Warum? Die App erwartet diese DB und verbindet sich später darauf.
  ENV MYSQL_DATABASE="accounts"
  
  Kopiert das DB-Schema + Initialdaten in den Auto-Init-Ordner von MySQL
  Alles in /docker-entrypoint-initdb.d/ wird beim ersten Start ausgeführt/importiert
  ADD db_backup.sql /docker-entrypoint-initdb.d/db_backup.sql
  

Warum genau diese ENV-Werte?

• MYSQL_ROOT_PASSWORD: Damit der DB-Container ein Root-Passwort bekommt (MySQL startet sonst nicht korrekt).
• MYSQL_DATABASE: Erzeugt direkt die benötigte DB (z.B. accounts), damit die App sofort starten kann.
• db_backup.sql: Importiert Tabellen + Daten automatisch (kein manuelles SQL-Setup nötig).
• Werte in: src/main/resources/application.properties (dort stehen DB-Name / User / Passwort, die die App erwartet).

- Ziel:

Ein eigenes Nginx-Image wird verwendet, um die Rolle des Reverse Proxys klar zu kapseln und zu standardisieren.

- Wie (Vorgehen)

1. Docker-Ordnerstruktur im Projekt anlegen

   profile/
   └── src/
   └── vagrant/
   └── Docker-files/
       └── app/
       └── db/
       └── web/
           └── Dockerfile
           └── nginvproapp.conf

2. Nginx-Config erstellen: nginvproapp.conf

   Nginx bekommt eine eigene Konfiguration als Datei, damit der Container beim Start sofort als Reverse Proxy funktioniert. Diese Datei definiert Nginx als Reverse Proxy:

   • server Nginx beschreibt den Entry Point und hört auf Port 80
   • Nginx leitet Requests weiter an upstream vproapp:8080 (Tomcat-App Container)
   • Tomcat bleibt intern, Nginx ist der Entry Point

           upstream vproapp {
               server vproapp:8080;
           }
           server {
               listen 80;
               location / {
                   proxy_pass http://vproapp;
               }
           }
           

3. Basis-Images auf Docker Hub auswählen
   • nginx

4. Dockerfile erstellen (Multi-Stage->to reduce the size of image)
   • Basis: offizielles Nginx Image (enthält Nginx + Standardstruktur)
     FROM nginx
     Metadaten: für Image-Identifikation
     LABEL Project="Profile"
LABEL Author="Steve"
     Entfernt die Standard-Konfiguration von Nginx (default.conf),
     damit Nginx nicht die Default-Welcome-Page ausliefert.
     RUN rm -rf /etc/nginx/conf.d/default.conf
     Kopiert deine eigene Reverse-Proxy-Konfiguration in den Container,
     Nginx leitet damit Traffic automatisch an den Tomcat-Service weiter.
     COPY nginvproapp.conf /etc/nginx/conf.d/vproapp.conf

Für Memcached und RabbitMQ werden offizielle Docker Images von DockerHub verwendet, da es sich um standardisierte Infrastruktur-Services handelt, die keine Anpassung am Code oder an der Konfiguration benötigen.

• Image für Memcache: memcached
• Image für RabbitMQ: rabbitmq

Ziel

Ein zentrales Repository für Docker Images.

Vorgehen

1. Account auf https://hub.docker.com erstellen
2. Neues Repository anlegen:
   • profileapp(Für tomcat)
   • profiledb(Für mysql)
   • profileweb(Für nginx)

- Ziel:

Alle Container unserer Anwendung (Java Web App (Tomcat), MySQL (Datenbank), Memcached (Cache), RabbitMQ (Messaging), Nginx (Reverse Proxy)) gemeinsam zu definieren , in der richtigen Reihenfolge zu starten und zu vernetzen – mit einem einzigen Befehl.

Statt viele einzelne docker run-Befehle zu nutzen, beschreibt Docker Compose das gesamte System als Code.

- Docker Compose – Orchestrierung der 5 Container (Profile)

Docker Compose beschreibt die komplette Anwendung als System (docker-compose.yml) und startet alle Container inklusive Netzwerk, DNS-Namen und Abhängigkeiten mit docker compose up -d.

- Containers Information für Docker-Compose

- Docker Compose – Wie (Vorgehen)

Prerequisite:

• Wir starten 5 Container gemeinsam: db(vprodb), mc(vprocache01), rmq(vpromq01), app(vproapp), we(vproweb).
• 3 Services werden selbst gebaut (eigene Images + Dockerfiles): app, db, web.
• 2 Services nutzen offizielle Images (direkt von Docker Hub): memcached und rabbitmq.
• Wichtige Werte (DB-Name, User/Pass, MQ-User/Pass, Hostnamen/Ports) stehen in src/main/resources/application.properties .

Compose-Datei anlegen:

Im Projekt-Root eine Datei erstellen: compose.yml

Docker-Compose schreiben:

services:
# --- MySQL Datenbank ---
  vprodb:
    build:
      context: ./Docker-files/db # Dockerfile liegt im Ordner ./Docker-files/db
    image: meka237/profiledb # db-Image Repository in dockerhub push/pull
    container_name: vprodb
    ports:
      - "3306:3306" # MySQL Standard-Port
    volumes:
      - vprodbdata:/var/lib/mysql # Persistente Daten der Datenbank
    environment:
      - MYSQL_ROOT_PASSWORD=??? # Root-Passwort (application.properties)

# --- Memcached Cache ---
  vprocache01:
    image: memcached # Offizielles Memcached Image von DockerHub
    container_name: vprocache01
    ports:
      - "11211:11211" # Cache Service Port

# --- RabbitMQ Message Broker ---
  vpromq01:
    image: rabbitmq # Offizielles RabbitMQ Image von DockerHub
    container_name: vpromq01
    ports:
      - "5672:5672" # AMQP Port
    environment:
      - RABBITMQ_DEFAULT_USER=??? # Default User(application.properties)
      - RABBITMQ_DEFAULT_PASS=??? # Default Passwort(application.properties)

# --- Java App (Tomcat) ---
  vproapp:
    build:
      context: ./Docker-files/app # Dockerfile für Tomcat App
    image: meka237/profileapp
    container_name: vproapp
    ports:
      - "8080:8080" # Tomcat Application Port
    volumes:
      - vproappdata:/usr/local/tomcat/webapps # Persistente App-Daten

# --- Nginx Reverse Proxy ---
  vproweb:
    build:
      context: ./Docker-files/web # Dockerfile für Nginx Reverse Proxy
    image: meka237/profileweb
    container_name: vproweb
    ports:
      - "80:80" # HTTP Zugriff für Benutzer

volumes:
  vprodbdata: {} # Volume für MySQL Daten
  vproappdata: {} # Volume für Tomcat Webapps