Docker Basics und Installation auf Mint, Ubuntu und Debian

In diesem Artikel geht es um die Docker Basics und der Installation auf Mint, Ubuntu und Debian. Für Benutzer, die sich nicht lange mit komplexen System- oder Programmsetups beschäftigen möchten, ist Docker eine ideale Lösung. Nicht jeder hat die Zeit und die Geduld heutzutage sich mit Setups, verschiedensten Abhängikeiten und Installation und Konfiguration von diverser Software auseinanderzusetzen, um eine bestimmte Software auf einem (Home)Server laufen zu lassen. Docker eliminiert also die Notwendigkeit, sich mit verschiedenen Systemkonfigurationen und Installationsmethoden auseinanderzusetzen.

Mit Docker kann man Anwendungen schnell und einfach in Containern verpacken und ausführen, ohne sich Gedanken über die zugrunde liegende Infrastruktur machen zu müssen. Docker eignet sich besonders für Anwender, die ihre Software problemlos auf verschiedenen Umgebungen – vom lokalen Rechner über Testserver bis hin zu Produktionssystemen – betreiben möchten. Docker ist aber wie wie mit vielen anderen Dingen heutzutage, man lernt die Basics von verschiedenen Programmschichten nicht, man lernt nicht, wie diese Zusammenarbeiten und wie man diese konfiguriert.

In diesem Tutorial werden wir also die Grundlagen von Docker kennenlernen, von der Installation bis hin zu den wichtigsten Befehlen, die den Einstieg erleichtern. Ob du eine Webanwendung, eine Datenbank oder ein ganz anderes Projekt verwalten möchtet – Docker wird euch helfen, dies effizient und schnell umzusetzen.

Was ist Docker

Docker ist eine Open-Source-Plattform, die es ermöglicht, Anwendungen in sogenannten Containern zu verpacken. Ein Container ist eine leichtgewichtige, eigenständige Einheit, die alles enthält, was eine Anwendung zum Laufen braucht: Code, Bibliotheken, Laufzeitumgebungen und Abhängigkeiten. Im Gegensatz zu virtuellen Maschinen (VMs) benötigen Container keinen eigenen Betriebssystem-Kernel, was sie effizienter und ressourcenschonender macht. Sie nutzen den Kernel der Hostmaschine, was sie auch unserer im Gegensatz zu herkömmlichen virtuellen Maschinen machen können. Ist der Host komprommitiert, kann theoretisch auch Unsinn mit den Containern angestellt werden.

Docker Installation (Ubuntu, Debian und Linux Mint)

sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl gnupg lsb-release

Den Docker Repository GPG Key hinzufügen:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Tauscht ubuntu gegen debian aus bei einem reinen Debian System. Benutzt ihr Linux Mint, belasst ihr die den Befehl auf ubuntu!

Fügt das Repository zu euren Quellen hinzu und updatet die Packete:

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update

Auch hier ubuntu gegen debian austauschen falls ihr ein Debian System fahrt. Bei Linux Mint --> ubuntu

Auf Linux Mint öffnet ihr vorher noch das Docker Repository mit:

sudo nano /etc/apt/sources.list.d/docker.list

Und ändert am Schluss der Zeile das Betriebssystem Codeword von Linux Mint auf den korrekten Ubuntu unterbau ab:

Linux Mint 21.x -> jammy
Linux Mint 22.x --> noble

Speichert mit strg+o und beendet mit strg+x

Jetzt können wir Docker installieren:

sudo apt-get install docker-ce docker-ce-cli containerd.io

Damit ihr Docker Befehle ohne sudo verwenden könnt, fügt euren aktuellen Benutzer zur docker Gruppe hinzu:

sudo usermod -aG docker $USER

Docker Images

Fertige Docker Images

