Docker

Das Prinzip von Docker ist einfach: Die Anwendung wird mit allem was sie braucht, in einen Container gepackt und läuft so auf jedem System, auf dem Docker läuft.

Aber ist das nicht das, was man mit Virtualisierung erreicht?

Ja, an sich schon. Dockercontainer teilen sich allerdings den Kernel mit dem Hostsystem und sind so um ein Vielfaches schlanker und ressourcensparender. Ein Apache-Container verbraucht so nur unwesentlich mehr Ressourcen als die native Anwendung auf dem Hostsystem.

Aber wenn der Container doch mehr Ressourcen als die native Anwendung verbraucht, warum sollte ich dann Container nutzen?

Darauf gibt es keine universelle Antwort. Wenn die Anwendung z.B. nur aus statischen Inhalten besteht, macht es wenig Sinn, diese in einen Container zu packen. Mit Containern ist es allerdings möglich, einzelne Anwendungen isoliert voneinander laufen zu lassen.

Wenn eine Anwendung z.B. noch PHP 5.4 braucht, die andere aber schon PHP 7.0, könnte man beide in einen Container packen und sie würden sich nicht in die Quere kommen.

Außerdem lassen sich Anwendungen mittels Dockercontainern sehr einfach skalieren, dazu später mehr.

Im Folgenden wollen wir uns damit beschäftigen, wie man eine Anwendung mit PHP und Datenbank in einen Container packt und diese dann auf einem Server laufen lässt.

Hier soll es um die Installation von Docker auf einem Debian 8 (bzw. Ubuntu) System gehen. Für die Installation auf anderen Systemen siehe https://docs.docker.com/engine/getstarted/step_one/

Für die Installation braucht man mindestens einen Kernel der Version 3.10 - Überprüfen lässt sich das mittels

uname -r

1. Diverse Pakete installieren, um den GPG-Schlüssel hinzuzufügen:

$ sudo apt-get install \
     apt-transport-https \
     ca-certificates \
     curl \
     software-properties-common

2. Docker's GPG key hinzufügen:

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -

3. Docker's „stable“-Repository hinzufügen:

$ sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/debian \
   $(lsb_release -cs) \
   stable"

4. Einmal updaten und dann Docker CE (Community Edition) installieren:

sudo apt update && sudo apt install docker-ce

5. Docker sollte jetzt installiert sein. Um das zu testen, folgendes Kommando ausführen:

sudo docker run hello-world

Es sollte nun ein Container gestartet werden, welcher eine „Willkommen“ Nachricht anzeigt.

Ein Dockercontainer besteht immer aus einem sogenannten Image. In diesem Image ist alles drin, was man zum starten eines Containers braucht. Diese Images kann man entweder direkt von Docker Hub herunterladen und ausführen, oder selbst erstellen und nur lokal ausführen. Docker Hub ist eine Art Registry, in der man eigene Images hoch- und die anderer Nutzer herunterladen kann (Es ist auch möglich, sein eigenes Registry zu hosten).

Images von Nutzern erkennt man an der Form des Namens „nutzer/image“ wohingegen offizielle Images nur aus dem Namen bestehen. (Offizielle Images werden offiziell von den Entwicklern unterstützt und supportet).

Um ein Image herunterzuladen und direkt zu starten, reicht folgendes Kommando:

docker run image

Mit

docker run hello-world

haben wir vorhin also das „hello-world“-Image heruntergeladen und ausgeführt.

Um das ganze mal greifbarer zu machen, hier ein Beispiel (Dieser Container zeigt nur seinen Hostnamen an, für unsere Zwecke ist das im Moment ausreichend):

docker run -d -p 8080:80 --name web tutum/hello-world

Die einzelnen Optionen erklärt:

-d: Der Container läuft im Hintergrund -p: Port 80 aus dem Container wird an den Host auf Port 8080 weitergereicht. Wenn man nun also <Host-IP>:8080 aufruft, bekommt man den Container. –name: Vergibt einen Namen für den Container, um ihn später einfach wiederzufinden. Ohne diese Option vergbt Docker automatisch einen zufälligen Namen.

Mit dem Kommando

docker ps

lassen sich alle Container anzeigen, die momentan laufen, mit

docker ps -a

alle Container inklusive allen, die nicht mehr laufen.

In unserem Beispiel sieht das dann ungefähr so aus:

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
404ccfd08a99        tutum/hello-world   "/bin/sh -c 'php-f..."   2 seconds ago       Up 1 second         0.0.0.0:8080->80/tcp   web

Das ist jetzt ja alles schön und gut, aber wie können wir denn nun mit Docker eine Website laufen lassen?

