Docker Compose installieren – Der Compose File Guide

Wie kann ich eine Docker Compose ausführen und installieren?

Dieser Guide erklärt Dir es und wie Docker Compose funktioniert.

Starten wir!

Was ist Docker?

Mit Docker kannst Du vollwertige Software-Systeme / Hardware virtualisieren und Software voneinander abkapseln. Wir können verschiedene Versionen einer Software z. B. Python 2 und 3 auf dem gleichen Computer für verschiedene Programme ausführen. Statt neue echte Hardware zu kaufen, schafft es Docker verschiedenste Anwendungen parallel auf einer (potenten) Hardware auszuführen.

Im Gegensatz zu virtuellen Maschinen sind Docker-Container leichtgewichtiger und verbrauchen nicht so viel Ressourcen. Die Ressourcen müssen nicht fix zu Beginn genannt sein, sondern die Docker Engine weist den Containern die Ressourcen zu, welche diese zurzeit brauchen.

Der Computer (Host) entscheidet, welche Ressourcen und Hardware dem einzelnen Container zuweisbar sind. Die Containerisierung ermöglicht es, mehrere Instanzen desselben Programms auf einem Computer ohne eine gegenseitige Beeinflussung laufen zu lassen.

Docker Container basieren auf Docker Images (binäre Blobs), welche Du mit einem Terminal-Befehl hochfährst. Die Docker Images beinhaltet den kompilierten Code der Software, alle Software-Abhängigkeiten und ein Betriebssystem. Die Container nutzen ein konfigurierbares und virtualisiertes Netzwerk und Speichersysteme (Volumes).

Was ist eine Docker Compose?

Die Docker Compose ist eine optionale Darstellungsweise. Docker kannst Du ausschließlich über das Command Line Interface bedienen. Da ein Container häufig viele Parameter braucht, strukturiert die Docker Compose alle Parameter in eine Datei.

Ein Docker-Compose Datei speichert den Inhalt des Docker Kommandos ab. Eine Docker-Compose ist kein normales Shell-Script, sondern eine yml- / yaml-Datei, welche die notwendigen Parameter für das Hochfahren eines Dockers-Containers bereitstellt.

version: '3'
services:
  kiwix-serve:
    image: ghcr.io/kiwix/kiwix-serve:latest
    restart: always
    container_name: kiwix
    volumes:
      - /home/steffen/kiwix:/data
    ports:
      - 60100:8080
    networks:
      - default
    command:
      - '*.zim'

Der Entwickler muss nur noch docker-compose up tippen, um den Container zu starten und docker-compose down zu herunterfahren.

In einer Docker Compose kannst Du mehre Container gleichzeitig, Netzwerke, Speicher (Volumes) oder das Logging definieren.

Warum Docker Compose bevorzugen?

Diese Top 3 Gründe sollten Dich dazu bewegen, die Docker-CLI in den meisten Fällen links liegenzulassen:

Schon wieder was vergessen? – Persistent

Docker Container brauchen je nach Installation verschiedene Parameter. Schnell hast Du einen Parameter vergessen oder verlierst Dich in dem langen Kommando.

Das Dateiformat speichert das Kommando in einem lesbaren Format ab.

Tausende Snippets managen – Struktur

Docker Kommandos werden sehr schnell verwirrend. Eine Docker Compose kannst Du in eine Git-Repo abspeichern, um spätere Änderungen nachvollziehen zu können.

Die YAML macht den Chaoten einen Strich durch die Rechnung und jeder Aspekt ist einzeln strukturiert anzugeben.

Starten und Stopp-Automatik

Du möchtest einen oder mehrere Docker Container, Volumes und Netzwerke mit wenigen Tastenanschlägen starten und stoppen? So geht das …

docker-compose up

// und

docker-compose down

Installieren

Docker Windows

Laden Sie das statische Binärarchiv herunter. Rufen Sie https://download.docker.com/win/static/stable/x86_64 auf und wählen Sie die neueste Version aus der Liste aus.

Führen Sie die folgenden PowerShell-Befehle aus, um das Archiv zu installieren und in Ihren Programmdateien zu entpacken:

PS C:\> Expand-Archive /path/to/<FILE>.zip -DestinationPath $Env:ProgramFiles

Registrieren Sie den Dienst und starten Sie die Docker-Engine:

PS C:\> &$Env:ProgramFiles\Docker\dockerd --register-service

PS C:\> Start-Service docker

Überprüfen Sie, ob Docker korrekt installiert ist, indem Sie das „hello-world“-Image ausführen.

PS C:\> &$Env:ProgramFiles\Docker\docker run hello-world:nanoserver

Dieser Befehl lädt ein Test-Image herunter und führt es in einem Container aus. Wenn der Container läuft, gibt er eine Meldung aus und wird beendet.

Docker Linux