Docker Images sind das Herzstück von Docker. Sie bilden die Grundlage, auf der Container erstellt werden, und enthalten alles, was eine Anwendung oder ein Dienst benötigt, um lauffähig zu sein. Es gibt zwei Hauptwege, um mit Images zu arbeiten: fertige Images nutzen oder eigene Images erstellen (builden). Viele Github Projekte stellen alle nötigen Dateien bereit, um aus dem Repo auch ein fertiges Image zu bauen, um z.B. es an seine Bedürfnisse anpassen zu können.

Docker bietet eine zentrale Plattform namens Docker Hub, auf der eine Vielzahl an fertigen Images verfügbar ist.

Vorteile fertiger Images:

• Zeiteinsparung: Images für viele gängige Anwendungen wie Webserver (nginx, apache), Datenbanken (mysql, postgres), Programmiersprachen (python, node) und mehr sind sofort einsatzbereit.
• Community-Support: Viele dieser Images werden aktiv gepflegt, und die Community stellt Updates bereit.
• Einfacher Einstieg: Sie eignen sich besonders für Anfänger, die Docker ausprobieren wollen, ohne sich mit komplexen Setups beschäftigen zu müssen.

Nutzung eines fertigen Images als Syntax:

docker pull <image-name> # Image von Docker Hub herunterladen 
docker run <image-name> # Container aus dem Image starten 

Beispiele:

docker pull nginx # Webserver-Image herunterladen 
docker run -d -p 8080:80 nginx # Webserver im Hintergrund starten

Plattformen für Images:
Neben Docker Hub gibt es auch andere Repositories, z. B.:

• Quay.io: Eher für Unternehmen und Open-Source-Projekte.
• GitHub Container Registry (GHCR): Ermöglicht das Speichern und Teilen von Container-Images direkt auf GitHub.
• Private Registries: Unternehmen hosten oft ihre eigenen Repositories für interne Anwendungen.

Eigene Docker Images erstellen (Builden)

Manchmal reicht ein fertiges Image nicht aus, z. B. wenn du spezielle Anpassungen oder zusätzliche Software benötigst. In solchen Fällen kannst du dein eigenes Image erstellen.

Dockerfile
Ein Dockerfile ist eine einfache Textdatei, die die Schritte definiert, um ein Image zu bauen. Es enthält Anweisungen, wie ein Basis-Image erweitert wird.
Beispiel eines Dockerfiles:

# Basis-Image wählen
FROM python:3.9-slim

# Arbeitsverzeichnis setzen
WORKDIR /app

# Abhängigkeiten kopieren und installieren
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Anwendung kopieren
COPY . .

# Startbefehl definieren
CMD ["python", "app.py"]

In diesem Beispiel bauen wir das Docker Image dann so:

Image bauen Syntax:
Mit dem Dockerfile könnr ihr ein eigenes Image erstellen:

docker build -t <image-name> <path-to-dockerfile> 

Beispiel:

docker build -t my-python-app . 

Der Punkt am Ende des Befehls (.) steht für das aktuelle Verzeichnis, in dem das Dockerfile liegt.

Image hochladen (pushen) Syntax:
Wenn das Image fertig ist, könnt ihr es in ein Repository hochladen, um es mit anderen zu teilen oder auf anderen Systemen zu nutzen:

Syntax:

docker push <repository>/<image-name>:<tag> 

Beispiel:

docker push myusername/my-python-app:latest

Wann sollte man eigene Images bauen

1. Anpassungen nötig: Wenn ein fertiges Image nicht deinen spezifischen Anforderungen entspricht, z. B. zusätzliche Pakete oder Konfigurationen.
2. Sicherheit: Eigene Images bieten mehr Kontrolle darüber, was im Container enthalten ist.
3. Eigene Software: Wenn ihr proprietäre Anwendungen oder Skripte in einem Image verpacken möchtest.
4. Optimierung: Ihr könnt ein Image optimieren, um es kleiner und effizienter zu machen.

1. Verwende schlanke Basis-Images: Images wie alpine oder debian-slim minimieren die Größe und Angriffsfläche.
2. Reduziere Layer: Kombiniere ähnliche Anweisungen (z. B. RUN apt-get update && apt-get install -y).
3. Vermeide unnötige Dateien: Nutze .dockerignore, um temporäre Dateien oder Build-Artefakte auszuschließen.
4. Spezifische Tags verwenden: Anstatt python:latest zu nutzen, wählt python:3.9-slim für mehr Konsistenz.

