Umstieg von MAMP auf Docker

Warum XAMP nicht die beste Lösung ist

XAMP und andere fertige Webserver haben den Nachteil, dass diese aus dem eigenen Rechner einen komplexen Webserver erstellen. Dieser kann durch viele äußere Faktoren beeinflusst werden (Systemkonfigurationen oder -updates). Selten arbeitet man mit dem gleichen Betriebssystem oder der gleichen Rechnerausstattung. Dieses kann in der späteren produktivumgebung zu Speicherproblmen oder Ressourcenenpässen führen.

Warum sollte man die Entwicklungsumgebung virtualisieren

Für die Kapselung seines Entwicklungsystem gibt es mehrere gute Gründe:

Kapselung des Entwicklungssystem von dem Betriebssystem
Kapselung der einzelnen Projekte untereinander
Konsistentes System, das nicht durch Systemupdates beeinflusst wird
Genaue Wiederspiegelung der unterschiedlichsten Produktivsysteme
Komplette Versionierung der Webanwendung und Serverkonfiguration möglich
Zurücksetzen des Entwicklungsystem und festhalten von verschiedenen Zuständen
Einfaches Austauschen einzelner Komponenten (PHP Version) ohne tieferes Hintergrundwissen durch fertige Kochbücher und Vorlagen

Was ist Docker

Docker ist ein Kommandozeilen Tool, das virtuelle Maschinen erstellen und verwalten kann. Die Konfiguration wird über eine Dockerfile Datei festgelegt. Hier werden die einzelnen Komponenten definiert, die in der virtuellen Maschinen laufen sollen. Dabei unterscheidet Docker zwischen Images, Layer und Containern.

Images

Ein Image ist vielleicht der bekannteste Begriff. Es ist ein genaues Abbildung eines Rechners mit den Einstellungen und Programmen.

Layer

Ein Layer ist übersetzt eine Schicht, die in der Docker Welt ein wichtiger Bestandteil des Konzept ist. Jeder Layer für sich ein eigenes Image das auf ein bestehendes Image Erweiterungen hinzufügt.

Container

Ein Container ist ein lauffähiger virtueller Rechner, der aus einen Image erstellt wird.

Öffentliche Images

Über den pull Befehl können vorhanden Images von externen Server (z.B. dockerhub) geladen werden.

docker pull IMAGENAME

Aus den Image kann über den create Befehl ein neuer Container erstellt werden.

docker create IMAGENAME

Starten lässt sich der Container über den start Befehl.

docker start IMAGENAME

Zum Stoppen gibt es einen analogen stop Befehl, dieser muss über ein neues Terminal ausgeführt werden.

docker stop IMAGENAME

Nach den Laden eines Images lassen sich der create und start Befehl auch über ein run kombinieren.

docker run IMAGENAME

Falls man mehrere Container im Hintergrund starten möchte, kann man über den Parater -d den Container im detached Modus starten. Über attach landet man wieder in der Prozess Konsole des Containers. Der Parameter --sig-proxy=false erlaubt das Ausklinken aus dem Prozess mittels Ctrl + C.

docker run -d IMAGENAME
docker attach --sig-proxy=false IMAGENAME

Für temporäre Container, die nach der Ausführung wieder gelöscht werden können, gibt es den Parameter --rm.

docker run -d --rm IMAGENAME

Beim Starten von Anwendung und während der Laufzeit werden einige Ausgaben in der Konsole ausgegeben. Diese lassens sich über den logs Befehl anzeigen. Der Parameter -t sorgt dafür, dass die Zeiten des Log Eintrags angezeigt werden.

docker logs -t IMAGENAE

Eigene Images

Einfache Anwendung definieren

Die Vorlage für ein späteres Image werden in einem Dockerfile hinterlegt.

Folgendes Dockerfile definiert ein einfaches Image mit einem Arbeitsordner /var/www. Es baut auf den bestehenden Image von debian:jessie auf und fügt einen neuen Layer über WORKDIR ... hinzu.