In Docker Hub gibt es ein fertiges PHP-Image mit Apache. Zum Ausprobieren erstellen wir uns eine index.php Datei mit folgendem Inhalt:

<?php
phpinfo();

Diese speichern wir irgendwo in einem eigenen Ordner ab (das wird noch wichtig).

Um den Apache-Container nun zu starten, führen wir dieses Kommando aus:

docker run -d -p 8080:80 -v /pfad/zum/ordner/mit/index.php:/var/www/html --name web php:7.0-apache

(Den Pfad natürlich entsprechend anpassen)

Die einzelnen Optionen erklärt:

-d: Der Container läuft im Hintergrund -p: Port 80 aus dem Container wird an den Host auf Port 8080 weitergereicht. Wenn man nun also <Host-IP>:8080 aufruft, bekommt man den Container. -v: Volumes. Damit lassen sich Ordner (oder nur einzelne Dateien) vom Host-System in den Container mounten. Ansonsten werden alle Dateien im Container abgelegt und gelöscht, wenn der Container gestoppt wird. –name: Vergibt einen Namen für den Container, um ihn später einfach wiederzufinden. Ohne diese Option vergbt Docker automatisch einen zufälligen Namen.

Mit dem Kommando

docker ps

lassen sich alle Container anzeigen, die momentan laufen, mit

docker ps -a

alle Container inklusive allen, die nicht mehr laufen.

In unserem Beispiel sieht das dann ungefähr so aus:

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                  NAMES
eeb079101976        php:7.0-apache      "docker-php-entryp..."   4 seconds ago       Up 2 seconds        0.0.0.0:8081->80/tcp   web

Wenn wir jetzt im Browser localhost:8080 aufrufen, sollten wir unsere vorhin erstellte phpinfo() sehen. Der Container funktioniert!

docker rm <name des containers>

Entfernt den Container. Dieser muss dazu gestoppt sein.

docker stop/start/restart <name des containers>

(neu-)Startet/Stoppt den Container

docker inspect <name des containers>

Zeigt einige nützliche Informationen über einen Container an, z.B. die vorhandenen Volumes.

Es ist ja schließlich nicht möglich, mehrere Container auf dem selben Port laufen zu lassen. Die müssen also auf verschiedenen Ports laufen. Um also für verschiedene Domains verschiedene Container anzusteuern, brauchen wir einen Proxy, der dann auf Port 80 (auf dem Hostsystem) lauscht und je nach Domain die Anfrage an den entsprechenden Container durchreicht. Wir machen das jetzt mal Beispielhaft mit NGINX (Apache würde natürlich auch gehen, NGINX ist allerdings schon „von Haus aus“ auf Loadbalancing ausgelegt und daher hier performanter als Apache)

Nach der Installation von NGINX legen wir eine Beispielhafte Konfiguration in /etc/nginx/sites-available/default an:

server {
   listen         80;
   server_name    example.com;

   location / {
      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_pass http://localhost:8080;
   }
}

Wenn jetzt jemand example.com aufruft, wird der Request an den Container durchgereicht. Der Websitebesucher merkt davon nichts.

Der Container-Port ist allerdings öffentlich zugänglich - man kann also von außen über jede IP (Und damit auch jede Domain, die auf diese zeigt) des Hostsystems und Port 8080 auf den Container zugreifen. Um das zu verhindern, starten wir den Container mit einem etwas veränderten -p-Flag:

docker run -d -p 127.0.0.1:8080:80 -v /pfad/zum/ordner/mit/index.php:/var/www/html --name web php:7.0-apache

Damit ist der Container immernoch auf Port 8080 erreichbar, aber nur innerhalb des Hostsystem - von Außen kommt man nicht mehr dran. Damit wird der Proxy spätestens zwingend notwendig.

Da der einzige Weg, den Container zu erreichen, über einen Proxy ist, kann man sich hier mittels SSL dazwischenschalten und die Website so verschlüsslen. Mittels NGINX geht das Beispielsweise so (Ein gültiges Zertifikat vorrausgesetzt - Im Beispiel mit Letsencrypt):

server {
   listen         80;
   server_name    example.com;
   return         301 https://$server_name$request_uri;
}

