Skip to content

DevEnv: Docker und AppServer

2015 April 26

Docker ist aktuell in aller Munde und das Ökosystem um Docker wächst kontinuierlich weiter. Somit lohnt sich mal ein genauerer Blick.
Ich werde hier schildern, wie ein Docker Image mit einem Application Server erstellt werden kann. Als Application Server werde ich WildFly verwenden, jedoch ist jegliche andere Software denkbar.

Überblick

Im einem Softwareprojekt strebt man an, dass alle Umgebungen (Entwicklung, Integration und Produktion) die selben Systeme, Versionen und Einstellungen besitzen. Dies kann man mit sehr genauen Installations- und Konfigurations-Anleitung bewerkstelligen. Jedoch ist der manuelle Aufwand hoch, genauso auch sehr fehleranfällig.
Eine andere Möglichkeit ist es, immer das selbe VM Image zu verwenden. Dies kann einheitlich erstellt werde und dann auf allen Umgebungen verwendet werden. Ein solches VM Image beinhaltet jedoch neben der für das Projekt benötigte Software auch mind. das Betriebssystem. Dieser Sachverhalt verursacht ein verhältnismäßig zu großes Artefakt, was dann auch nicht schnell mal auf einer neuen Umgebung kopiert und bereitgestellt werden kann.
Hier kommt dann Docker ins Spiel [1]. Docker kapselt die Software in einem Container und erwartet auf dem Host-System eine Docker Engine um den Container zum Laufen zu bringen. D.h. der Container beinhaltet nur die „projekt-relevanten“ Softwareprodukte. Dieser Container ist leichtgewichtiger als ein komplettes VM Image.
Einmal erstellt, können diese Docker Container überall eingesetzt werden können, wo ein Docker Engine zur Verfügung steht – für Windows-User gibt es hier auch eine Lösung ;-).

Im weiteren Verlauf werde ich die Einrichtung eines Docker Container beschreiben, welches einen Application Server (hier: WildFly) beinhaltet. Dieser Container wird nur den App Server und die restliche Software beinhalten (JDK etc.). In weiteren Beiträgen werde ich dann darauf eingehen, wie diese Docker Instanz mit einer Docker DB Instanz verknüpft werden kann, oder wie die Konfiguration, welche umgebungsabhängig ist, verwaltet werden kann. Das Ökosystem ist hier umfangreich, so dass hier mehrere Beiträge folgen werden.

Zusammenfassend für diesen Beitrag bedeutet das
Ziel

  • Überblick in Docker
  • Erstellung eines Docker Image mit Wildfly

Vorbedingungen

  • Ubuntu als Host-System

Ausgrenzungen

Installation

Um Docker zu verwenden, benötigt man für das Host-System, wo Docker laufen soll eine entsprechende Docker Engine. Mittels folgendem Befehl wird die aktuellste Version (1.6.0, Stand April 2015, hier in Ubuntu 14.10) installiert:

Nach der Installation kann geben wir testweise die Version aus:

Wie man erkennen kann, wird für die Nutzung sudo-Rechte benötigt. Um Docker mit einem Nicht-Root-User zu benutzen, müssen wir den User zur „docker“-Gruppe hinzufügen:

Einrichtung

Bevor wir mit der Einrichtung eines neuen Docker Containers beginnen, noch ein paar einleitende Worte. Im Docker Kontext gibt es mindestens folgende zwei Komponenten:

  • Image: Ein Docker Image ist die Komponente, welches das System/Applikation beschreibt und alle Softwareinstallationen beinhaltet. Ein Image kann als Template angesehen werden, welches für die Erstellung eines Docker Container verwendet wird. Jegliche Änderungen an ein existierendes Image resultiert in ein neues Image.
  • Container: Ein Docker Container, wird aus einem Image erstellt und symbolisiert die laufende Plattform, welches die Applikation beinhaltet. Jeder Docker Container kann als geschlossenes/isoliertes System angesehen werden.

Ein Docker Image besteht aus einer Menge von Layer. Solch ein Layer wird durch jegliche Änderung/Aktion erstellt. D.h. eine Befehl-Ausführung, Variablen-Änderung oder das Hinzufügen einer Datei führt zu einem neuen Layer. Die Summe dieser Layer beschreiben das Docker Image, welches in einem „Dockerfile“ festgehalten werden. Um ein Docker Image zu aktualisieren, reicht es, nur die neusten Layer mitzuteilen, anstatt das ganze Image nochmal zu übertragen. Das hat den großen Charme im Gegensatz zu einem VM Image.

Wir werden im weiteren Verlauf ein eigenes Docker Image erstellen. Als Basis brauchen wir ein minimales Betriebssystem z.B. Ubuntu, CentOS. Unter Docker Hub [2] kann nach existierenden Images gesucht werden. Diese Systeme sind jedoch gut über 100MB groß. Mit busybox [3] oder der Weiterentwicklung alpine [4] bekommen wir ein minimales System mit einer Größe von 5MB. Nachtrag: Alpine scheint aktuell noch nicht optimal zu laufen. Deswegen wird im weiteren Verlauf wieder busybox verwendet.

Das Docker Image wird mittels der Konfigurationsdatei Dockerfile beschrieben:

Mit folgendem Befehl wird dann das Docker Image gebaut, in dem das Dockerfile verwendet wird:

Dieser Befehl kann mehrmals aufgerufen werden. Docker merkt, welche Anweisungen neu hinzugekommen sind und führt dann nur noch diese aus, die anderen werden aus dem Cache verwendet. Dies ist in der Ausgabe zu erkennen:

Gestartet kann nun unsere neues Docker Image wie folgt:

Dabei bedeuten die Parameter:

  • -it: interaktiv mit pseudo TTY
  • -p: Publiziert den Port vom Container zum Host
  • –rm: Löscht den Container, falls der schon existiert. Das reduziert während der Entwicklung die Anzahl der erstellten Container.

Wildfly ist nun im Browser unter http://localhost:8080 bzw. http://localhost:9990 zu erreichen. Für die Management-Konsole wurde admin:admin2015 als Nutzer hinterlegt.

Fazit

Das hier aufgeführte Dockerfile habe ich real in 3 Teile aufgeteilt

  • base: welches das Betriebssystem und allg. Informationen beinhaltet
  • jdk8: Ein Docker Image, welches auf base basiert und Oracle JDK 8 bereitstellt.
  • Wildfly9: Ein Docker Image, welches auf jdk8 basiert und WildFly 9 bereitstellt.

Mit dieser Modularisierung lassen sich die Docker Images für weitere Projekte wiederverwenden. So kann in wenigen Schritten ein wiederverwendbarer Docker Container bereitgestellt werden.

Informationen bzgl. Deployment und Konfiguration folgen in den nächsten Beiträgen.

Die Dockerfiles sind bei Bitbucket zu finden:

https://bitbucket.org/playsphere/docker-files.git

Referenzen

[1] Docker: https://www.docker.com/

[2] Docker Hub: https://hub.docker.com/

[3] BusyBox: https://github.com/progrium/busybox

[4] Docker Alpine: https://github.com/gliderlabs/docker-alpine

[5] Blog-Eintrag von Peter Roßbach zu Docker und Microservices: http://www.infrabricks.de/blog/2014/12/19/docker-microservice-basis-mit-apache-tomcat-implementieren/

Share it!
  •  
  •  
  •  
  •  
  •  
  •  

Leave a Reply

Note: You can use basic XHTML in your comments. Your email address will never be published.

Subscribe to this comment feed via RSS