Docker

Eine Einführung für Fachinformatiker

Virtuelle Maschinen mit Hypervisor
(HyperV, Virtual Box, KVM, VMware) vs. Docker-Engine
 Was ist Docker?
• Docker (bzw. die Docker-Engine) ist eine Software zur Virtualisierung von (Server-)Applikationen
• Docker ist OpenSource, wird kommerziell vermarktet, aber es gibt eine kostenlose Community-Edition (DockerCE)
• Im Gegensatz zu HyperV, Virtual Box, KVM oder VMware, die komplette Computer-Hardware simulieren und
damit ganze Betriebssysteme virtualisieren, ist Docker erheblich "schlanker" da es nur ein Betriebssystem
gegenüber der laufenden Anwendung simuliert.
• Docker packt zum Ausführen einer Applikation ein fertig installiertes Applikations-Image in einen "Container", in
dem die Informationen gespeichert sind, die die Anwendung tatsächlich ausmacht (z.B. Programmcode, Libraries,
Einstellungen, Daten etc.).
• Die Docker Engine stellt allen Containern (man kann quasi beliebig viele starten) gemeinsame Ressourcen des auf
der Hardware installierten OS zur Verfügung.
• Die Container sind standardmäßig untereinander und dem OS gegenüber abgekapselt. Dazu werden verschiedene
Linux-Technologien (namespaces, cgroups) genutzt, um die Container voneinander und vom Host-OS zu isolieren.
• Auf dem Docker-Hub ([Link] gibt es mehrere Millionen Open-Source-Images. Ähnlich wie bei
Github kann jeder eigene Images auf dem Docker Hub hochladen.
• Docker gibt es auch als Desktop-Version für Windows und macOS. Nachteil: Die Docker-Engine läuft nicht als
echter Dienst im Hintergrund, sondern nur wenn Docker Desktop gestartet ist. Deshalb als (dauerhaft laufender)
Server ungeeignet.
Eigenschaften von Applikations-Containern
• Software muss nicht mehr installiert werden, sondern wird in einem
(mehr oder minder) fertigen Container gestartet.
• Das Host-Betriebssystem bleibt dabei weitgehend unangetastet und
schlank (man muss nur den Docker-Dienst installieren)
• Mehrere Container sind möglich (auch mehrere Container einer
Applikation), z.B. 5 * nginx Webserver und 3 * MySQL und 2 * Redis
DBs, und das auch in unterschiedlichen Versionen
• Container können untereinander über entsprechende Netzwerkports,
oder durch "Verlinkung" oder virtuelle Laufwerke (Docker Volumes)
miteinander kommunizieren oder Daten gemeinsam nutzen.
Vorteile von Docker Containern
• Container und damit Applikationen lassen sich jederzeit pausieren, löschen, neu
konfigurieren. Ideal für Systementwicklung und Testumgebungen!
• Ein Container enthält alles, was die Applikation benötigt (Programm, Daten,
Libraries, individuelle Teile des Betriebssystems). Er lässt sich problemlos auf
eine andere Maschine mit der gleichen Prozessorplattform verschieben.
• Ressourcen werden besser ausgenutzt, weil sich alle Docker-Container eine
Hardware und ein OS teilen.
• Mit Docker-Swarm oder Kubernetes lassen sich Container auf mehreren Host-
Maschinen verteilen (Clusterbildung).
• Container lassen sich auch problemlos in die Cloud zu einem Docker-Provider
transferieren (CAAS - Container as a service), z.B.:
• Google Cloud Run [Link]
• Amazon Elestic Container Service (ECS) [Link]
• Microsoft Azure Container Service (ACS) [Link]
• Hostinger [Link]
• … und natürlich lassen sich Docker Container auch auf jeder anderen in der Cloud gehosteten Linux-Maschine
betreiben (NetCup, Strato, Digital Ocean etc. etc.)
Wichtige Begriffe zu Docker
• Docker Hub → Öffentliches Verzeichnis von Docker Images ([Link]
• Image → Read Only - Kopiervorlage für später laufenden/laufende Applikationscontainer
• Container → Lauffähige Applikation aus einem Image erzeugt, enthält außer dem
Applikations-Image die Netzwerkkonfiguration und Datenspeicher
• Volume → Vom Container unabhängiger Datenspeicher für einen oder mehrere Container
• Dockerfile → "Bauanweisung" für Docker, um ein neues Image zu erzeugen, dabei kann
man sich auf ein bestehendes Image beziehen und dieses um Softwarepakete erweitern
Aufbau und Inhalt eines Docker-Containers

Daten und Konfiguration

Dauerhaft
(Netzwerk, Speicher etc.) des gespeicherte
Containers: nicht 100% Daten im
persistent, d.h. verschwinden Dateisystem
des Host,
beim Neuerzeugen des können auch
Containers von mehreren
Containern
genutzt
werden
Image (Read Only)
Container (laufende Applikation) Volume
Installation von Docker (Debian 11 /12)
• Empfohlen: Docker auf Linux installieren, nur dort läuft es als Service
• Best Practice: Um Docker auszuprobieren, eine VM mit Debian 12 erstellen
(mit Netzwerkbrücke, damit die VM eine eigene IP hat)
• Basisinstallation ohne Desktop mit sshd reicht völlig aus
• Diese VM wird dann unser Docker-Host, auf dem wir Docker installieren.
• Docker-Installation unter Debian / Ubuntu u.v.a.m.:
• curl installieren (sudo apt install curl)
• Docker installieren mit sudo curl [Link] | sh
• Die IP-Adresse des Hosts lässt sich mit ip a anzeigen, das ist dann auch
die IP-Adresse der verschiedenen, in Docker laufenden Applikations-
Container.
Funktionstest von Docker (Hello World)
docker run hello-world
docker run
(Image herunterladen, Container erzeugen und starten)
• Erzeugt einen neuen Container auf Basis eines Images und startet ihn, ist das Image lokal nicht vorhanden,
wird es vom Docker-Hub geladen:
docker run –p 80:80 nginx:latest
• -p 80:80→ Mappe den Port 80 des Nginx-Containers nach außen auf den Port 80 des Docker-Hosts (z.B.
unsere VM). Ohne die Option -p ist die Applikation/Container nicht von außerhalb von Docker erreichbar!
• Ggf. den Port 80 (eingehend) in der Firewall des Hosts freigeben (z.B. ufw allow 80).
• nginx:latest → Name des Images und der Version (genannt "Tag"), in diesem Fall der Nginx-Webserver
• Mit einem Webbrowser kann man jetzt direkt auf die Applikation browsen [Link]
(in Debian kann man mit ip a die aktuelle IP-Adresse anzeigen lassen).
• Auf dem Bildschirm sieht man jetzt die Log-Ausgabe des Containers, den Nginx-Container kann man mit
Strg-C beenden. Der Nginx ist nicht mehr per Browser erreichbar.
• Den gestoppten Container könnte man später jederzeit weiterlaufen lassen.
docker run -d
(Container erzeugen und im Hintergrund starten)
• Erzeugt einen neuen Container auf Basis eines Images und startet ihn, ist das Image lokal nicht vorhanden,
wird es vom Docker-Hub geladen:
docker run –d –p 8888:80 docker/getting-started
• -d → Container soll "detached" laufen (im Hintergrund)
• -p 8888:80 → mappe den "internen" Port 80 des Containers / der Applikation nach außen auf den Port
8888 des Docker-Hosts (z.B. unsere VM). Ohne die Option -p ist die Applikation/Container nicht von
außerhalb von Docker erreichbar!
• Ggf. den Port 8888 (eingehend) in der Firewall des Hosts freigeben (Allow)!
• docker/getting-started → Name des Anbieters und des Images, das Image enthält einen kompletten
Webserver (lighttpd) mit einer Website mit einem Docker Tutorial
(Beschreibung siehe [Link]
• Mit einem Webbrowser kann man jetzt direkt auf die Applikation browsen [Link]
(in Debian kann man mit ip a die aktuelle IP-Adresse anzeigen lassen)
• docker create statt docker run erstellt einen neuen Container, ohne ihn sofort zu starten
docker ps (Container anzeigen)

• Listet alle laufenden und pausierten Container auf, nicht jedoch die gestoppten
(nicht laufenden).
• Zur eindeutigen Identifizierung des Containers (z.B. zum späteren Stoppen oder
Pausieren oder Starten) ist dabei die Container_ID oder der Name wichtig. Bei
der Container_ID reichen im allgemeinen die ersten Ziffern, um ihn eindeutig zu
identifizieren:
• Hinweis: docker ps –a listet alle Container auf, also auch alle gestoppten.
• Mit docker stop 566b könnte man den Container stoppen und ihn mit
docker start 566b wieder weiterlaufen lassen.
• docker images listet alle heruntergeladenen Images auf
Weitere Docker-Befehle
für Container und Images
Befehl Auswirkung
docker stop <container> Beendet einen Container
docker start <container> Startet einen (gestoppten) Container
docker pause <container> Pausiert einen Container, "entpausen" geht mit docker unpause <container>
docker kill <container> Beendet einen Container zwangsweise
docker rm <container> Löscht einen Container (darf in dem Moment nicht laufen)
docker images Listet alle lokalen (heruntergeladenen) Images auf
docker pull <image> Lädt ein Image vom Docker Hub herunter
docker system prune --all Löscht alle nicht laufenden Container und Images ohne laufenden Container
docker stats Zeigt Ressourcenverbrauch von laufenden Containern an
docker exec –u root -it <container> bash Eine Bash oder Shell als root im angegebenen laufenden Container interaktiv
docker exec –u root -it <container> sh ausführen (je nachdem welche Shell verfügbar ist)

docker cp <datei> <container>:<pfad> Kopiert eine Datei in einen Container hinein, z.B. docker cp [Link]
deb:/home
Hinweis: <container> steht für ID oder Name des Containers
Der ([Link]
• Enthält über 100.000 Repositories (Docker-Image-Projekte)
• Jedes Repository enthält ein Image in vielen Versionen
• Versionsnummer wird als Tag bezeichnet und mit Doppelpunkt getrennt
hinter den Namen des Images geschrieben(z.B. mysql:8.3 oder
archlinux:latest)
• Die Suche im Docker-Hub ermöglicht Selektion nach "Docker Official
Image" und "Verified Publisher" oder "Sponsored Open Source Software",
welche Vertrauenswürdigkeit versprechen.
• Manche Publisher (z.B. Bitnami) haben sich darauf spezialisiert,
hochqualitative, stabile Images anzubieten.
• Außerdem gibt es die Möglichkeit, die Prozessorarchitektur vorzugeben
(x86-64, ARM) da nicht alle Repositories alle Prozessoren unterstützen.
• Es gibt auch die Möglichkeit, private Repositories anzulegen oder vom
lokalen Docker aus andere, z.B. unternehmenseigene Hubs anzusprechen
(ähnlich wie bei Github).
• Nicht alle Docker Images werden mit einem einfachen docker run
gestartet, dazu empfiehlt sich das Lesen der Dokumentation auf der
Repository Seite.
Beispiel: Docker Container mit MySQL
• Starten Sie einen MySQL-Server mit folgendem Befehl:
docker run --name MYDB -e MYSQL_ROOT_PASSWORD=geheim123 -d –p 3306:3306 mysql:8.3

• mysql:8.3 → Offizielles Image von Docker und dem MySQL Team

• --name MYDB → Startet den Container mit dem selbstgewählten Namen MYDB
→ Startet den Container mit der Umgebungsvariable
• -e MYSQL_ROOT_PASSWORD=geheim123
(Environment) für das root-Kennwort
• -d → Startet den Container im Hintergrund ("detached")
• –p 3306:3306 → Sorgt dafür, dass der MySQL-Server via Port 3306 erreichbar ist.
• mysql:8.3 → Lädt das Image mysql mit dem Tag (Version) "8.3" herunter
• Tipp: mit docker exec -it MYDB bash eine interaktive Shell im Container öffnen und
dann mit mysql -p in die Datenbank einloggen
Beispiel: Docker Container mit MySQL und
persistenten Daten (Volume)
• Erzeugen Sie ein Volume (Virtuelle Festplatte) im Dateisystem des Hosts:
docker volume create DBDATA

• Was man wissen muss: Das Datenverzeichnis eines MySQL-Servers befindet

sich im noch zu startenden MySQL-Container im Ordner /var/lib/mysql
• Starten Sie einen MySQL-Server und binden Sie das Volume als Datenspeicher
ins Dateisystem an der Stelle /var/lib/mysql des Containers ein:
docker run --name WORLDDB -e MYSQL_ROOT_PASSWORD=geheim123 –v DBDATA:/var/lib/mysql \
-d –p 3306:3306 micky65/mysql-world

• Das Datenverzeichnis ist jetzt ausserhalb des Container und überlebt ihn, wenn
er z.B. gelöscht und neu erzeugt wird, ebenso ein eventuelles
docker system prune –-all

• Auf dem (Linux-)Host findet man die Volumes unter /var/lib/docker/volumes/

Beispiele: Linux Distributionen als Image
• docker run –it archlinux:latest
→ Startet ein aktuelles Arch Linux interaktiv im Terminal
• docker run –it ubuntu:22.04
→ Startet Ubuntu 22.04 interaktiv im Terminal
• docker run –it opensuse/tumbleweed:latest
→ Startet das aktuelle OpenSUSE interaktiv im Terminal
• docker run –it kalilinux/kali-rolling
→ Startet Kali interaktiv im Terminal (kommt ohne Tools, für die
Installation derselben siehe Doku auf Docker-Hub)
Spaß mit Docker Images
• docker run -it danielkraic/asciiquarium
→ Aquarium mit ASCII-Art
• docker run –it defnotgustavom/nsnake
→ Das klassische "Snake" Game im Terminal
• docker run –it defnotgustavom/tetris
→ Tetris im Terminal
• docker run –it awalach/ninvaders
→ Space Invaders!
• docker run -it jwodder/nethack
→ Das klassische Rogue im Terminal, der Urvater von Diablo, must play! Siehe
[Link]
• docker run -d -it -e EULA=TRUE -p 25565:25565 –v ./data:/data itzg/minecraft-server
docker run -d -it -e EULA=TRUE -p 19132:19132/udp -v mc-bedrock-data:/data itzg/minecraft-bedrock-server
→ Eigener Minecraft- bzw. Minecraft-Bedrock-Server
Beispiel: Plik Container (Upload Portal)
• Erzeugen Sie eine Plik-Instanz auf Port 8080:
docker run --name plik -t -d -p 8080:8080 rootgg/plik

• Die Plik-Instanz ist dann über Webbrowser auf Port 8080 erreichbar: [Link]
• Weitere Infos findet man auf der Projektwebsite: [Link]
Beispiel: Docker Container mit nginx Webserver
und persistenten Daten
• Starten Sie einen nginx-Container mit folgendem Befehl:
docker run --name MYWWW -d –p 8080:80 –v webspace:/usr/share/nginx/html nginx:latest

• --name MYWWW → Startet den Container mit dem selbstgewählten Namen MYWWW
• -d → Startet den Container im Hintergrund ("detached")
• -p 8080:80 → Mappe den Port 8080 des Hosts mit dem Port 80 des Containers

• –v webspace:/usr/share/nginx/html → Legt ein Volume namens webspace an und verlinkt es im Container

unter /usr/share/nginx/html (dem nginx-Datenverzeichnis).

• nginx:latest → Lädt das Image nginx mit dem Tag (Version) "latest" herunter (normalerweise
die neueste Version)
• Der Webserver lässt sich jetzt im LAN mit [Link] ansurfen
• Das Volume befindet sich auf dem Docker Host unter /var/lib/docker/volumes/webspace und
ist unabhängig vom gestarteten Container
Beispiel: Komplettes XAMPP im Container mit
Volumes für persistente Daten
docker run --name myXampp -p 41061:22 -p 41062:80 -d -v ~/my_web_pages:/www tomsik68/xampp

• SSH Zugang über Port 41061 (root/root)

• Webzugang über [Link]
• phpMyAdmin über [Link]
• Webseitenverzeichnis (unter Linux) in ~/my_web_pages → Deshalb bleiben
die Daten auch nach Neu-Erzeugung des myXampp-Containers erhalten
• Mit der Option --restart always kann man den Container dauerhaft
laufen lassen (auch nach Reboot des Hostrechners)
• Anderenfalls: Jederzeit Stop des Containers mit docker stop myXampp
und Start mit docker start myXampp möglich!
Beispiel: [Link] (Diagrammeditor) Instanz
docker run -it --rm –-name draw -p 8080:8080 -p 8443:8443 jgraph/drawio

• Erzeugt eine [Link] Instanz, die über Port 8080 (http) oder 8443 (https) mit
dem Browser erreichbar ist (z.B. [Link] )
• Die Option --rm bewirkt, dass der Container nach Beenden automatisch
entfernt wird, sozusagen ein "Kurzzeit-/Wegwerf-Container".
docker run -it -e LETS_ENCRYPT_ENABLED=true -e PUBLIC_DNS=[Link]
–-name draw -p 80:80 -p 443:8443 jgraph/drawio

• Erzeugt eine Instanz mit LetsEncrypt-Zertifikat (PUBLIC_DNS anpassen!)

→ In Browsern anerkanntes https - Zertifikat (siehe [Link])
→ 90 Tage Gültigkeit, Container aktualisiert es automatisch beim Start
• Container-Beschreibung: siehe [Link] )
(Hinweis: [Link] gibt es auch als Desktop-Applikation: [Link] )
Beispiel: Einfaches Standalone CryptPad
docker run -d -p 3000:3000 -p 3001:3001 promasu/cryptpad
• Erzeugt einen CryptPad-Container. CryptPad (siehe
[Link] ) ist ein Online-Collaborations-Tool
zum gemeinsamen, gleichzeitigen Arbeiten an
Dokumenten.
• Es wird eine komplette Office Suite (ähnlich Google-Docs)
für Textdokumente, Tabellen, Präsentationen zur
Verfügung gestellt.
• Das besondere an CryptPad: Alle Daten, die den Client-
Browser verlassen, werden sicher verschlüsselt und auch
verschlüsselt auf dem Server gespeichert.
• Selbst der Server-Admin kann diese nicht einsehen.
• CryptPad kommt mit einer Registrierungsseite zum
Anlegen eines Benutzeraccounts, arbeiten ist aber auch
als Gast möglich.
 Beispiel: CryptPad mit persistenten Daten
docker run -d -p 3000:3000 -p 3001:3001 -v ${PWD}/data/blob:/cryptpad/blob -v
${PWD}/data/block:/cryptpad/block -v ${PWD}/customize:/cryptpad/customize -v
${PWD}/data/data:/cryptpad/data -v ${PWD}/data/files:/cryptpad/datastore
promasu/cryptpad

• Erzeugt einen CryptPad-Container mit persistenten Daten für Benutzer,

Dokumente, Einstellungen etc.
• Die persistenten Daten landen im Ordner data und customize im
Benutzerordner (${PWD})
• Später erzeugte promasu/cryptpad-Container können problemlos auf diese
Daten zugreifen (mit gleichem docker run Befehl)
• Weitere Infos und andere Versionen des verwendeten Images unter:
[Link]
Beispiel: Nextcloud
docker run -d -p 8080:80 nextcloud
• Kompletter Nextcloud-Container, standardmäßig mit Apache-
Webserver und SQLite als DB mit persistentem Speicher unter
/var/lib/docker/volumes/…
• Start Username/Password: db / nextcloud (baldmöglichst ändern!)
• Beschreibung des Images:
[Link]
• Weitere Erweiterungsmöglichkeiten (siehe Beschreibung):
• Eigene MySQL- oder Maria-DB
• Selbstdefiniertes Volume für Datenspeicherung
• Eigener, vorgeschalteter Webserver (fpm-Image)
• https:// mit vorgeschaltetem Reverse-Proxy und Lets-Encrypt
Docker Befehle für Volumes
Befehl Auswirkung
docker volume ls Listet die Volumes auf
docker volume prune Löscht alle gerade nicht verwendeten Volumes (vorsicht!)
docker volume rm <volume> Entfernt ein bestimmtes Volume
docker inspect <volume> Zeigt detaillierte Daten zu einem Volume an
docker volume create <volume> Volume erzeugen
Beispiel: Portainer – ein Verwaltungsserver für Docker
• Portainer ist ein browserbasiertes Verwaltungstool für Container Applikationen und lässt sich unter
Docker installieren:
docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always
-v /var/run/[Link]:/var/run/[Link] -v portainer_data:/data portainer/portainer-ce
• Siehe auch [Link]
• Portainer ist danach über [Link] per Browser erreichbar.
• Ein Volume portainer_data wird beim Erzeugen des Containers angelegt.
• Der Container startet dank der Option --restart=always automatisch nach dem Reboot und auch
wenn er beendet wird. Nur mit docker kill wird er ohne Restart beendet.
Image Befehle für Import / Export / Docker Hub
• docker commit <container> <image> → Macht aus einem Container ein Image
• docker save <image> > [Link] → Speichert ein Image in eine tar-Datei
• docker load < [Link] → Lädt ein Image aus einer .tar-Datei
• docker tag <image> <hub-user>/<repo-image> :<tag> → Taggt ein vorhandenes
Image zum späteren Push des repo-Images zum Docker Hub ([Link]
• docker push <hub-user>/<repo-name>:<tag> → Veröffentlichung zum Docker Hub →
Vorher docker login durchführen – benötigt eventl. die Installation von sudo apt-get
install pass
Multi-Container-Applikationen
• Bei vielen Images gilt das Prinzip: 1 Container = 1 Dienst
• Da viele IT-Systeme aus mehreren Diensten / Applikationen bestehen,
muss man oft mehrere Container miteinander verbinden / vernetzen.
• Beispiele:
• Webserver und Datenbankserver (nginx und MariaDB)
• Datenbankserver und Datenbankclient (MySQL und phpMyAdmin)
• Datensammler, Datenbankserver und Auswertungssoftware (z.B. Telegraf,
InfluxDB und Grafana)

• Ein Möglichkeit, Multicontainer-Applikationen zu bauen, ist die

"Verlinkung" der Container (die Images müssen das unterstützen, siehe
die jeweilige Beschreibung). Dazu wird der Container der die Ressourcen
eines anderen Containers nutzen will mit der Option --link aufgerufen.
Siehe Beispiel auf der nächsten Folie!
Beispiel: Multicontainer-App mit phpMyAdmin und MySQL
• Wir starten zunächst eine MySQL-Instanz und vergeben einen Namen für den Container und setzen das
Passwort:
docker run --name SQLdb -d micky65/mysql-world:latest
• Der Container SQLdb läuft im Hintergrund und ist nicht übers Netzwerk erreichbar!
Falls das doch gewünscht ist: docker run --name SQLdb -d -p:3306:3306 micky65/mysql-world:latest
• Nun starten wir ein phpMyAdmin-Image und verlinken die Variable db mit der
-- link Option mit dem Container SQLdb (siehe auch: [Link]
docker run --name phpmyadmin -d –-link SQLdb:db –p 8888:80 phpmyadmin/phpmyadmin
• Eine Kontrolle der beiden Container mit docker ps ergibt:

• Die Weboberfläche lässt sich anschließend mit [Link] aufrufen und man kann sich bei
phpMyAdmin mit root und dem vergebenen Passwort (geheiM123+) anmelden.
• Diese Art der Verlinkung ist nur eine von mehreren Möglichkeiten in Docker mehrere Container
miteinander kommunizieren zu lassen. Ebenfalls üblich ist die Verbindung über ein eigenes (internes)
Docker Netzwerk. Auch lässt sich der Start der beiden Container mit dem Linux-Tool Docker-Compose
automatisieren.
Docker Aufbauwissen: Multicontainer-
Applikationen mit docker compose
• Mit docker compose und einer [Link] Datei kann version: '3'
services:
man (auch mehrere) Container starten und zu einer Applikation # mySQL-Database
verbinden db:
image: mysql:latest
• docker compose ist also eine bessere (!) Alternative zum Starten volumes:
der Einzelcontainer mit docker run… - db_data:/var/lib/mysql
restart: always
• In der [Link]-Datei (in leerem Ordner ablegen) environment:
werden mit einer speziellen Syntax alle beteiligten Images, MYSQL_ROOT_PASSWORD: topSecret
# phpmyadmin
Volumes, Netzwerkverbindungen, Ports etc. festgelegt phpmyadmin:
• Start des Gesamtsystems (detached) mit depends_on:
- db
docker compose up –d image: phpmyadmin/phpmyadmin
• Beenden und löschen der Container der gesamten Applikation restart: always
ports:
mit docker compose down - '8088:80'
environment:
• Container stoppen und wieder starten mit docker compose stop PMA_HOST: db
bzw. docker compose start MYSQL_ROOT_PASSWORD: topSecret
volumes:
• Log-Dateien kann man mit docker compose log anzeigen db_data:
lassen (Echtzeitanzeige docker compose log –f) Applikation mySQL mit PHPMyAdmin
-Als [Link] speichern
-Starten mit docker compose up -d
 Beispiel: [Link] für
version: "3"

• Datei in leeren Ordner z.B. "myPihole" # Mehr Infos unter [Link]

# und [Link]

erstellen als [Link] services:

pihole:

• Ggf. WEBPASSWORD anpassen container_name: mypihole

image: pihole/pihole:latest

• In den Ordner wechseln und mit ports:

- "53:53/tcp"
docker compose up –d - "53:53/udp"
den Pi-hole-Container starten - "8081:80/tcp"
environment:
• Das Pi-hole-Webinterface ist TZ: 'Europe/Berlin'

anschließend unter WEBPASSWORD: 'topsecret123'

volumes:
[Link] erreichbar - './etc-pihole:/etc/pihole'
- './etc-dnsmasq.d:/etc/dnsmasq.d'
• Docker-Compose-Tutorial siehe Links restart: unless-stopped

[Link] für einen Pihole-Container

Beispiel: [Link] für WordPress
• Datei in leeren Ordner z.B. "myWP" version: '3.1'
# Infos unter [Link]
services:
erstellen als [Link] wordpress:
image: wordpress

• In den Ordner wechseln und mit restart: unless-stopped

ports:
docker compose up –d - 8080:80
environment:

den WordPress-Container starten WORDPRESS_DB_HOST: db

WORDPRESS_DB_USER: exampleuser
WORDPRESS_DB_PASSWORD: examplepass
• Die WordPress-Instanz ist dann unter WORDPRESS_DB_NAME: exampledb
volumes:
[Link] erreichbar (ist in db:
- wordpress:/var/www/html

der [Link] anpassbar, image: mysql:8.0

restart: unless-stopped

normalerweise Port 80 statt 8080) environment:

MYSQL_DATABASE: exampledb
MYSQL_USER: exampleuser
• Der Admin-Bereich von WP ist unter MYSQL_PASSWORD: examplepass
MYSQL_ROOT_PASSWORD: secretpass1234
[Link] erreichbar volumes:
- db:/var/lib/mysql
volumes:
• Sämtliche Daten sind container-unabhängig wordpress:
db:
in den Volumes auf dem Host abgelegt. [Link] für eine WordPress Instanz
Eigene [Link] erstellen
• Leeren Basisordner in Home erstellen und [Link]
(anderer Name ist auch möglich) editieren.
• Erste Zeile beschreibt die version: der compose-Sprachdefinition
(V3.8 und V2.4 sind die neuesten Definitionen), ist allerdings
„obsolete“ (nicht mehr notwendig)
• Danach folgt services: , am Ende der Datei eventuell noch volumes:
(für alle Services zugängliche Volumes), alle weiteren Einstellungen
sind darunter eingezogen.
• Einzüge in der .yml-Datei sind immer jeweils 2 Leerzeichen!
• Deutschsprachiges Docker Compose Tutorial:
[Link]
• Englisch: [Link]
• Siehe auch meine Docker Compose Kurzreferenz!
Nicht so einfach:
Update von Docker-Containern
• Der klassische Weg ist:
• Konfiguration des Containers sichern (falls das notwendig ist oder die Konfiguration nicht ohnehin in externem
Volume gespeichert ist)
• Container beenden/stoppen
• Aktuelles Image "pullen" (docker pull …)
• Neuen Container erstellen (docker run…)
• Konfiguration einspielen (falls notwendig)
• Alten Container löschen
• Andere Möglichkeit
• Z.B. docker exec -it <container> bash eine Shell im Container öffnen
• Mit apt update && apt upgrade auf den neuesten Stand bringen
• Nachteile: Image bleibt auf dem alten Stand / Unübersichtlich
• Mittels docker-compose
• docker compose down (Aktuelle(n) Container beenden und löschen)
• docker compose pull (Image(s) aktualisieren)
• docker compose up (Container neu erstellen und starten)
• Bester Weg
• Mit watchtower (ist selbst ein Container)
• Stoppt regelmäßig alle Container, pullt die neuesten Versionen und startet sie wieder
• Siehe nachfolgende Folie in dieser Präsentation und [Link]
Container automatisch updaten mit Watchtower
• Homepage [Link]
• Dokumentation: [Link]
• Einmaliges Update aller laufenden Docker-Container mit Watchtower:
docker run –-rm –v /var/run/[Link]:/var/run/[Link]
nickfedor/watchtower -–run-once
• Watchtower als Dienst starten und die Container myWP und DB stündlich (alle 3600s)
überprüfen:
docker run -d --name watchtower -v /var/run/[Link]:/var/run/[Link]
nickfedor/watchtower myWP DB --interval 3600

• Weitere Optionen:
• --cleanup (nach Update alte Images löschen)
• --include-stopped (auch nicht laufende Container updaten)
• --monitor-only (macht nur einen "dry-run", schickt Benachrichtigungen, updatet aber nicht)
• Benachrichtigungen (Discord, Email, Slack, shoutrrr) sind ebenfalls konfigurierbar,
siehe Watchtower-Dokumentation!
[Link] für Watchtower
• Ermöglicht komfortable Konfiguration von Email-Benachrichtigungen
und anderen Watchtower-Einstellungen
services:
watchtower:
image: nickfedor/watchtower:latest
container_name: watchtower
restart: unless-stopped
environment:
WATCHTOWER_NOTIFICATIONS: email
WATCHTOWER_NOTIFICATION_EMAIL_FROM: mywatchtower@[Link]
WATCHTOWER_NOTIFICATION_EMAIL_TO: info@[Link]
WATCHTOWER_NOTIFICATION_EMAIL_SERVER: [Link]
WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT: 465
WATCHTOWER_NOTIFICATION_EMAIL_SUBJECTTAG: Proxmox Home
WATCHTOWER_NOTIFICATION_EMAIL_SERVER_USER: mywatchtower@[Link]
WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD: Obxxxxx465789+!
WATCHTOWER_NOTIFICATION_EMAIL_DELAY: 2
volumes:
- /var/run/[Link]:/var/run/[Link]
command: --cleanup --interval 86400
Docker Aufbauwissen: Wie erstellt man eigene
Docker-Images? Mit einem Dockerfile!
• Das "Bauen" eines eigenen Images
geschieht mit dem Befehl docker build .
Basis Image laden
• Dieser Befehl wird in einem extra dafür
angelegten Verzeichnis ausgeführt, in FROM ubuntu:latest Update, Installation
dem sich mindestens eine Datei namens gcc und nano
Dockerfile befindet. RUN apt-get update && \
• Im Dockerfile wird festgelegt, auf apt-get -y install gcc nano
welchem Image das zu Erstellende Image Dockerfile für einen Ubuntu Container mit gcc-Compiler und nano-Editor

basiert und welche Änderungen Docker Image basierend auf Ubuntu mit gcc-Compiler und pico-Editor
enthalten sein sollen.
Image "bauen" mit docker build –t mygcc:latest
• Es wird dort quasi festgelegt, welche
Installationsschritte man sonst manuell Starten des Containers mit docker run –it mygcc

durchführt, um die Applikation(en) zu

installieren.
• Anschließend startet man das eigene
Image mit docker run
Zusammenfassung: Erstellung von….
• …Container-Applikation: mit docker run <image-name>
• …Einzel/Multi-Container-Applikation: mit docker compose up und
einer [Link] - Datei
• …Volumes :
• Beim Erzeugen des Containers mit docker run und der Option –v
• In einer .yml-Datei vordefinieren und mit docker compose up mit dem
Container zusammen erzeugen
• …Image:
• Aus einem Container: mit docker commit <container> <image-name>
• Von Grund auf: mit einem Dockerfile und docker build
Docker Links
• [Link]
Docker Desktop für Windows / Mac
• [Link]
Docker Hub
• [Link]
Docker Alternative, ebenfalls Free / OpenSource / Multi-Plattform
• [Link]
Kubernetes: Einerseits Docker-Alternative/-Fork, aber auch Docker-AddOn zur
Multi-Container-Orchestrierung / Skalierung / Clusterisierung
• [Link] Lokale Kubernetes Umgebung zum Experimentieren
• Video-Tutorials für Docker / Dockerfile / Docker-Compose:
• [Link]
• [Link]
• [Link]
• [Link]
• [Link]