Docker Images sind ein flexibles Werkzeug, das sowohl Einsteigern als auch Profis erlaubt, Anwendungen effizient bereitzustellen. Egal, ob ihr fertige Images nutzt oder eigene baut – Docker macht den Prozess relativ einfach und zuverlässig!

Docker Images aus GitHub Repositories bauen

Neben lokalen Dockerfiles könnt ihr auch Images direkt aus einem GitHub-Repository erstellen. Dies ist besonders nützlich, wenn das Repository bereits ein Dockerfile enthält oder eine komplexe Anwendung definiert ist. Hier sind die wichtigsten Methoden, wie ihr Images aus einem GitHub-Repository bauen könnt:

1. Direkt mit Docker CLI aus einem GitHub-Repository bauen

Docker kann ein Repository direkt als Quelle verwenden, wenn es ein Dockerfile enthält.

Syntax:

docker build -t <image-name> https://github.com/<username>/<repository>.git

Beispiel:

docker build -t my-app https://github.com/myusername/my-repo.git

Docker lädt das Repository herunter, sucht nach einem Dockerfile im Root-Verzeichnis und baut das Image basierend darauf.

Branch oder Tag angeben:
Wenn das Repository mehrere Branches oder Tags hat, könnt ihr einen bestimmten Branch oder ein bestimmtes Tag angeben:

Syntax:

docker build -t <image-name> https://github.com/<username>/<repository>.git#<branch-or-tag> 

Beispiel:

docker build -t my-app https://github.com/myusername/my-repo.git#master

2. Manuelles Klonen und Bauen

Wenn ihr das Repository nicht direkt von Docker oder automatisierten Tools aus zugänglich machen wollt, könnt ihr es auch manuell klonen und lokal bauen.

Schritte:

1. Klont das Repository: git clone https://github.com/<username>/<repository>.git
2. Wechselt in das Verzeichnis: cd <repository>
3. Baut das Image: docker build -t <image-name> .

Worauf sollte man achten

1. Position des Dockerfiles: Das Dockerfile sollte sich idealerweise im Root-Verzeichnis des Repositories befinden. Ansonsten könnt ihr den Pfad explizit angeben, z. B.: docker build -t <image-name> -f <path-to-dockerfile> <repository-url>
2. Build-Kontext: Wenn das Dockerfile auf andere Dateien im Repository zugreifen muss (z. B. Quellcode oder Konfigurationsdateien), stelle sicher, dass der Build-Kontext korrekt definiert ist.
3. Secrets und Umgebungsvariablen: Falls euer Dockerfile Zugang zu Secrets oder API-Keys benötigt, sollten diese sicher gehandhabt werden. Verwende keine harten Codierungen im Dockerfile.

Mit diesen Optionen könnt ihr flexibel Docker Images aus GitHub-Repositories bauen, entweder lokal oder vollständig automatisiert. Das ermöglicht es euch, Anwendungen schnell bereitzustellen und nahtlos zu aktualisieren!

Was ist ein Docker Container

Ein Container ist eine laufende Instanz eines Images. Er stellt eine isolierte Umgebung dar, in der Anwendungen unabhängig von der Umgebung des Hosts ausgeführt werden können.

Warum Container?
Container teilen sich den Kernel des Hosts, benötigen daher weniger Ressourcen als virtuelle Maschinen und starten blitzschnell.

Grundlegende Befehle:

docker run <image-name> # Einen Container starten 
docker ps # Aktive Container anzeigen 
docker ps -a # Alle Container anzeigen (inkl. gestoppte) 
docker stop <container-id oder name> # Container stoppen 
docker rm <container-id> # Container löschen

Docker Volumes

Volumes bieten persistenten Speicher für Daten, die über die Lebensdauer eines Containers hinaus erhalten bleiben sollen.

