Docker

aus www.kruedewagen.de, Homepage von Ralf und Judith Krüdewagen (Kruedewagen)
Zur Navigation springen Zur Suche springen

Diese Seite beschäftigt sich mit Docker Containern zur Virtualisierung von Applikationen.

Allgemein

Docker Webseiten

Artikel und Infos

Datenbank und Webserver in getrennten Containern
  • Docker Einführung und Panamax als GUI: siehe LU 12/14 S.78
  • Docker mit Swarm: siehe iX 03/15 S.108
  • Anwendungen mit Docker isolieren
  • Docker Report: siehe iX 05/15 S.46
  • Docker Container Einführung: siehe c't 05/16 S.108
  • Docker Container einsetzen: siehe c't 05/16 S.112

Ökosystem

Repository Server

Siehe auch "Docker Registry Frontend" in rawino.

Sicherheit

Orchestrierung

Bei der Orchestrierung geht es um Skalierbarkeit und Automatisierung:

  • Container massenweise auf beliebigen Hosts (automatisch) starten
  • Container auf mehreren Hosts in ein "virtuelles" Netzwerk integrieren, mit dynamischer Vergabe von IP-Adressen und Ports (internes DNS und Service Discovery)
  • Dienste und Anwendungen aus einer Vielzahl von Container in Clustern erstellen und steuern
  • Mehrere Versionen einer Anwendung parallel laufen lassen mit schnellem Wechsel der Versionen

Siehe:

  • Dockers Ökosystem: Kubernetes, etcd, Project Atomic, Open Stack, siehe LM 11/14 S.70
  • Deis vereint Docker und Core OS: siehe LM 03/15 S.62
  • Flocker: Verwaltung von Speicher-Ressourcen / Daten
    • siehe LM 09/15 S.60
  • Docker-Orchestrierung mit Kubernetes

Anwendungen

openSUSE

Icinga

Training und Lernen

Betrieb

Hilfe

man docker
man docker run
docker --help
docker run --help

Konfiguration

Images landen hier: 

/var/lib/docker

Images

Handling von Images

Ein Image herunterladen: 

docker pull debian

Vorhandene (lokale) Images auflisten: 

docker images

Image (lokal) löschen (nur möglich, solange kein Container es nutzt): 

docker rmi debian

Image pushen (zuerst "Rename" des Images in Non-Root-Pfad durch Taggen [1], dann einmalig Login [2]): 

docker tag meinnginx2:latest formwandler/meinnginx2:latest
docker login
docker push <username>/meinnginx2
Login-Daten landen in /root/.docker/config.json

Eigenes Image bauen

Beispiel 1: Apache auf Basis Debian

Das folgende Beispiel setzt ein Apache-Image mit einer statischen Webseite auf Basis eines Debian "Betriebssystem-Images" auf.

1. Verzeichnis für den Bau erstellen 

mkdir -p /data/docker/newimage

2. Die statische Seite(n) erstellen, die dem Image hinzugefügt werden sollen 

cd /data/docker/newimage
vi index.html

3. Das Dockerfile anlegen 

vi Dockerfile

FROM debian
MAINTAINER Ralf Kruedewagen <docker@kruedewagen.de>
RUN apt-get update && apt-get install -y apache2
ADD index.html /var/www/html/
EXPOSE 80
# Apache ENVs, sonst Fehlermeldung beim Start von Apache, siehe
# https://github.com/paulczar/docker-apache2/blob/master/Dockerfile
# http://tech.paulcz.net/2015/03/optimizing-your-dockerfiles/
ENV APACHE_RUN_USER    www-data
ENV APACHE_RUN_GROUP   www-data
ENV APACHE_PID_FILE    /var/run/apache2.pid
ENV APACHE_RUN_DIR     /var/run/apache2
ENV APACHE_LOCK_DIR    /var/lock/apache2
ENV APACHE_LOG_DIR     /var/log/apache2
ENV LANG               C

# Fehlermeldung mit APACHE_LOCK_DIR -> https://log.axcoto.com/article/164442852
RUN [ ! -d ${APACHE_RUN_DIR:-/var/run/apache2} ] && mkdir -p ${APACHE_RUN_DIR:-/var/run/apache2}
RUN [ ! -d ${APACHE_LOCK_DIR:-/var/lock/apache2} ] && mkdir ${APACHE_LOCK_DIR:-/var/lock/apache2} && chown ${APACHE_RUN_USER:-www-data} ${APACHE_LOCK_DIR:-/var/lock/apache2}

CMD ["/usr/sbin/apache2", "-D", "FOREGROUND"]
# alternativ:
# ENTRYPOINT ["/usr/sbin/apache2"]
# CMD ["-D", "FOREGROUND"]

4. Das Image bauen 

docker build -t meinapache /data/docker/newimage/

5. Container anlegen und starten 

docker run -d --name meinapachecontainer -p 8080:80 meinapache

Mehr Infos zu Apache und Docker:

Beispiel 2: Nginx auf Basis Debian

Genau so wie bei Apache mit einigen Änderungen im Dockerfile: 

FROM debian
MAINTAINER Ralf Kruedewagen <docker@kruedewagen.de>
RUN apt-get update && apt-get install -y nginx
ADD index.html /var/www/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
Beispiel 3: Parsoid mit Node.js