server {
   listen         443 ssl;
   server_name    example.com;

   ssl_certificate /etc/letsencrypt/live/domain.tld/fullchain.pem;
   ssl_certificate_key /etc/letsencrypt/live/domain.tld/privkey.pem;

   ssl_protocols TLSv1 TLSv1.1 TLSv1.2;

   ssl_session_cache shared:SSL:10m;
   ssl_session_timeout 30m;

   ssl_prefer_server_ciphers on;
   ssl_ciphers "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-SHA:ECDHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES256-GCM-SHA384:AES128-GCM-SHA256:AES256-SHA256:AES128-SHA256:AES256-SHA:AES128-SHA:DES-CBC3-SHA:HIGH:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4";

   ssl_stapling on;
   ssl_stapling_verify on;

   ssl_dhparam /etc/ssl/certs/dhparam.pem;

#   add_header Strict-Transport-Security "max-age=63072000;";

   # Logs werden auf dem Hostsystem gespeichert
   access_log  /var/log/nginx/docker-webapp_access.log;
   error_log   /var/log/nginx/docker-webapp_error.log;

   location / {
	proxy_buffers 16 4k;
        proxy_buffer_size 2k;

        proxy_read_timeout 300;
        proxy_connect_timeout 300;
        proxy_redirect     off;

        proxy_set_header   Host              $http_host;
        proxy_set_header   X-Real-IP         $remote_addr;
        proxy_set_header   X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header   X-Frame-Options   SAMEORIGIN;

        client_max_body_size 10G;

        proxy_pass http://127.0.0.1:8080;
   }
}

Im Beispiel wurden noch einige zusätzliche (sichere) SSL-Einstellungen vorgenommen, um die Gesamtsicherheit zu erhöhen, diese haben sich in der Praxis bewährt.

Unsere Website läuft also jetzt in einem Dockercontainer. Die meisten Websites benutzen heutzutage Datenbanken. Da Dockercontainer allerdings mehr oder weniger von der Außenwelt abgeschnitten sind, können sie nicht so ohne weiteres eine Verbindung zu z.B. einem Mysql-Server auf dem Hostsystem herstellen.

Nach dem Dockerprinzip sollten Container nur Sinnvolle Teile enthalten - die Datenbank sollte also in einem seperaten Container laufen

Um diese Verbindung zwischen unserem Website-Container und einem Datenbank-Container zu realisieren, brauchen wir zunächst einen Datenbankcontainer:

docker run -d --name db -v /var/www/webapp/db:/var/lib/mysql mariadb

Das Volume dient dazu, dass die Daten der Datenbank nicht verloren gehen, wenn der Container neugestartet wird.

Um diesen Container nun mit einem anderen zu verlinken, muss dieser mit dem –link Flag gestartet werden:

docker run -d -p 127.0.0.1:8080:80 --link db:db -v /pfad/zum/ordner/mit/index.php:/var/www/html --name web php:7.0-apache

Jetzt können wir aus dem Website-Container heraus auf die Datenbank via db (als Host angegeben) zugreifen.

Neurdings gibt es in Docker das „networks“-Feature. Damit lassen sich verschiedene Container in ein gemeinsames Netzwerk einsperren und können direkt über ihre Namen miteinander kommunizieren - ohne dass man das vorher explizit mit “–link“ angeben muss.

Im letzten Beispiel waren das einige Flags - bei einer Anwendung, die aus mehreren verschiedenen Containern besteht oder viele Volumes/Umgebungsvariablen (Man kann Umgebungsvariablen an den Container übergeben, um z.B. Standardpasswörter zu ändern) benutzt, kann es sehr schnell unübersichtlich werden.

Um dem entgegenzuwirken, gibt es Docker-Compose.

Installation erfolgt durch folgende Kommandos:

curl -L https://github.com/docker/compose/releases/download/1.12.0/docker-compose-`uname -s`-`uname -m` > ./docker-compose
mv ./docker-compose /usr/bin/docker-compose
chmod +x /usr/bin/docker-compose

Damit definiert man in einer docker-compose.yml-Datei die gesamte Webapp:

version: '2'
services:
  web:
    image: php:7.0-apache
    volumes:
      - /pfad/zum/ordner/mit/index.php:/var/www/html
    ports:
      - "127.0.0.1:8080:80"
    links:
      - db:db
    depends_on:
      - db
    restart: always
  db:
    image: mariadb
    restart: always
    environment:
      - MYSQL_ROOT_PASSWORD=ganzgeheimespasswort
    volumes:
      - /var/www/webapp/db:/var/lib/mysql

depends_on verhindert, dass der Container ohne die Datenbank startet. restart: always sorgt dafür, dass der Container immer neugestartet wird, wenn z.B. der Server neugestartet wird.

Starten lässt sich diese Kombination mit

docker-compose up -d

Dafür muss man sich im selben Ordner wie die docker-compose.yml-Datei befinden.

Dockercontainer machen erst so richtig Sinn, wenn man sie massenweise einsetzt. Das kann man manuell mit Shell-Skripten machen, oder man nutzt Tools wie Docker Swarm, Kubernetes oder Rancher, welche Containerorchestrierung wesentlich einfacher machen.