Warum Volumes?
Daten in einem Container gehen verloren, wenn der Container gelöscht wird. Mit Volumes kannst du Daten unabhängig von Containern speichern.

Befehle:

docker volume create <name> # Neues Volume erstellen 
docker volume ls # Liste aller Volumes anzeigen 
docker run -v <volume-name>:<container-path> <image-name> # Container mit Volume starten 
docker volume inspect <name> # Details zu einem Volume anzeigen

Docker Compose

Docker Compose ermöglicht es, mehrere Container mit einem einzigen YML-File zu definieren und zu starten.

Warum Compose?
Ideal für komplexe Anwendungen mit mehreren Diensten (z. B. Webserver, Datenbank und Backend), die koordiniert starten und miteinander kommunizieren sollen.

Grundlegendes Beispiel (docker-compose.yaml):

version: '3.8'
services:
  web:
    image: nginx
    ports:
      - "8080:80"
  db:
    image: mysql
    environment:
      MYSQL_ROOT_PASSWORD: example

Befehle

docker compose up -d # Dienste starten 
docker compose down # Dienste stoppen

Die docker-compose.yml muss in dem Verzeichnis liegen, indem der docker compose Befehl ausgeführt wird. docker-compose.yml ist ein Standardname, die Befehle reagieren starten die Container nur, wenn das File auch wirklich docker.compose.yml heisst. Hat es einen anderen Namen, zum Beispiel docker-compose_variant.yml lautet der Syntax:

docker compose -f docker.compose_variant.yml up -d

Mit Docker Compose ein Image Builden

Manchmal möchtet ihr ein Docker-Image nicht direkt aus einem Repository wie Docker Hub beziehen, sondern aus einem GitHub-Repository erstellen. Dies ist besonders nützlich, wenn ihr das Dockerfile eines Repos anpassen oder lokal ein eigenes Image auf Basis des Codes bauen möchtet.

Docker Compose ermöglicht es dir, den Build-Prozess direkt zu definieren, anstatt ein bereits fertiges Image zu verwenden.

Grundlegendes Setup: Docker Compose mit GitHub-Repository

Docker Compose kann ein Image direkt aus einem GitHub-Repository bauen, indem ihr die Option build verwendet. Das GitHub-Repository wird dabei als Build-Kontext definiert.

Beispiel: docker-compose.yaml

version: '3.8'

services:
  my-app:
    build:
      context: https://github.com/<username>/<repository>.git
      dockerfile: Dockerfile   # Optional: Pfad zum Dockerfile im Repo
    container_name: my-custom-app
    ports:
      - "8080:80"
    environment:
      - APP_ENV=production
    restart: always

Erklärung der Parameter

1. build mit context:
   • context kann eine lokale Verzeichnisstruktur oder eine URL zu einem GitHub-Repository sein.
   • Docker lädt das Repository herunter und sucht nach dem Dockerfile im Root-Verzeichnis.
   • Ihr könnt auch ein alternatives Dockerfile im Repository angeben.
2. dockerfile (optional):
   Wenn das Dockerfile nicht im Root-Verzeichnis des Repos liegt, gib den Pfad explizit an: build: context: https://github.com/<username>/<repository>.git dockerfile: path/to/Dockerfile
3. ports:
   Bindet den Port des Containers an den Host, damit die Anwendung erreichbar ist.
4. environment:
   Setzt Umgebungsvariablen im Container.
5. restart:
   Stellt sicher, dass der Container nach einem Fehler oder Neustart automatisch neu gestartet wird.

Image lokal bauen und ausführen

1. Starte den Build-Prozess mit Docker Compose: docker-compose up --build
   • --build stellt sicher, dass das Image aus dem GitHub-Repository neu gebaut wird.
2. Im Hintergrund ausführen (detached mode): docker-compose up -d --build
3. Status prüfen: docker-compose ps

Anpassungen vornehmen

Wenn ihr Änderungen an der Anwendung vornehmen möchtet, könnt ihr:

1. Das GitHub-Repository forken und das Dockerfile nach euren Anforderungen anpassen.
2. Den Pfad zu eurem eigenen Repository im docker-compose.yml anpassen: build: context: https://github.com/<dein-username>/<forked-repo>.git

Beispiel für ein erweitertes Setup

Falls das Repository mehrere Services oder Builds enthält, könnt duihrmehrere Services definieren, die unterschiedliche Build-Kontexte verwenden:

yamlCode kopierenversion: '3.8'

services:
  web:
    build:
      context: https://github.com/myusername/web-repo.git
    ports:
      - "8080:80"
    restart: always

  api:
    build:
      context: https://github.com/myusername/api-repo.git
      dockerfile: api.Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production

Mit Docker Compose könnt ihr Images direkt aus einem GitHub-Repository bauen, ohne sie vorher manuell herunterzuladen. Diese Methode ist ideal, wenn ihr:

• das Dockerfile eines öffentlichen Repos nutzen möchtet,
• eigene Anpassungen in einem Fork oder lokalen Clone vornehmen wollt,
• mehrere Services mit verschiedenen Builds orchestrieren musst.

Der build-Befehl in Docker Compose ermöglicht einen nahtlosen und automatisierten Workflow, der sowohl für Entwicklungs- als auch Produktionsumgebungen geeignet ist.

Docker Network Modes und ihre Auswirkungen

Docker bietet verschiedene Netzwerkmodi, die festlegen, wie ein Container mit dem Host und anderen Containern kommuniziert. Diese Modi beeinflussen den Zugriff auf Dienste und die Sicherheit. Hier sind die wichtigsten Netzwerkmodi und ihre Verwendung – sowohl mit dem docker run-Befehl als auch in einer docker-compose.yml.

1. Bridge Mode (Standard)

Im Bridge-Modus wird ein Container mit einem isolierten virtuellen Netzwerk verbunden. Container im gleichen Bridge-Netzwerk können miteinander kommunizieren, aber standardmäßig nicht direkt auf den Host zugreifen.

Docker Run Beispiel: docker run --network bridge -d nginx Hier nutzt der Container das Standard-Bridge-Netzwerk, das Docker bei der Installation erstellt.

docker-compose.yml Beispiel:

version: "3.8"
services:
  web:
    image: nginx
    networks:
      - my_bridge_network

networks:
  my_bridge_network:
    driver: bridge

Auswirkungen:

• Container kommunizieren über private IP-Adressen im Bridge-Netzwerk.
• Zugriff von außen auf den Container erfordert Port-Mapping, z. B. -p 8080:80. docker run --network bridge -p 8080:80 -d nginx

Der Container ist also auf Port 8080 erreichbar, benutzt aber intern im Container den Port 80

2. Host Mode

Im Host-Modus nutzt der Container direkt das Netzwerk des Hosts. Er hat keine eigene virtuelle Netzwerkschnittstelle, sondern teilt sich die Netzwerkkonfiguration mit dem Host.

Docker Run Syntax: docker run --network host -d nginx

docker-compose.yaml Beispiel:

version: "3.8"
services:
  web:
    image: nginx
    network_mode: host

Auswirkungen:

• Der Container hat direkten Zugriff auf das Host-Netzwerk. Dienste laufen auf den gleichen Ports wie der Host. Hört Nginx im Container auf Port 80, ist dieser auch nur über Port 80 erreichbar.
• Kein Port-Mapping erforderlich – der Dienst ist direkt auf dem Host-Port verfügbar.
  Beispiel: Ein Nginx-Container auf Port 80 ist unter http://localhost erreichbar.
• Einschränkungen: Keine Isolation – alle Dienste im Container sind direkt auf dem Host zugänglich, was die Sicherheit reduziert.

3. None Mode

Im None-Modus hat der Container keine Netzwerkschnittstelle. Er kann nur auf lokale Ressourcen zugreifen.