Für die Docker Compose brauchst Du erst einmal eine Docker Installation auf Deinem Computer. Hast Du ein Debian-basierendes System (Ubuntu, Linux Mint, PopOS usw.) gebe diese drei Scripte einfach ein:

1. Setup APT Rep

# Add Docker's official GPG key:
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

2. Installiere alles

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

3. Starte den ersten Container

sudo docker run hello-world

Docker-Compose

In Linux / Debian:

sudo apt-get update 
sudo apt-get install docker-compose-plugin

Docker Compose ist Teil von der Windows Version „Docker for Desktop“ und muss nicht nach installiert werden.

Die Docker Compose Datei

Die Docker-Compose Datei benennst Du in einem Git-Repo idealerweise immer docker-compose.yml. Dies ist der Standardname, welcher Docker immer sucht, wenn Du den Befehl docker-compose up tippst.

Die Datei beginnt mit einer Versionsnummer. Jede Version hat einen unterschiedlichen Funktionsumfang. In der Regel solltest Du die neuste verwenden, um alle verfügbaren Features zu nutzen:

version: "3.9"
services:
  adguardhome:
    container_name: adguardhome
    image: adguard/adguardhome
    restart: unless-stopped
    ports:
      - 53:53/udp
      - 81:80/tcp
      - 444:443/tcp
      - 853:853/tcp
      - 3000:3000/tcp
    volumes:
      - adguardconf:/opt/adguardhome/conf
      - adguardwork:/opt/adguardhome/work

volumes:
  adguardconf:
  adguardwork:

Unter dem Tag services definierst Du freie Namen für die Docker-Container, die Du laufen lassen willst. Starte mehrere Docker-Container in einer Compose-Datei, indem Du mehrere Images / Container angibst.

Images

Das Image pihole/pihole:latest ist vom Docker Hub frei verfügbar. Von dort kannst Du 100 Images am Tag downloaden.

Ports und Netzwerk

Dann folgen die Port-Freigaben nach dem Schema:

Host-Port(nach außen):Docker-Port(nach innen)/Transportprotokoll(tcp/udp)

Wenn Du den Netzwerk-Modus network-mode:hosts nutzt verhält sich der Docker Container wie eine native Anwendung und nimmt sich einfach die Ports, die notwendig sind. Docker arbeitet mit verschieden Netzwerk-Modi, die Du als Treiber angeben kannst:

• host: Keine Isolation zwischen den Container – wie ein Baremetal-Server
• bridge: Die Container können miteinander kommunizieren.
• overlay: Wenn Du Docker-Swarms miteinander verbinden willst, brauchst Du diese Form der Kommunikation.
• (weglassen): Unterbindet die Kommunikation hinein / heraus.

Umgebungsvariablen

Je nach Container brauchst Du noch eine Anzahl an Umgebungsvariablen. Dazu musst Du Dich mit der Doku der Software auseinandersetzen. Ein Container ist nicht persistent. Das bedeutet, dass Du alle Änderungen im Container verlierst, wenn Du den Container reinitialisierst. Die Umgebungsvariablen bleiben persitent, wenn diese in der Docker Compose bleiben.

Volumes

Die Volumes halten alle Daten, welche nach dem Neustart nicht verfallen dürfen. Ohne ein Docker-Volume setzt die Docker Engine die Anwendung während des Reinitalisierung zurück. Du kannst entweder Docker Volumes direkt in der .yml-Datei erstellen …

volumes:
  myfirstvolume:

… oder vorher mit einem Docker-Befehl:

docker volume create myfirstvolume

Du kannst die Speichersystem „Volumes“ alternativ in einen Ordner auf Dein Host-Dateisystem verankern. Dazu muss der Ordner vorhanden sein, welche Du in der Docker-Compose angibst:

/etc/pihole/

Eine Ordner-Verschachtlung kannst Du mit mkdir -p /etc/pihole/ erstellen.

Restart-Policy

Der Container hält sich an die Restart-Policy, wenn dieser abstürzt.

• always: Starte jedes Mal neu
• unless-stopped: Wie always nur beim expliziten Stop-Befehl ist der Container zu stoppen
• (weglassen): Kein Neustart
• on-failure: Wenn ein Fehler auftritt, dann startet der Container neu.

Integrations-Guide mit Docker Build

Eine Docker-Compose lässt sich mit einem Docker-Build verbinden. Die Dockerfile beschreibt, wie die Docker Engine aus dem Code, eine Build- und Run-Container ein fertiges Image erstellen kann.

Den Docker build startet man mit dem Start des Containers. Statt ein feritge Image image:xxxxx geben wir einen Zeiger auf die Dockerfile build:. an

image: pihole/pihole:latest

-->

build:.

Wenn der Code, die Dockerfile und das Docker-Compose im gleichen Ordner liegen, startet der Docker Image Build automatisch. Die Dockerfile kompiliert den Quellcode, baut das Image fertig und die Compose startet das Image mit allen Parameter, Volumens und Netzwerken. Genial!