Siehe Mediawiki#Visual_Editor.

Voraussetzungen / Bemerkungen:

  • MediaWiki läuft auf dem Host selbst (Dockerhost)
  • Parsoid soll in einem Container laufen, daher benötigt der Dockerhost Zugriff auf den Parsoid-Port im Container und im Gegenzug benötigt Parsoid Zugriff auf das Wiki im Dockerhost
  • Den Dockerhost aus dem Container ansprechen (Eintrag in hosts Datei): Siehe https://github.com/docker/docker/issues/1143

settings.js: 

'use strict';

exports.setup = function(parsoidConfig) {
        parsoidConfig.setMwApi({ prefix: 'localhost', domain: 'localhost', uri: 'http://dockerhost/w/api.php' });
        parsoidConfig.useSelser = true;
};

Dockerfile: 

FROM debian
MAINTAINER Ralf Kruedewagen <docker@kruedewagen.de>
# for HTTPS sources
RUN apt-get update && apt-get install -y apt-transport-https
# Install Node.js
RUN apt-get install -y curl
RUN curl -sL https://deb.nodesource.com/setup_5.x | bash -
RUN apt-get update && apt-get install -y nodejs
# Add Parsoid repo
RUN apt-key advanced --keyserver keys.gnupg.net --recv-keys 664C383A3566A3481B942F007A322AC6E84AFDD2
RUN echo "deb https://releases.wikimedia.org/debian jessie-mediawiki main" > /etc/apt/sources.list.d/parsoid.list
# Install Parsoid
RUN apt-get update && apt-get install -y parsoid
# Copy config
ADD settings.js /etc/mediawiki/parsoid/
EXPOSE 8142
CMD ["/usr/bin/nodejs /usr/lib/parsoid/src/api/server.js -c /etc/mediawiki/parsoid/settings.js"]
#CMD ["service parsoid restart"]

Image bauen: 

docker build -t parsoid /data/docker/newimage/

Container starten (IP des Dockerhost einsetzen): 

docker run -d --name parsoid -p 8142:8142 --add-host=dockerhost:172.17.0.1 parsoid
Images erstellen nach Änderungen im Container

Man kann Änderungen im Container in ein neues Image "committen". Dabei wird aus dem Basis-Image plus den Änderungen ein neues Image erstellt.

1. Basis-Image holen

2. Container darauf aufsetzen

3. Änderungen im Container vornehmen (z.B. im o.g. Beispiel die Webseite ändern)

4. Container ID feststellen 

docker ps -l

5. Neues Images aus laufendem Container bauen: 

docker commit <CONTAINER ID> <NEUES IMAGE>
docker commit 05c85da33c4a meinnginx2
docker commit -m="Webseite angepasst + vim installiert" -a "Ralf Kruedewagen" 05c85da33c4a meinnginx2

6. Neues Image inspizieren 

docker inspect meinnginx2
Image auf Docker Hub erstellen
  • Git Repository (z.B. aus GitHub), das Dockerfile und weiteren Dateien enthält, in Docker Hub referenzieren
  • Nach jedem Commit (Push) im Git Repo wird neues Images erstellt.
Weitere Steuerungsmöglichkeiten
  • Script kann über Variablen das Verhalten der Container steuern

Dockerfile

Siehe:

Container

Anlegen und Starten

Container in einem Rutsch anlegen und starten (und auch Image herunterladen falls nötig): 

docker run --name meindebian -it debian
Wordpress mit MySQL
mkdir /data/mysqlcontainer
docker run -d --name meinmysql -v /data/mysqlcontainer/:/var/lib/mysql/ -e MYSQL_ROOT_PASSWORD=xxx mysql
docker run -d --name meinwordpress --link meinmysql:mysql -p 8080:80 wordpress
Parameter: "--link" erstellt die MySQL-Konfig im Wordpress Container gemäß Daten/Status des MySQL Containers (Interface, IP, Port) -> "Docker Networks" ersetzt "--link"
"-v" reicht Verzeichnisse vom Host in den Container durch (kann auch im Dockerfile fest vorgegeben sein)

Container (nur) anlegen: 

docker create --name=meindebian -it debian
Parameter: i = interaktiv, t = terminal (nötig weil es ein Basis-Image mit "Bash" als Dienst ist)

Container starten: 

docker start -ia meindebian
Parameter: i = interaktiv, a = Ausgabeumlenkung / Konsole verbinden
Exit aus Bash stoppt den Container

Container stoppen (mehrere Container können angegeben werden): 

docker stop meindebian

Container löschen (Daten im Container gegen verloren, Image bleibt unberührt): 

docker rm meindebian

Managen von Containern

Laufende Container zeigen ("-a" zeigt auch nicht-laufende): 

docker ps
docker ps -a

Ausgaben auf Konsole anzeigen: 

docker logs meindebian

Shell in laufendem Container starten: 

docker exec -it meindebian bash

Shell in einem Container starten (dabei "CMD" übergehen): 

docker run -it --entrypoint=/bin/bash <image> -i

Etwas im Container installieren: 

docker run meindebian apt-get install -y dovecot

Monitoring

Abgerufen von „https://www.kruedewagen.de/w/index.php?title=Docker&oldid=9826“