• Docker Run Beispiel: docker run --network none -d nginx
• docker-compose.yml Beispiel: version: "3.8" services: web: image: nginx network_mode: none
• Auswirkungen:
  • Der Container ist vollständig vom Netzwerk isoliert.
  • Keine Kommunikation mit anderen Containern oder dem Host.
  • Nützlich für Anwendungen, die keinen Netzwerkzugriff benötigen (z. B. Datenverarbeitung).

4. Container Mode

Im Container-Modus teilt sich ein Container das Netzwerk eines anderen Containers.

Docker Run Syntax:

docker run --network container:<container-name-or-id> -d nginx

Beispiel:

docker run --name web1 -d nginx docker run --network container:web1 -d my-app

docker-compose.yaml Beispiel:

version: "3.8"
services:
  app:
    image: my-app
    network_mode: service:web
  web:
    image: nginx

Auswirkungen:

• Die beiden Container teilen sich IP-Adresse und Ports.
• Nützlich, wenn mehrere Dienste dieselbe Netzwerkkonfiguration benötigen.
• Kein Port-Mapping erforderlich – Ports des ersten Containers werden auch für den zweiten verwendet.

5. Overlay Mode

Der Overlay-Modus ist für Swarm- oder Kubernetes-Cluster gedacht. Er verbindet Container auf verschiedenen Hosts über ein verteiltes Netzwerk.

docker-compose.yaml Beispiel:

version: "3.8"
services:
  web:
    image: nginx
    networks:
      - my_overlay_network

networks:
  my_overlay_network:
    driver: overlay

Auswirkungen:

• Ermöglicht die Kommunikation zwischen Containern auf verschiedenen Hosts.
• Voraussetzung: Docker Swarm oder ein anderes Orchestrierungstool muss aktiviert sein.

6. Macvlan Mode

Im Macvlan-Modus erhält der Container eine eigene IP-Adresse im selben Netzwerk wie der Host. Der Container erscheint für andere Geräte im Netzwerk wie ein eigenständiges Gerät.

Docker Run Beispiel:

docker network create -d macvlan \
  --subnet=192.168.1.0/24 \
  --gateway=192.168.1.1 \
  -o parent=eth0 macvlan_net

docker run --network macvlan_net -d nginx

docker-compose.yaml Beispiel:

version: "3.8"
services:
  web:
    image: nginx
    networks:
      my_macvlan_network

networks:
  my_macvlan_network:
    driver: macvlan
    driver_opts:
      parent: eth0
    ipam:
      config:
        - subnet: 192.168.1.0/24
          gateway: 192.168.1.1

Auswirkungen:

• Der Container hat eine eigene IP-Adresse im Netzwerk.
• Direkter Zugriff von anderen Geräten im Netzwerk möglich, ohne Port-Mapping.
• Sicherheit: Keine Isolation zwischen Containern im gleichen Netzwerk.

Zusammenfassung der Modi und deren Auswirkungen

Mit diesen Netzwerkmodi könnt ihr die Kommunikationsanforderungen eurer Container flexibel anpassen – von vollständiger Isolation bis hin zu direktem Zugriff auf das Host-Netzwerk!

Zusammenspiel der Docker Komponenten

Die genannten Bausteine greifen nahtlos ineinander:

• Ein Image dient als Vorlage.
• Der Container führt die Anwendung aus.
• Ein Netzwerk verbindet Container miteinander.
• Volumes speichern Daten dauerhaft.
• Mit Compose orchestrierst du komplexe Setups.

Aufräumen in Docker: Platz schaffen und Ressourcen verwalten

Beim Arbeiten mit Docker sammeln sich schnell nicht mehr benötigte Images, Container, Volumes und Netzwerke an. Diese verbrauchen Speicherplatz und können die Übersicht erschweren. Docker bietet eine Reihe von Befehlen, um das System aufzuräumen und effizient zu halten.

1. Ungenutzte Ressourcen aufräumen:

Der Befehl docker system prune ist die einfachste Möglichkeit, das gesamte Docker-System aufzuräumen. Er entfernt nicht genutzte Container, Images, Netzwerke und Volumes. Docker system prune löscht wie gesagt zusammen alles, was aktuell nicht in Verwendung ist (ausser Volumes auf dem Host) . Wer einzelne Komponente löschen will, liesst unten im nächsten Abschnitt weiter.