FROM debian:jessie

WORKDIR /var/www

Über den Build befehl wird anschließend das Image erstellt:

docker build -t testimage .

Komplexe Anwendung definieren

Komplexere Anwendungen, die aus mehreren Containern bestehen lassen sich über eine docker-compose.yml Datei definieren.

code:
    image: core23/symfony-code
    volumes:
        - ./code:/var/www
        - ./var/logs/symfony:/var/www/app/logs
    tty: true

db:
    image: mysql:5.5
    ports:
         - 3306:3306
    environment:
        MYSQL_ROOT_PASSWORD: root
        MYSQL_DATABASE: db
        MYSQL_USER: symfony
        MYSQL_PASSWORD: symfony

php:
    image: core23/symfony-php
    expose:
        - 9000
    links:
        - db
    volumes_from:
        - code

nginx:
    image: core23/symfony-nginx
    ports:
        - 8080:80
    links:
        - php
    volumes_from:
        - code
    volumes:
        - ./var/logs/nginx/:/var/log/nginx

Nginx: Ist ein PHP Webserver
PHP-FPM: Ist eine PHP Compiler der von Nginx genutzt wird
MySQL: Die Datenbank

Eigenschaften der einzelnen Container

image: Gibt das Image / die Vorlage an, auf dem der Container aufbaut
ports: Gibt die Ports an, die der Container nach außen zur Verfügung stellt (offener Port nach draußen : interner Port der Anwendung)
expose: Ähnlich wie Ports, nur dass diese Ports nur zwischen den Containern zur Verfügung stehen.
links: Verbindet einen Container mit einem (oder mehreren) anderen
volumes: Teilt einen Ordner des Containers mit dem Host Betriebssystem (Betriebssystem Pfad: Container Pfad)
volumes_form: Ähnlich wie volumes, nur das Ordner zwischen einzelnen Container geteilt werden.
environment: Legt Umgebungsvariablen fest
tty: Erlaubt den Zugriff via Terminal

Weitere Infos in der offiziellen Dokumentation.

Die fertige Anwendung lässt sich außerdem auch bei GitHub ansehen: symfony-docker.

Starten des Servers

Der konfigurierte Server lässt sich durch einen einfachen Befehl starten. Der erste Aufruf kann ein paar Minuten dauern, da die einzelnen Systemkomponenten aus dem Internet geladen und installiert werden müssen.

docker-compose up -d

Der Paramter -d lässt den Prozess im Hintergrund laufen, sodass man weitere Befehle absetzen kann.

Stoppen des Servers

docker-compose stop

Hilfereiche Befehle

Eigenschaften eines Images

docker run --rm IMAGE env

CPU Auslastung

docker stats $(docker ps -q)

Alle Container beenden

docker kill $(docker ps -q)

Container und Images entfernen

docker rm $(docker ps -a -q)
docker rmi $(docker images -q)

Imagebaum anzeigen

In alten Version gab es ein internen Befehl um den den Baum der Images anzuzeigen

docker images --tree

Seit einigen Version wurde der Befehl entfernt. Es gibt allerdings ein öffentliches Images das die gleiche Ausgabe anzeigen kann:

docker run --rm -v /var/run/docker.sock:/var/run/docker.sock nate/dockviz images -t

Docker aktualiseren

Die aktuelle Version von Docker lässt sich über den folgenden Befehl anzeigen.

docker version

Client aktualiseren

Ein Updates des Docker Clients ist aktuell nur über eine Neuinstallation der Docker Toolbox möglich.

Server aktualisieren

docker-machine upgrade default

Tipps & Tricks

composer als Docker Image

Um composer komforatable zu benutzen kann man dieses natürlich auch virutalisieren als Docker Image und einen Alias auf diesen erstellen damit man von überall auf composer zugreifen kann.

alias composer="docker run --rm -it -v \$PWD:/usr/src/app -v ~/.composer:/root/.composer -v ~/.ssh:/root/.ssh:ro graze/composer"