Docker: Unterschied zwischen den Versionen

aus www.kruedewagen.de, Homepage von Ralf und Judith Krüdewagen (Kruedewagen)
Zur Navigation springen Zur Suche springen
(21 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 43: Zeile 43:
*[https://entwickler.de/online/development/docker-test-driven-development-b-170207.html Einführung in Test-driven Docker Development]
*[https://entwickler.de/online/development/docker-test-driven-development-b-170207.html Einführung in Test-driven Docker Development]
*[https://entwickler.de/online/development/container-und-das-docker-oekosystem-status-quo-185051.html Container und das Docker-Ökosystem – Status quo] (entwickler.de) zur Studie [http://offers.ruxit.com/rs/987-BEQ-874/images/State_of_Containers_Ruxit_compressed_V2.pdf?mkt_tok=3RkMMJWWfF9wsRokvqrMZKXonjHpfsX86u0kW6KzlMI%2F0ER3fOvrPUfGjI4AS8pgI%2BSLDwEYGJlv6SgFQ7jCMaJly7gFXBU%3D The State of Containers and the Docker Ecosystem 2015]
*[https://entwickler.de/online/development/container-und-das-docker-oekosystem-status-quo-185051.html Container und das Docker-Ökosystem – Status quo] (entwickler.de) zur Studie [http://offers.ruxit.com/rs/987-BEQ-874/images/State_of_Containers_Ruxit_compressed_V2.pdf?mkt_tok=3RkMMJWWfF9wsRokvqrMZKXonjHpfsX86u0kW6KzlMI%2F0ER3fOvrPUfGjI4AS8pgI%2BSLDwEYGJlv6SgFQ7jCMaJly7gFXBU%3D The State of Containers and the Docker Ecosystem 2015]
*Die Zukunft der Container-Technik (Spezifikation, Standards): siehe c't 02/20 S.140 , https://ct.de/ypyc
*Deployments mit "Cloud Native Applications Bundles": siehe LM 02/20 S.62


=== Versionshinweise ===
=== Versionshinweise ===
Zeile 53: Zeile 55:
*[https://cncf.io Cloud Native Computing Foundation] (CNCF)
*[https://cncf.io Cloud Native Computing Foundation] (CNCF)


=== Repository Server ===
=== Registry Server ===
*[https://github.com/kwk/docker-registry-frontend Docker Registry Frontend] - Browse and modify your Docker registry in a browser.
*[https://github.com/kwk/docker-registry-frontend Docker Registry Frontend] - Browse and modify your Docker registry in a browser.
*[[GitLab]]
*[https://goharbor.io/ Harbor]
**Review siehe iX 02/20 S.66


:Siehe auch "Docker Registry Frontend" in rawino.
:Siehe auch "Docker Registry Frontend" in rawino.
Zeile 82: Zeile 87:
*[https://katacontainers.io/ Kata Containers] zur Isolation: siehe [[LM]] 12/18 S.60
*[https://katacontainers.io/ Kata Containers] zur Isolation: siehe [[LM]] 12/18 S.60
*Tools zur Absicherung von Containern: siehe iX 04/19 S.98
*Tools zur Absicherung von Containern: siehe iX 04/19 S.98
*Bausteine zur Container-Sicherheit vom BSI: siehe iX 05/20 S.88


== Orchestrierung ==
== Orchestrierung ==
Zeile 117: Zeile 123:
**Cloud Native Storage (i.d.R. CEPH) als Volume in Kubernetes einbinden mit [https://rook.io/ Rook]: siehe LM 09/18 S.58
**Cloud Native Storage (i.d.R. CEPH) als Volume in Kubernetes einbinden mit [https://rook.io/ Rook]: siehe LM 09/18 S.58
**siehe Praxis-Artikel in c't 18/19: [https://heise.de/-4496199 Kubernetes lernen mit dem Raspberry Pi] (geht natürlich auch mit andere HW oder virtuellen Maschinen), http://ct.de/ya59
**siehe Praxis-Artikel in c't 18/19: [https://heise.de/-4496199 Kubernetes lernen mit dem Raspberry Pi] (geht natürlich auch mit andere HW oder virtuellen Maschinen), http://ct.de/ya59
**Orchestrierungstools für Kubernetes im Vergleich (SuSE, Red Hat, Rancher): siehe iX 12/19 S.50
**Herausforderungen bei Kubernetes auf dem eigenen Server: siehe iX 12/19 S.58
**Kubernetes-Cluster sicher betreiben: siehe iX 12/19 S.62
**VMware im Kubernetes-Markt: siehe LM 01/20 S.60
**Sicher auf Kubernetes zugreifen (Namespaces, OpenID, Accounts, Service-Accounts, Rollen, Autorisierung, Zugriffkontrolle): siehe LM 02/20 S.28
**Deployments mit "Cloud Native Applications Bundles": siehe LM 02/20 S.62
**[https://k3s.io/ K3s] - Lightweight Kubernetes, aus dem Hause "Rancher" und in Rancher 2.4 noch umfangreicher unterstützt
***Beispiel siehe [https://github.com/ct-Open-Source/team-container team-container] Projekt der c't mit Nextcloud, Rocket.Chat, Jitsi Meet und Træfik Router, siehe c't 09/20 S.26
**Vergleich kommerzieller Distributionen: siehe iX 05/20 S.64
**[https://entwickler.de/online/cloud/kubernetes-cicd-generationen-579934292.html Kubernetes und seine CI/CD-Generationen], als Zwischenlösung [[GitLab]] empfohlen als System 2. Generation.


*Compose, Machine, Swarm
*Compose, Machine, Swarm
Zeile 140: Zeile 156:
**Rancher 1: siehe iX 02/17 S.32
**Rancher 1: siehe iX 02/17 S.32
**Rancher 2: siehe iX 04/18 S.60
**Rancher 2: siehe iX 04/18 S.60
**[https://heise.de/-4693261 Containerisierung: Rancher 2.4 wächst über den Rand hinaus] (Heise)


*[https://kontena.io/ Kontena]
*[https://kontena.io/ Kontena]
Zeile 195: Zeile 212:
*Reverse Proxy als Docker-Container für den automatischen Einsatz bei vielen Containern unter einer IP, die z.B. alle auf Port 80 und 443 erreichbar sein sollen: https://hub.docker.com/r/jwilder/nginx-proxy/
*Reverse Proxy als Docker-Container für den automatischen Einsatz bei vielen Containern unter einer IP, die z.B. alle auf Port 80 und 443 erreichbar sein sollen: https://hub.docker.com/r/jwilder/nginx-proxy/
**siehe c't 15/17 S.113
**siehe c't 15/17 S.113
*[https://traefik.io/ Traefik], https://docs.traefik.io
*[https://traefik.io/ Traefik], https://docs.traefik.io
**als schlanke NGINX-Alternative für das Routen von HTTP und - ab v2 - anderen TCP-Traffic: Load Balancer, Let's Encrypt Integration, [https://docs.traefik.io/v2.0/middlewares/overview/ Middleware] für Logging und Filtering, integriert mit Docker Daemon oder auch in größeren Kubernetes- bzw. Rancher-Umgebungen, statische und dynamische Konfiguration
**als schlanke NGINX-Alternative für das Routen von HTTP und - ab v2 - anderen TCP-Traffic: Load Balancer, Let's Encrypt Integration, [https://docs.traefik.io/v2.0/middlewares/overview/ Middleware] für Logging und Filtering, integriert mit Docker Daemon oder auch in größeren Kubernetes- bzw. Rancher-Umgebungen, statische und dynamische Konfiguration
**Beispiel siehe c't 12/19 S.158
**Beispiel siehe c't 12/19 S.158
**siehe c't 17/19 S.158 , http://ct.de/y1ds , Beispiele https://github.com/jamct/traefik-example
**siehe c't 17/19 S.158 , http://ct.de/y1ds , Beispiele https://github.com/jamct/traefik-example
**[http://heise.de/-4658800 TLS-Zertifikate: Træfik 2 für Container jenseits von HTTPS]


*Software Defined Networking, z.B. mit [http://contiv.github.io/ Contiv]: siehe iX 06/18 S.110
*Software Defined Networking, z.B. mit [http://contiv.github.io/ Contiv]: siehe iX 06/18 S.110
Zeile 235: Zeile 254:
Info ausgeben:
Info ausgeben:
  docker info
  docker info
=== Logging ===
*Logs aus Docker-Umgebungen sammeln und auswerten mit [https://docs.fluentd.org/ fluentd], Elasticsearch, Kibana, : siehe c't 08/20 S.166, https://ct.de/yjn4, Beispiel-Projekt: https://github.com/jamct/docker-log


=== Images ===
=== Images ===
Zeile 249: Zeile 271:
Image in Tar-Archiv umwandeln:
Image in Tar-Archiv umwandeln:
  docker images save > myimage.tar
  docker images save > myimage.tar
oder
docker save myimage -o myimage.tar


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


===== Beispiel 3: Parsoid mit Node.js =====
===== Beispiel 3: Parsoid mit Node.js =====
Parsoid wird für den [[Mediawiki#Visual_Editor|Visual Editor]] von MediaWiki benötigt und ist ein webbasierter Dienst.
Parsoid wird für den [[Mediawiki#Visual_Editor|Visual Editor]] von MediaWiki benötigt und ist ein webbasierter Dienst. Siehe auch https://hub.docker.com/r/formwandler/parsoid.


Voraussetzungen / Bemerkungen:
Voraussetzungen / Bemerkungen:
Zeile 376: Zeile 400:
# Install Node.js
# Install Node.js
RUN apt-get install -y curl
RUN apt-get install -y curl
RUN curl -sL https://deb.nodesource.com/setup_5.x | bash -
RUN curl -sL https://deb.nodesource.com/setup_10.x | bash -
RUN apt-get update && apt-get install -y nodejs
RUN apt-get update && apt-get install -y nodejs
# Add Parsoid repo
# Add Parsoid repo
RUN apt-key advanced --keyserver keys.gnupg.net --recv-keys 664C383A3566A3481B942F007A322AC6E84AFDD2
RUN apt-key advanced --keyserver keys.gnupg.net --recv-keys AF380A3036A03444
RUN echo "deb https://releases.wikimedia.org/debian jessie-mediawiki main" > /etc/apt/sources.list.d/parsoid.list
RUN echo "deb https://releases.wikimedia.org/debian jessie-mediawiki main" > /etc/apt/sources.list.d/parsoid.list
# Install Parsoid
# Install Parsoid
Zeile 551: Zeile 575:
*Mehrere Prozesse / Applikationen in einem Container managen mit [http://supervisord.org/ supervisord]
*Mehrere Prozesse / Applikationen in einem Container managen mit [http://supervisord.org/ supervisord]
*[https://entwickler.de/online/php/docker-web-apps-579861527.html Docker in der Praxis: Lehren aus dem Umgang mit komplexen Web-Apps] (entwickler.de)
*[https://entwickler.de/online/php/docker-web-apps-579861527.html Docker in der Praxis: Lehren aus dem Umgang mit komplexen Web-Apps] (entwickler.de)
*Unterordner vom Host vom Mapping ausnehmen: Ordner angeben, aber keine Zuordnung mit Doppelpunkt, siehe c't 18/19 S.168


== Tools ==
== Tools ==

Version vom 22. Mai 2020, 12:38 Uhr

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 verwaltet LXC Container: LM 08/13 S.64
  • 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
  • Systemd vs. Docker (lwn.net)
  • PHP development with Docker
  • Docker Grundlagen, Praxis, User Defined Networks: siehe c't 15/17 S.106 ff
  • Docker Container aktuell halten: siehe LM 06/18 S.48
  • Docker Images (allgemein, Auswahl): siehe c't 16/18 S.104 ff
  • Docker auf dem Raspberry Pi: siehe c't 02/19 S.149
  • Multi Stage Builds mit Docker (am Beispiel einer Node.js Applikation)
    • Indiz: Zwei oder mehrere FROM Anweisungen im Dockerfile
    • siehe c't 03/19 S.152
  • Images automatisch im Docker Hub bauen via GitHub: siehe c't 04/19 S.138 , http://ct.de/y3tz , https://github.com/ct-Open-Source/docker-autobuild-example

Ökosystem

Versionshinweise

1.3

Projekte und Verbände

Registry Server

Siehe auch "Docker Registry Frontend" in rawino.

Betriebssysteme

Besonders auf Docker abgestimmte (schlanke) Betriebssysteme (Linux):

Sicherheit

Orchestrierung

Bei der Orchestrierung geht es um Verwaltung, 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:

  • Docker-Orchestrierung mit Kubernetes
    • http://kubernetes.io
    • siehe LM 11/14 S.70
    • siehe LM 05/15 S.70
    • siehe iX 05/15 S.49
    • Kubernetes & OpenShift E-Book
      • OpenShift 4: siehe iX 07/19 S.62
    • siehe c't 05/16 S.116
    • fabric8: Open source microservices platform based on Docker, Kubernetes and Jenkins
    • siehe iX 02/17 S.38
    • Einführungstutorials in der iX
      • Teil 1: Logik und Terminologie, iX 07/17, S. 98
      • Teil 2: Kubernetes installieren, iX 08/17, S. 122
      • Teil 3: Produktiveinsatz planen und vorbereiten, iX 09/17, S. 138
    • Kubeapps, Kubeapps startet Apps auf Kubernetes (linux-magazin.de)
    • Introducing commercial Kubernetes applications in GCP Marketplace (Google)
    • A practical Introduction to Kubernetes (Video)
    • Cloud Native Storage (i.d.R. CEPH) als Volume in Kubernetes einbinden mit Rook: siehe LM 09/18 S.58
    • siehe Praxis-Artikel in c't 18/19: Kubernetes lernen mit dem Raspberry Pi (geht natürlich auch mit andere HW oder virtuellen Maschinen), http://ct.de/ya59
    • Orchestrierungstools für Kubernetes im Vergleich (SuSE, Red Hat, Rancher): siehe iX 12/19 S.50
    • Herausforderungen bei Kubernetes auf dem eigenen Server: siehe iX 12/19 S.58
    • Kubernetes-Cluster sicher betreiben: siehe iX 12/19 S.62
    • VMware im Kubernetes-Markt: siehe LM 01/20 S.60
    • Sicher auf Kubernetes zugreifen (Namespaces, OpenID, Accounts, Service-Accounts, Rollen, Autorisierung, Zugriffkontrolle): siehe LM 02/20 S.28
    • Deployments mit "Cloud Native Applications Bundles": siehe LM 02/20 S.62
    • K3s - Lightweight Kubernetes, aus dem Hause "Rancher" und in Rancher 2.4 noch umfangreicher unterstützt
      • Beispiel siehe team-container Projekt der c't mit Nextcloud, Rocket.Chat, Jitsi Meet und Træfik Router, siehe c't 09/20 S.26
    • Vergleich kommerzieller Distributionen: siehe iX 05/20 S.64
    • Kubernetes und seine CI/CD-Generationen, als Zwischenlösung GitLab empfohlen als System 2. Generation.
docker-compose build
docker-compose up -d
docker-compose up <name> -d
docker-compose down
docker-compose restart <name>
docker-compose logs
  • DC/OS von Mesosphere
    • siehe iX 02/17 S.42
  • OpenStack
  • Kubic
    • openSUSE MicroOS Container Operating System and the Kubic Container as a Service Platform based on MicroOS and kubernetes
  • Kleinere Tools:
    • Watchtower prüft nach neuen Versionen für Images, macht ein Pull und startet Container neu
    • Management GUIs
      • Testbericht siehe LM 09/18 S. 48 (Dockstation, Kitematic, Portainer)
      • Portainer, management user interface for your Docker environments, https://portainer.io , siehe c't 16/18 S.109 und LM 09/18 S.48

Anwendungen

openSUSE

Icinga

Training und Lernen

Literatur

  • Verschiedene Bücher von Packt.
  • "Pro Docker" vor allem mit Beispiel-Containern für Linux, Datenbanken, und Applikationen; siehe iX 10/16 S.156
  • Docker
    • "Software entwickeln und deployen mit Containern" - dpunkt
    • Docker, Rheinwerk, 2018: siehe LM 02/19 S.85
  • Kubernetes
    • Kubernetes, Dpunkt, 2018: siehe LM 02/19 S.85

Betrieb

Hilfe

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

Netzwerk

  • Wenn man von einem Container eine TCP-Verbindung zum Docker Host machen möchte, z.B. um eine MySQL DB auf dem Host zu nutzen, dann muss bei aktivierter Firefall das interne Docker-Netzwerk freigeschaltet werden, z.B. als "Trusted Network":
FW_TRUSTED_NETS="172.17.0.0/16"
  • Beim Start des Docker-Daemons kann Firewall-Funktion deaktiviert werden.
  • Reverse Proxy als Docker-Container für den automatischen Einsatz bei vielen Containern unter einer IP, die z.B. alle auf Port 80 und 443 erreichbar sein sollen: https://hub.docker.com/r/jwilder/nginx-proxy/
    • siehe c't 15/17 S.113
  • Software Defined Networking, z.B. mit Contiv: siehe iX 06/18 S.110

User Defined Networks

  • User Defined Networks: siehe c't 15/17 S.116
  • Netzwerke anzeigen:
docker network ls
  • Bridge "docker-extern" (einmalig) erstellen und einen Container aus der Standard-Bridge dort hineinfügen:
docker network create docker-extern
docker network disconnect docker0
docker network connect docker-extern mycontainer

oder beim Start des Containers mit "docker run" das Netzwerk angeben

docker run ... --network docker-extern
  • Netzwerk Alias - zur Verlinkung von Diensten/Hostnamen (z.B. einer Datenbank mit Hostnamen "db") - anstatt Link:
docker run ... --network docker-extern --name dbserver --network-alias db
  • Man kann mehrere Container im gleichen Netz denselben Alias zuweisen: Round Robin des eingebetteten DNS-Servers
  • Man kann einem Container mehrere Aliase geben: Mehrere Namen in einem Container
  • Container in mehrere User Defined Networks erreichbar machen (alias):
docker network connect --alias db docker-extern mycontainer
  • Verbindungen (Inter Container Connectivity) zwischen User Defined Networks verhindern:
docker network create -o 'com.docker.network.bridge.enable_icc=false' docker-isoliert
  • Keine Netzwerkverbindung im impliziten Netzwerk "none"
  • Keine Verbindung nach außen (Internet):
docker network create --internal docker-intern
  • Feste IP-Adressen im Netz auf im Container:
docker network create --subnet 172.20.0.0/16 --gateway 172.20.0.1 docker-extern
docker run ... --network docker-extern --ip 172.20.0.2

Konfiguration

Images landen hier:

/var/lib/docker

Info ausgeben:

docker info

Logging

Images

Handling von Images

Image suchen:

docker search debian

Ein Image herunterladen:

docker pull debian

Vorhandene (lokale) Images auflisten:

docker images

Image in Tar-Archiv umwandeln:

docker images save > myimage.tar

oder

docker save myimage -o myimage.tar

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 <username>/meinnginx2:latest
docker login
docker push <username>/meinnginx2
Login-Daten landen in /root/.docker/config.json

Neues Tag "v2.0" pushen auf Basis von "latest":

docker tag <username>/meinnginx2:latest <username>/meinnginx2:v2.0
docker push <username>/meinnginx2:v2.0

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

Parsoid wird für den Visual Editor von MediaWiki benötigt und ist ein webbasierter Dienst. Siehe auch https://hub.docker.com/r/formwandler/parsoid.

Voraussetzungen / Bemerkungen:

  • MediaWiki läuft auf dem Host selbst (Dockerhost). Für das Ansprechen namensbasierter virtueller Webserver sind FQDN-Einträge in uri nötig.
  • 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.
  • wie man den Dockerhost aus dem Container ansprechen kann (Eintrag in hosts Datei mit --add-host beim Starten des Containers) erklärt https://github.com/docker/docker/issues/1143.

/data/docker/parsoid/config.yaml (only the "conf" section):

       mwApis:
        - # This is the only required parameter,
          # the URL of you MediaWiki API endpoint.
          uri: 'https://dockerhost/w/api.php'
          domain: 'localhost'  # optional
        - # This is the only required parameter,
          # the URL of you MediaWiki API endpoint.
          uri: 'http://www.example.org/w/api.php'
          domain: 'example.org'  # optional

        # Use selective serialization (default false)
        useSelser: true

        # Allow override of port/interface:
        serverPort: 8142
        #serverInterface: '127.0.0.1'

        # Require SSL certificates to be valid (default true)
        # Set to false when using self-signed SSL certificates
        strictSSL: false
};

/data/docker/parsoid/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_10.x | bash -
RUN apt-get update && apt-get install -y nodejs
# Add Parsoid repo
RUN apt-key advanced --keyserver keys.gnupg.net --recv-keys AF380A3036A03444
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 config.yaml /etc/mediawiki/parsoid/
EXPOSE 8142
CMD ["/usr/bin/nodejs", "/usr/lib/parsoid/src/bin/server.js", "-c", "/etc/mediawiki/parsoid/config.yaml"]

Image bauen:

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

Container starten (IP des Dockerhost einsetzen):

docker run -d --name parsoid -p 8142:8142 --add-host=dockerhost:172.17.0.1 parsoid

oder mit zwei URLs:

docker run -d --name parsoid -p 8142:8142 --add-host=dockerhost:172.17.0.1 --add-host=www.example.org:172.17.0.1 parsoid

oder inkl. automatischem Restart:

docker run -d --name parsoid -p 8142:8142 --add-host=dockerhost:172.17.0.1 --add-host=www.example.org:172.17.0.1 --restart=always parsoid

optional mit "--restart=unless-stopped"

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

  • siehe c't 15/17 S.120 (Beispiel MySQL in Container packen, X-Anwendung im Container mit SSH), http://ct.de/yqws

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

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

Ausgaben auf Konsole anzeigen (Logging):

docker logs meindebian

In syslog loggen mit Namen statt ID des Containers:

docker run ... --log-driver=syslog --log-opt tag="mycontainer"

Kommandos in Image einbauen zur Verwendung im Container

docker exec gitweb addauth test test

Debugging

  • siehe LM 03/18 S.58
docker logs -f
docker top
docker pause | unpause
docker exec -it /bin/bash
docker history
docker stats
docker inspect

Volumes

Volumes auflisten:

docker volume
docker volume inspect <VOLUME_ID>

Volume eines Containers:

docker inspect -f 'Vorlage:.Mounts' <CONTAINER_ID>

Volumes erben (hilfreich um laufenden Container zu ersetzen, zuerst laufenden Container umbenennen):

--volumes-from mycontainer

Aufräumen

Nicht mehr benötigte Container entfernen, die im Status "exited" sind:

docker rm -v $(docker ps -a -q -f status=exited)

Images löschen, die nicht in Gebrauch sind:

docker rmi $(docker images -f "dangling=true" -q)

Überflüssige Volumes finden und löschen:

docker volume ls --filter "dangling=true"
docker volume prune

Unbenutze Container, Networks und Images löschen:

docker system prune

Auch unbenutzte Volumes löschen:

docker system prune --all --force --volumes

Weblinks / Quellen (u.a. auch zu Tipps zu Volumes):

Tools

Troubleshooting

Best Pratices - Tipps & Tricks

zuerst Nummer des Interfaces im Container herausfinden:
cat /sys/class/net/eth0/iflink
6
Dann auf dem Host nach dieser Nummer suchen:
grep -l "^6$" $(find /sys/devices/virtual/net -name "ifindex")
/sys/devices/virtual/net/veth034c9d0/ifindex

Tools

Testen

  • Testen mit Testcontainern: siehe iX 07/19 S.68

Monitoring

Siehe auch