• Befehl: docker system prune
• Erweiterte Version (ohne Bestätigung): docker system prune -f
• Inklusive Volumes:
  Standardmäßig werden ungenutzte Volumes nicht entfernt. Um diese ebenfalls zu löschen: docker system prune --volumes
• Was wird entfernt?
  • Gestoppte Container
  • Nicht verwendete Netzwerke
  • Dangling Images (verwaiste Images ohne Tags)
  • Ungenutzte Build-Caches
  • (Optional) Nicht referenzierte Volumes

Beispiel-Ausgabe:

WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all dangling images
  - all build cache
Are you sure you want to continue? [y/N]

2. Alte oder ungenutzte Docker-Images löschen

Oft bleiben alte oder ungenutzte Images im System, die Speicherplatz belegen.

• Dangling Images entfernen:
  Dangling Images sind Images ohne Tags und werden beim Erstellen neuer Images oft als Zwischenstufen erzeugt. docker image prune
• Alle ungenutzten Images löschen:
  Achtung: Dies entfernt alle Images, die momentan nicht in Verwendung sind. docker image prune -a
• Liste aller Images anzeigen (zur Übersicht): docker images

3. Nicht verwendete Container löschen

Gestoppte Container verbleiben standardmäßig im System. Diese könnt ihr gezielt oder gebündelt löschen.

• Einzelne Container löschen: docker rm <container-id>
• Alle gestoppten Container löschen: docker container prune
• Liste der Container anzeigen (inklusive gestoppter): docker ps -a

4. Nicht verwendete Netzwerke löschen

Docker erstellt bei jedem Containerstart automatisch Bridge-Netzwerke, die manchmal ungenutzt bleiben.

• Alle ungenutzten Netzwerke löschen: docker network prune
• Einzelnes Netzwerk löschen: docker network rm <network-name>
• Netzwerkliste anzeigen: docker network ls

5. Nicht verwendete Volumes löschen

Docker Volumes speichern persistente Daten. Nicht mehr referenzierte Volumes können Speicherplatz verbrauchen.

• Alle ungenutzten Volumes löschen: docker volume prune
• Einzelnes Volume löschen: docker volume rm <volume-name>
• Liste der Volumes anzeigen: docker volume ls

Zusammenfassung der wichtigsten Befehle

Automatisches Aufräumen mit einem Zeitplan

Ihr könnt die Aufräum-Befehle automatisieren, indem ihr sie in einem Cronjob einrichtet. Zum Beispiel mit dem Befehl crontab -e als sudo user:

• Cronjob für tägliches Aufräumen: 0 3 * * * docker system prune -f --volumes

Dies führt den Befehl jeden Tag um 3 Uhr morgens aus und räumt ungenutzte Ressourcen auf.

Fazit

Docker bietet eine leistungsstarke und flexible Plattform, die die Art und Weise revolutioniert, wie Anwendungen entwickelt, getestet und bereitgestellt werden. Die vorgestellten Grundlagen – Images, Container, Netzwerke, Volumes und Docker Compose – bilden das Fundament, um mit Docker effizient zu arbeiten.

Docker erleichtert nicht nur den Einstieg in die Container-Technologie, sondern bietet auch Lösungen für alltägliche Probleme: Sei es die Konsistenz zwischen Entwicklungs- und Produktionsumgebungen, die schnelle Bereitstellung von Anwendungen oder das Experimentieren mit neuen Technologien ohne Risiko.

Für Entwickler, Administratoren und auch für IT-Einsteiger ist Docker der Schlüssel zu mehr Effizienz und weniger Frust bei der Arbeit mit Software. Mit den hier vorgestellten Grundlagen bist seid ihr bereit, eigene Anwendungen zu containerisieren, die ersten Container zu starten und die Vorteile der modernen Softwareentwicklung voll auszuschöpfen.