Docker Seminar

(Wer sofort mit den Docker Seminarunterlagen loslegen will: Einführung)

Hinweis

Status 06.02.2020: Nachtrag: mein Schreibtisch war zu „voll“! Überarbeitung - auch wegen Seminarauslastung - erst ab KW 8 (17.02.2020)

Seit Mitte 2017 erstelle ich neue Seminarunterlagen in restructuredText (RST) und wandele bestehende Dokumentationen und Seminarbegleitungen in RST um.

Bemerkung

Infos zu restructuredText

Für gelegentliche „Typos“, die schon verhanden waren oder beim Konvertieren entstanden sind, bitte ich um Verständnis. Bitte einfach unter Angabe der Kapitel-Info an mich übermitteln. Hierfür Danke im Voraus.

Für Kenner meiner Seminarunterlagen hier kurz die wichtigsten Gründe für die teils aufwändigen Arbeiten:

  • Flexibilität:

    Word- (.docx), LibreOffice- (.odt) und PDF-Dokumente lassen sich zwar einfach erstellen! Aber solche Doks lassen sich leider überhaupt nicht geeignet und sauber in HTML (gegliedert / oder eine Seite), JSON, XML, Manpages, Texinfo oder gar EPUB wandeln! Oder umgekehrt!

  • Metainfos:

    Meta-Techniken, Fußnoten oder Indizes lassen sich nicht einheitlich in den unterschiedlichen Formaten pflegen.

  • Versionsmanagement:

    Eine Versionsverwaltung wie Git (Plattform: github.com) arbeitet am effizientesten mit einfachen Textdokumenten. Auch manuelles „Diffen“ ist mit Rohtexten eine mächtige und einfache Technik, während bei Word/PDF-Dokumenten immer sehr aufwändige und unübersichtliche Techniken eingesetzt werden müssen.

Conclusio: ein einziges grundlegendes Dokumentformat restructuredText und Werkzeuge (RstTools, DocUtils, Pandoc oder Sphinx) zum sauberen Erzeugen der gewünschten Dokumentformate (HTML, SingleHTML, Latex, PDF, EPUB, ODT, DOCX,…)

Ihr Trainer Joe Brandes



Hier folgen jetzt Meta-Infos zur Dokumentenversionspflege:

Version

2.0-2020

Language

de

Description
Unterlagen zu Docker Seminaren Trainer Joe Brandes.
Erstellt mit restructuredText / Sphinx / sphinx_rtd_theme!
Keywords

Docker, Seminarunterlage, J. Brandes

Copyright

Joe Brandes

Author

Joe Brandes

License

GNU General Public License, either version 2 of the License or any later version.

Rendered

06.02.2020


1. Willkommen

Manche meiner RST-Unterlagen sind im Laufe der Jahre zu kleinen Büchern gewachsen. Das möchte ich mit dieser Unterlage nicht (er)schaffen. Und die Autoren haben mir/uns die Arbeit „Buch“ ja auch schon abgenommen!

Diese Unterlage sollte eher als „Cheat Sheet“ / „Roter Faden“ verstanden und genutzt werden!

Und jetzt viel Spaß mit Docker…

1.1. Docker Versionen

Docker Software gibt es für nahezu alle Betriebssysteme. Und in unseren Seminaren wollen wir die OS-Implementierungen versuchen in Gänze zu erfassen - aber: aktuell ist Docker einfach heimisch auf Linux-Plattformen!

1.1.1. Linux

geplante Installationen:

Hinweis

Bitte überprüfen, ob der Docker Daemon läuft und enabled ist für Standard-Target/Runlevel!

Alle Aufrufe (hier folgend) und dann auch für docker müssen mit root-Rechten durchgeführt werden.

systemctl status docker.Service
systemctl start docker.Service
systemctl enable docker.Service
docker version

Im letzten Aufruf müssen Client und Server aufgelistet sein.

Im Seminar wird auch der Standarduser für docker berechtigt werden, um die tägliche Seminar- und Schulungsarbeit zu erleichtern.

Hierfür muss manchmal die Gruppe docker neu erstellt werden

groupadd docker    # falls noch nicht vorhanden und nicht mit dockerroot (CentOS) verwechseln
usermod -aG docker standarduser

Gefahr

Docker mit Standarduser kann ein großes Sicherheits darstellen! Darstellungen hierzu folgen!

1.1.2. Windows

Anm.: im 1400 Seiten zweiten Container-Werk von O. Liebel ist Docker für Windows komplett heraus! Und der Nano-Server findet ebenfalls nicht statt!

Aber so ginge es los… wir bnenötigen Windows 10 Pro oder Enterprise - siehe Hyper-V mit MobyLinuxVM!

Installarchiv für die Docker für Windows (Hyper-V) Technik am Besten über Umweg docs.docker.com

Docker für Windows

oder über

Portal zu Docker für Windows

Hinweis

Legacy Tech: Docker Toolbox

Alte Alternative (LegacyTech): Docker Toolbox für Windows (dann arbeitet man mit VirtualBox zusammen!)

https://docs.docker.com/toolbox/overview/#ready-to-get-started

https://docs.docker.com/toolbox/toolbox_install_windows/

1.1.3. macOS

(noch mehr außer Konkurrenz als Docker für Windows ;-)

Die Installationsdatei (DMG) für macOS finden Sie unter folgender Adresse:

Docker für Mac

1.2. Fachbegriffe

Basis-Begriffe:

  • Images - unveränderlich / ro

  • Container - basieren auf Images, nutzen ein Overlay-Dateisystem

    Container basiert auf Image; Container-Instanz ist R/W (Read/Write) Layer

    maximale Anzahl Layer: 128 (bei overlay2, devicemapper; s.u.)

    Container-Hosts: physikalische/reale oder virtuelle Maschine

  • Volumes - vom Container getrennte Verzeichnisse im Docker-Host-System

Vertiefung:

  • Services - Dienst/Aufgabe

    Um diese kümmert sich Docker selbst! Sogar auf welchem Docker-Host!

  • Stacks - Administration von Service-Gruppen

  • Cluster - Vorraussetzung für Services und Stacks;

    Docker Nomenklatur: Swarm; s.a. Python-Skriptool docker-compose

  • Kubernetes - Google Open Source für Container-Verwaltungen;

    läuft Docker Swarm den Rang ab!

Virtuelle Layers

Virtuelle Layers (Bild: Liebel - Skalierbare Container-Infrastrukturen für Ihr Unternehmen)

  • Continouus Delivery / Continous Integration (CD/CI)

    Versuch der Eklärung: (semi-)automatisierte Verfahren (CI) von kleinteiligen Releases mit ebenfalls möglichst automatischen Deployment-Test (CD) ;siehe: Liebel Kap. 2.3ff

1.3. Technik

Weitere Fachbgegriffe und kurze Erläuterungen:

docker Client-Server-Modell

Linux: docker /dockerd; bei Windows/MacOS „komplizierter“

Docker-Client und Server kommunizieren über eine HTTP-RESTful API (für eine sichere Kommunikation siehe Docker Security HTTPS

Einfacher Test der HTTP-Technik:

curl -s --unix-socket /var/run/docker.sock http://localhost/images/json

Das erzeugt einen einen unleserlichen (serialisierten) Infostrom, der sich mit dem Tool jq besser analysieren lässt:

curl -s --unix-socket /var/run/docker.sock http://localhost/images/json | jq

Tipp

Paket jq nachinstallieren! Anm.: für CentOS benötigt man EPEL-Repo!

Bei diesen Ausgaben gleich auch die Syntax der JSON-Files beachten (Klammerungen, Aufzählungen mit Kommata).

Docker Images Windows

siehe Windows Server Core, Nano Server, IIS, ASP.NET; Anm.: Nano Server nur für Windows Server Instanz!

Registry

Image-Datenbank mit Service zum pullen und pushen von Images

Im Produktionsbetrieb müsssen aus Sicherheitaspekten vertrauenswürdige und daher firmeninterne Registries genutzt werden.

Docker Registry: https://index.docker.io/v1/

Registry finden: docker info | grep -i registry

Alternative Registries:

Anm.: Werden im Seminar - bis auf Weiteres - keine Rolle spielen (siehe auch nötige Accounts, ggfs. Kosten, …)

Repository

Logische Unterteilung einer Registry; Fundus mit mehreren Images (siehe Tags); siehe ubuntu:* (beliebige Ubuntu-Varianten)

keine init/systemd Techniken

Was passiert bei mehr als einem Dienst pro Container?

Virtuelle VMs vs. Container

die Container als „Leichtgewichte“ und ohne Prozesse-Lasten; und Nutzung von VMs für Docker-Hosts!

Virtuelle Maschinen und Container

Virtuelle Maschinen und Container (Bild: Liebel - Skalierbare Container-Infrastrukturen für Ihr Unternehmen)

Container Lösungen (Wikipedia Containervirtualisierung )

  • Klassiker:

    FreeBSD Jails (ca. 2000), Solaris Zones (ca. 2005), OpenVZ (ca. 2005; siehe Virtuozzo von Parallels)

  • LXD für LXC (ca. 2008; Linux Containers oder Lightweight Linux Container) - Ausgangsbasis für Docker

  • rkt (sprich: Rocket) - von CoreOS (bzw. Produkt Container Linux)

  • VMware Photon

  • Docker

    März 2013 Fa. dotCloud - dann Oktober 2013 umbenannt in Docker Inc. mit Sitz in Berlin

    Neue Componenten (ab Version >= 1.11): containerd, runc,

    aus „Docker Daemon“ wurde Docker Engine;

    ab Version 1.12 mit eingebauter Swarm Technik: Swarm Mode

    Schwerpunkt auf Applikationsvirtualisierung und nicht auf abgespeckte VMs

Tipp

Darstellung runc als eigenständiges Container-Tool bei Liebel (S. 85ff.)

Container Formate

  • Docker, CoreOS/rkt, LXD/LXC, Photon, …

  • OCF (Open Container Format) der OCI (Open Container Initiative - www.opencontainers.org

Namespaces

Ressourcen von Kernel lassen sich isolieren - Prozesse erhalten quasi eigene Umgebung

Tipp

Übung mit uname -r und grep -i pretty_name /etc/os-release Aufrufen in Host und Containern!

1.4. Sicherheit

Faktoren für die Sicherheit der Container-Techniken:

  • Herkunft der genutzten Images

  • Wegen der Kernel-syscall Techniken (siehe namespaces) problematisch!

Tipp

Bitte seccomp >= Version 2.2.1

Anm./Empfehlung zu Thema namespaces:

# cat /boot/config-$(uname -r) | grep CONFIG_SECCOMP=
CONFIG_SECCOMP=y
# rpm -qa | grep seccomp
libseccomp2-2.3.2-lp150.1.9.x86_64
joeb@opensuse:~/rst/docker>

Links:

Empfehlungen:

  • Implementierungen mittels cgroups (Control Groups für Nutzung von Limits)

  • Applikationen in Container möglichst nicht mit root

  • Fähigkeiten der Images einschränken

  • User-Namespace aktiv

  • seccomp/SELinux/Apparmor

  • keine SUID im Container

  • aktuelle Kernel

  • Container-Host härten, aktualisieren, patchen

  • Container-Host Zugriffe einschränken

  • Netzwerk sichern / konfigurieren

Hinweis

Also: SELinux und auch Firewalltechnken (Netfilter/iptables, firewalld, …) bedenken.

Zu diesen vertiefenden Themen in Produktionsumgebungen an dieser Stelle keine weiteren Ausführungen.

2. Erste Beispiele

Wir wollen ein Gefühl für die Docker-Technik bekommen - „Learning by Doing

Fertige „Hello World“ Beispiele (inkl. Dockerfile Nutzungen) nach „Öggl/Kofler“ (siehe Literatur)

Tipp

Anm.: möglichst erst später im Seminar - wir wollen uns herantasten

  • apache2/php

  • node.js

  • python

Hier beispielhaftes Dockerfile für das Hello-World apache2/php Image:

Dockerfile apache2/php
1
2
3
FROM php:7-apache
ENV TZ="Europe/Amsterdam"
COPY index.php /var/www/html

Mehr dazu aber - wie bereits gesagt - erst später!

2.1. Beispiel Hello World!

Kein Seminar oder Scripting ohne ein „Hello World!“ Beispiel!

Erste Aufrufe also:

1
2
3
docker run hello-World
docker ps -a
docker images

2.2. Basis-Images

Beispielhafte Suche nach offiziellen Basis-Images: Docker Hub - Offizielle Basis Images

z.B. Ubuntu https://hub.docker.com/_/ubuntu

also:

docker run -it ubuntu

Bestehende Container nutzen:

docker start -i <name>  (oder die ID)

Anm.: bei Namen funzt Completion

Besser beim Erstellen der Container auf Namen achten: (hier für Container und Docker-„Maschine“)

docker run -it --name meinubuntu -h meinubuntuhostname ubuntu

Gleichzeitiges Ausführen von Kommando in laufendem Container:

docker exec -it meinubuntu /usr/bin/top

2.3. Beispiel MariaDB

Das Image stellt mit dem MariaDB-Service einen Background Prozesse zur Verfügung! Anm./Erinnerung: Container ohne Prozess(e) wird gleich wieder beendet! (siehe: hello-world)

docker run -d --name mariadb-test1 -e MYSQL_ROOT_PASSWORD=geheim mariadb

Stoppen eines Containers:

docker stop mariadb-test1

Containerinfos auslesen:

docker inspect maria-db-test1

Beachten: MariaDB Datenbank Verzeichnis /var/lib/mysql liegt im Docker-Container!

docker inspect maria-db-test1 | less

und die Zeilen mit Mounts analysieren.

Die Datenbank (wenn diese läuft) mit MySQL/MariDB-Client checken:

docker exec -it mariadb-test1 mysql -u root -p

Den Container analysieren:

docker exec -it mariadb-test1 /bin/bash
# Aufrufe:
cat /etc/os-release
ps ax
mysqld --version
exit

Das Logging übernimmt Docker für den Hintergrund-Daemon Mysqld:

docker logs mariadb-test1

Jetzt erweitern wir das Beispiel mit eigenem Volume im Userdir Home:

mkdir /home/joeb/varlibmysql     # manuelles mkdir (ggf.) nicht nötig!
docker run -d --name mariadb-test2 \
    -e MYSQL_ROOT_PASSWORD=geheim \
    -v /home/joeb/varlibmysql/:/var/lib/mysql  mariadb

So jetzt haben wir einen neuen Container mariadb-test2 mit den DB-Dateien im Homedir eines Users.

Hinweis

Diese Umleitung für Volumes kann bei Nicht-Linuxen problematisch sein!

Jetzt noch ein Container - hier mit Portumleitungen:

docker run -d --name mariadb-test3 \
    -v /home/joeb/varlibmysql/:/var/lib/mysql \
    -p 13306:3306 mariadb

Und jetzt klappt der Zugriff auch direkt über den Docker-Host:

mysql -u root -p --port 13306 --protocol=tcp

2.4. Beispiel Networking

Mit Ports kann man also (in)direkt auf die Dockerdienste / Dockerprozesse zurgreifen. Besser ist es allerdings mit eigenen Dockernetzwerk die nötigen Container zu verbinden.

Anm.: bitte (immer) vorher alle beteiligten „MariaDB-Container“ stoppen.

Neues Netzwerk erstellen und und neuen MariaDB-Container mit PhpMyAdmin nutzen:

docker network create test-net
docker run -d --name mariadb-test4 \
    -v /home/joeb/varlibmysql/:/var/lib/mysql \
    --network test-net mariadb
docker run -d --name pma -p 8080:80 \
    -e PMA_HOST=mariadb-test4 \
    --network test-net phpmyadmin/phpmyadmin

Anm.: beim letzten Aufruf ist der volle Name für das PhpMyAdmin-Image zu beachten.

Siehe: PhpMyAdmin Image auf Docker Hub

Docker-Netzwerke erledigen selbstständig die Namensauflösungen! Aber: es werden die mit der Option -- name erstellten Bezeichner verwendet.

2.5. Beispiele WordPress

Vor der Bereitstellung von WordPress benötigen wir eine MySQL/MariaDB-Docker-Instanz und ein passendes Dockernetzwerk.

Infos zum Wordpress Image siehe: Wordpress Image auf Docker Hub

Auf dem Docker Hub Portal zu Wordpress finden sich auch die Erläuterungen für die speziellen WordPress Umgebungsvariablen (siehe Parameter -e).

Hier die vollständigen Konfigurationen…

Lokale Verzeichnisse für DB und WordPress-Website: (Anm.: ich habe gerne ein Hauptverzeichnis für die Docker-Dirs, die Unterverzeichnisse würde Docker heute auch selber anlegen!)

mkdir -p /home/joeb/docker/varlibmysql
mkdir /home/joeb/docker/wp-html

Test-Netzwerk:

docker network create test-net
docker network list

DB MariaDB bereitstellen: (bei Tests auf Name –name achten - Nummerierungen)

docker run -d --name mariadb-test5 \
    -e MYSQL_ROOT_PASSWORD=geheim --network test-net \
    -v /home/joeb/docker/varlibmysql/:/var/lib/mysql  mariadb

Und jetzt noch WordPress:

docker run -d --name wp-test1 --network test-net \
    -v /home/joeb/docker/wp-html:/var/www/html -p 8081:80 \
    -e WORDPRESS_DB_PASSWORD=geheim \
    -e WORDPRESS_DB_HOST=mariadb-test5 wordpress

Und natürlich lässt sich auch der PhpMyadmin Zugriff bereitstellen:

docker run -d --name pma -p 8080:80 \
    --network test-net -e PMA_HOST=mariadb-test5 phpmyadmin/phpmyadmin

Hinweis

Bitte immer auf die Ports achten!

Soweit ein kleiner Überblick mit praktischen Beispielen.

2.6. Vertrauenswürdige Images

Wir nutzen bisher einfach öffentliche Images aus möglichst offiziellen Quellen.

Wie sieht es aber mit echt vertrauenswürdigen Images aus?

Eigenes Basis-Image

Wir erstellen/installieren ein Template-System und erstellen hieraus einen Tarball.

Dieses lässt sich dann auf dem Docker-Host wieder Importieren.

Image-Erzeugung per Skript

Beispiel: YUM-Based mit Skript online

Images from Scratch

Siehe Docker Registry: Offizielles Image Scratch

SUSE/SLES sle2docker

Auf Ruby basierendes spezielles Tool mit speziellen Registries für Suse-Plattformen.

2.7. Faktoren für Security

Ganz wichtige aber eben auch ganz dicke Bretter…

  • AppArmor (Application Armor)

  • SELinux (Security Enhanced Linux) - wollen wir für Test auf permissive

    Status ermitteln mit: sestatus oder ls -Z (bei CentOS; bei Debian, openSUSE sollte SELinux deaktiv sein)

    (Auszug/Zeile:) Current Mode: enforcing

    Ausschalten mit setenforce 0

    Dauerhafte Konfiguration in /etc/sysconfig/selinux

  • Netfilter/iptables (bzw. Dienste firewalld, ufw)

    Anm.: auch immer mal verantwortlich bei vermeintlichen Docker Technik Problemen!

3. Erste Administration

Die komplette Administration ergibt sich erst durch längere Praxis und Erfahrungen mit den mannigfachen Docker-Aufrufen und Tools.

Hier eine erste kleine Übersicht…

3.1. Images, Container

Liste der heruntergeladenen bzw. selbst erstellten Images:

docker images

Container analysieren:

docker ps        # laufende Container
docker ps -a     # alle Container
docker ps -a s   # alle Container mit Größenangaben

Beachten bei den Größenangaben: virtuell - mehrere Container können gleiche Images nutzen.

Gefahr

Die Löschkommandos gerne ohne Rückfragen! Wie bei Linux-Konsolen eben üblich!

Container löschen:

docker rm <id>
docker rm <name>

Die IDs der Container kann mit Parameter -q erhalten und so ergeben sich praktische Aufrufe zum Löschen von Containern:

docker ps -a -q
docker ps -a -q -f ancestor=hello-world              # alle Container von Image hello-world
docker rm $(docker ps -a -q -f ancestor=hello-world) # löschen
docker rm $(docker ps -aq)                           # alle Container löschen!!!

Images löschen:

docker rmi hello-world

3.2. Volumes

Die Volumes werden beim Löschen von Containern nicht mitgelöscht, was ja auch ganz im Sinne der technischen Nutzung ist (siehe Aktualisierung von Containern).

Verzeichnis für Volumes (bei Linux): /var/lib/docker/volumes

Zu beachten in aktuellen Beispielen entweder keine Volumens genutzt (siehe docker inspect) oder die Volumes anders gemountet!

…tbc…

3.3. Overlay-Dateisysteme

Die Struktur aus (von unten nach oben):

  • Read-only Schichten

    • bootfs mit Kernel und cgroups

    • Basis Image (z.B. Alpine)

    • Application Image (z.B. Webserver Apache oder Nginx)

    • weitere Application-Layers

  • Read-Write Container Schicht (quasi on top)

    Jetzt wird aus einem Image ein Container!

Copy-On-Write (COW)

Zugriff durch die Schichten und in oberster Schicht (rw-Container) Kopie anlegen, für Daten aus den unteren ro-Schichten.

Ermitteln des Storage-Overlay-Systems:

docker info | grep Storage

Durch die Schichten

Übersicht Overlay-Systeme:

  • vfs (nur für Testing/Debugging)

  • aufs (ältester Docker Storage Driver; Advanced Multi-layered Unification Filesystem)

    Anm.: nur noch selten vertreten; siehe: Knoppix

  • overlay2 (die modernisierte overlay Variante und Docker-Standard)

    Anm.: Kernel >= 4.0 nötig!

  • btrfs (siehe openSUSE/SLES)

    Achtung (siehe Suse Installationen): Literatur empfiehlt noch keinen produktiven Einsatz!

  • zfs

    performant, hoher RAM-Verbrauch, Lizenzfragen; hinterfragen: Ubuntu nutzt zfs

  • devicemapper

    in allen Distros verfügbar; muss mit direct-lvm eingebunden werden (nicht: loop-lvm)

Hier mal eine Grafik zur OverlayFS(2) Technik:

Overlay(2)FS

OverlayFS(2)-Modell (Bild: Liebel - Skalierbare Container-Infrastrukturen für Ihr Unternehmen)

Siehe hierzu auch Ordnerstrukturen: /var/lib/docker/overlay...

3.4. Netzwerke

Spater hierzu mehr - hier: 101

Netzwerke auflisten:

docker network ls             # auflisten
docker network inspect bridge # analysieren

3.5. Konfiguration Daemon

Verschiedene Möglichkeiten für die Docker Daemon Konfiguration:

  • Beim Starten über die Kommandozeile - siehe dockerd --help

  • Docker config: /etc/sysconfig/docker (z.B. DOCKER_OPTS="")

  • Systemweite config: /etc/docker/daemon.json

  • Benutzer config: ~/.docker/config.json

Tipp

Möglichst nicht mischen/kombinieren!

3.6. Sicherheit

Container sind zwar durch Namespaces isoliert. Doch das ist bei Weitem nicht derselbe Schutz, wie es bei echten Virtualisierungen erreicht werden kann.

Technische Ansätze zur Isolierung zum Host:

  • Namespaces (siehe UIDs, GIDs, PIDs pro Container)

  • Mount-Namespaces auf Kernelebene (sicherer als chroot)

  • eigener Netzwerkstack

Gefahr

Docker Prozess verlangen nach root

Siehe Rechte für

ls -l /var/run/docker.sock
srw-rw---- 1 root docker 0  7. Jan 12:35 /var/run/docker.sock

Aus Vereinfachungs- und Seminargründen entscheiden wir uns dennoch für

usermod -aG docker joeb

Ansätze zur Verbesserung der Sicherheit:

4. Dockerfile

Bis jetzt haben wir fertige Images (siehe hub.docker.com) genutzt und mit diesen Images die Container erstellt.

Hinweis

Später: mit docker-compose werden mehrere Container kombiniert eingerichtet!

Die meisten Images waren auch ordentliche Vorlagen, aber z.B. in Ubuntu würde man vielleicht gerne das Paket iproute2 nachinstallieren, … usw.

Also wollen wir jetzt unsere eigenen Images erstellen und bedienen uns eines Dockerfile, das alle nötigen Anweisungen enthält!

4.1. Kurzanleitung

  • Ordner für Image erstellen

  • ggf. Dateien im Ordner bereitstellen (z.B. Skripte, Webdateien/Ordner)

  • Datei Dockerfile im Ordner erzeugen und Inhalt/Konfiguration für Image festlegen

  • mit docker build ein neues Image lokal erzeugen

  • mit docker push (ggf.) im Docker-Hub veröffentlichen (wörtlich zu nehmen: public)

Alternative Veröffentlichungstechniken für eigene Images:

  • GitHub für Dockerfile bzw. Ordner/Dateien für automatisierte Builds

  • Private Image Repository auf Docker Hub ($)

  • Eigenes Docker Repository

Links:

4.2. Syntax

Schlüsselwörte für ein Dockerfile als Tabelle:

Schlüsselwort

Bedeutung

ADD

kopiert Dateien in das Dateisystem des Images

CMD

führt Kommando beim Start des Containers aus

COPY

kopiert Dateien aus Projekverzeichnis in das Image

ENTRYPOINT

führt Kommando beim Start des Containers aus

ENV

setzt eine Umgebungsvariable

EXPOSE

gibt die aktiven Ports an

FROM

gibt das Basis-Image an

LABEL

legt Zeichenkette fest

RUN

führt das Kommando aus

USER

Account für RUN, CMD und ENTRYPOINT

VOLUME

gibt Volume-Dirs an

WORKDIR

Arbeitsverzeichnis für RUN, CMD und ENTRYPOINT

Erläuterungen:

Kurze Analyse / Erläuterungen:

ADD v. COPY - scheinen ja dasselbe zu tun, aber ADD kann…

  • … auch mit URL umgehen

  • … auch (wie COPY) Verzeichnisinhalte komplett kopieren

  • … mit TAR-Archiven arbeiten/entpacken (gzip, bzip2, xz)

Beide können mit –chown=user:group Parameter umgehen.

In Kürze: COPY nur für einfaches Kopieren einer lokalen Datei.

CMD v. ENTRYPOINT - Startkommandos für Container

Wenn man Container mit mit docker run Komandos anfügt, dann …

  • … wird bei CMD das angefügte Kommando anstelle von CMD ausgeführt

  • … wird bei ENTRYPOINT das Kommando hinzugefügt

4.3. Image erstellen

Vorgehen für Beispiel 2 (s.u. einfacher Webserver)

mkdir -p /home/joeb/projektverzeichnis/samplesite
cd /home/joeb/Projekverzeichnis
touch samplesite/index.html samplesite/style.css   # HTML/CSS-Site nach Gusto
touch Dockerfile                                   # siehe Dockerfile Beispiel
docker build -t joebrandes/testwebserver .         # Image erzeugen / taggen
docker run -d -p 80:80 -p 443:443 -h webtest \     # Container erzeugen
    --name testwebserver joebrandes/testwebserver

Die normale (und https-gesicherte) Seite sollte sich jetzt im Browser öffnen lassen!

4.4. Beispiele

Ein paar Beispiele aus Öggl/Kofler…

4.4.1. Beispiel 1

Beispielhaftes erstes Dockerfile:

Dockerfile nach Öggl/Kofler (S. 63)
1
2
3
4
5
6
7
8
# Datei Dockerfile
FROM ubuntu:18.04
LABEL maintainer "kontakt@kofler.info"
RUN apt -get update && \
    apt-get install -y joe && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
CMD ["/bin/bash"]

Im Seminar analysieren - Wert legen auf Zusammenfassung für RUN mit && Konstruktion!

4.4.2. Beispiel 2

Beispiel für einfachen Webserver:

Dockerfile für Webserver nach Öggl/Kofler (S. 69)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Datei Dockerfile
FROM ubuntu:18.04

LABEL maintainer "kontakt@kofler.info"
LABEL description "Test"

# Apache installieren, und unnötige Dateien aus dem Paket - Cache
# gleich wieder entfernen
RUN apt-get update && \
    apt-get install -y apache2 && \
    apt-get -y clean && \
    rm -rf /var/cache/apt /var/lib/apt/lists/*

# HTTPS -Unterstützung aktivieren
RUN a2ensite default-ssl && a2enmod ssl

ENV APACHE_RUN_USER=www-data \
    APACHE_RUN_GROUP=www-data \
    APACHE_LOG_DIR=/var/log/apache2

EXPOSE 80 443

# gesamten Inhalt des Projektverzeichnisses
# samplesite nach /var/www/html kopieren
COPY samplesite/ /var/www/html

CMD ["/usr/sbin/apache2ctl" , "-D" , "FOREGROUND"]

4.4.3. Beispiel 3

Alpine Linux mit Apache2

Hier sind wir durch Recherchen zu Alpine Linux und diversen Dockerfile Analysen herausgefordert worden (Anm.: Apache als Prozess am Laufen halten im Container!)

Dockerfile für Alpine Linux mit Apache2
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
FROM alpine

LABEL maintainer "dummy@aol.com"
LABEL description "Test Alpine und Apache"


RUN apk update && apk upgrade && \
    apk add apache2 libxml2-dev apache2-utils && \
    rm -rf /var/cache/apk/*

# war zwischendurch nötig: 
# RUN mkdir /run/apache2

ENV APACHE_RUN_USER=apache \
    APACHE_RUN_GROUP=www-data 

EXPOSE 80 443

COPY samplesite/ /var/www/localhost/htdocs

CMD ["/usr/sbin/httpd", "-DFOREGROUND"]

4.4.4. Beispiel 4

Als ausführlicheres Dockerfile-Beispiel liefern Öggl/Kofler für „Pandoc“:

Dockerfile pandoc Installationen nach Öggl/Kofler (S. 73ff.)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# Datei Dockerfile
FROM haskell

# Pakete installieren
RUN apt-get update -y && \
    apt-get install -y -o Acquire::Retries=10 \
                     --no-install-recommends \
      texlive-latex-recommended \
      texlive-latex-extra \
      texlive-fonts-recommended \
      texlive-lang-german \
      texlive-pstricks \
      imagemagick \
      unzip \
      python3 \
      ghostscript \
      less && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Pandoc installieren
RUN cabal update && \
    cabal install pandoc-2.1.1 && \
    ln -s /root/.cabal/bin/pandoc /usr/bin/pandoc

# Mitteleuropäische Zeitzone
# (siehe https://serverfault.com/questions/683605)
RUN cp /usr/share/zoneinfo/Europe/Berlin /etc/localtime

# Fonts für LaTeX installieren
# ADD rheinwerkfonts.tgz /usr/local/share/texmf
# RUN texhash

# Volume /data, bei docker run mit dem Arbeitsverzeichnis
# verbinden, also: docker run -v $(pwd):/data
WORKDIR /data
VOLUME  ["/data"]

ENTRYPOINT ["/bin/bash"]

Die Kollegen richten also - wie ich mit SphinxDoc - eine Umgebung ein, in der sie mit Hilfe von Markdown und dem Werkzeug pandoc dann HTML als auch LaTeX-Versionen für Print/PDF generieren können.

5. Docker Kommandos

Auflistung von Docker Befehlen: Docker Befehle

Wir haben schon einigen Docker CLI Kommandos genutzt. Jetzt sollen komplettere Aufstellungen folgen.

Die Aufrufe sind nach Kategorien gegliedert. Die Aufrufe lassen sich teilweise in langer und kurzer Schreibung aufrufen:

docker container ps -a     # oder auch kürzer
docker ps -a

Das hat auch mit historischen Entwicklungen innerhalb der Docker-Versionen zu tun! Eine neue und saubere Kommanostruktur wurde mit Version 1.13 eingeführt.

Tipp

Paket docker-bash-completion in der Shell nutzen: also fleißig mit Tab-Tab vervollständigen!

Wir beginnen aber wie immer mit der eingebauten Hilfe…

5.1. docker help

Onlineportal für Docker CLI:

https://docs.docker.com/engine/reference/commandline/cli/

Tipp

Die Befehle (z.B. docker events) lassen sich einfach in URL an Stelle von cli ersetzen!

Und natürlich kann man auch jederzeit mal die interaktive Docker Hilfe nutzen.

docker help (teilweise Zeilen gekürzt)
Usage:	docker [OPTIONS] COMMAND

A self-sufficient runtime for containers

Options:
      --config string      Location of client config files (default "/home/joeb/.docker")
  -D, --debug              Enable debug mode
  -H, --host list          Daemon socket(s) to connect to
  -l, --log-level string   Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") ...info
      --tls                Use TLS; implied by --tlsverify
      --tlscacert string   Trust certs signed only by this CA (default ".../.docker/ca.pem")
      --tlscert string     Path to TLS certificate file (default ".../.docker/cert.pem")
      --tlskey string      Path to TLS key file (default "/home/joeb/.docker/key.pem")
      --tlsverify          Use TLS and verify the remote
  -v, --version            Print version information and quit

Management Commands:
  builder     Manage builds
  config      Manage Docker configs
  container   Manage containers
  engine      Manage the docker engine
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  stack       Manage Docker stacks
  swarm       Manage Swarm
  system      Manage Docker
  trust       Manage trust on Docker images
  volume      Manage volumes

Commands:
  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

Run 'docker COMMAND --help' for more information on a command.

Mit der Hilfe kann man sich auch weiter in die Kommando-Hierarchien begeben:

docker container ps –help
Usage:	docker container ls [OPTIONS]

List containers

Aliases:
  ls, ps, list

Options:
  -a, --all             Show all containers (default shows just running)
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print containers using a Go template
  -n, --last int        Show n last created containers (includes all states) (default -1)
  -l, --latest          Show the latest created container (includes all states)
      --no-trunc        Don't truncate output
  -q, --quiet           Only display numeric IDs
  -s, --size            Display total file sizes

Und ja: es handelt sich bei der Textausgabe der Hilfe nicht um einen Fehler - es wurde docker container ps --help aufgerufen - man erkennt dann die Aliase.

Und zuletzt wurden auch klassische Man-Pages für die docker-Kommandos implementiert, die man einfach über mit „-“ (Bindestrich) zusammengesetzte Aufrufe erhält: man docker-start

5.2. docker

Allgemeine Docker Kommandos:

Kommandos

Funktionalität

docker container

Hauptbefehl: Container verwalten

docker events

laufend (!) Aktionen des Docker-Systems anzeigen

docker info

Status Docker-System

docker image

Hauptbefehl: Images verwalten

docker login/logout

am Docker-Account an-/abmelden

docker network

Hauptbefehl: Docker-Networking verwalten

docker node

Haupbefehl: Docker Swarm Knoten verwalten

docker search

Images (unter docker.io) suchen

docker secret

Hauptbefehl: Secrets für Services

docker service

Hauptbefehl: Services verwalten (siehe Cluster)

docker stack

Hauptbefehl: Stack (Gruppe von Services) verwalten

docker stats

laufend (!) CPU, MEM anzeigen lassen

docker swarm

Haupbefehl: Swarm einrichten / verwalten

docker system

Haupbefehl: Infos zu Docker System

docker version

Docker Version(en) anzeigen lassen

docker volume

Hauptbefehl: Volumes verwalten

Es folgen ein paar individuelle Anmerkungen zu einzelnen docker-Kommandos.

docker events

Eine laufende Konsole - also gerne wieder mit mehreren Terminalfenstern arbeiten (siehe Tilix).

# Alle Events in einem bestimmten Zeitraum:
docker events --since '2019-01-01' --until '2019-01-10'
# in den letzten 50 Minuten
docker events --since '50m'
# für ein bestimmtes Image (oder auch 'container=...')
docker events --since '40m' --filter 'image=alpine'
# Event types filtern:
docker events --since '2019-01-01' --filter 'container=alpinejoeb' --filter 'event=start'

Die Ausgaben können formatiert (Parameter --format) ausgegeben werden (auch JSON).

Anm.: Linux Kernel verteilen Privilegien (Capabilities)

Hier: Docker Prozess im Host finden und CapEff finden: cat /proc/PID/status | grep CapEff

Die Hex-Kodierung CapEff des Prozesse analyisieren: capsh --decode=<hexcode>

Tools capsh in Paket libcap-progs (Suse) oder libcap (CentOS).

docker info

Die Infos zum laufenden Docker-System.

Die Anzahl der laufenden Container anzeigen mit docker info | grep Running.

docker search

Einfache Suche: docker search ubuntu

Anzahl Images (hier: ubuntu): docker search ubuntu | grep "\/ubuntu\ " | wc -l

Filtern: docker search --filter=stars=7 --filter=is-official=true ubuntu

docker stats

Entspricht dem Linux-Klassiker top für die Shell.

docker system

Speichernutzung anzeigen lassen mit docker system df

Aufräumen / „Echt Alles ;-) Tabularasa“ mit `` docker system prune`` (--all --force)

docker network …

Hauptbefehl für Docker-Networking (siehe auch wieder docker network --help)

Kurze Befehlsliste: docker network ...

  • create (Netzwerk erstellen)

  • connect <nwid> <cname/cid>

  • inspect <nwname/nwid>

  • ls (Netzwerke auflisten)

  • prune (ungenutzte Netzwerke löschen; siehe docker-compose)

Online: Infoseite Docker Networking

5.3. docker image

Docker Kommandos für Images:

Kommandos

Funktionalität

docker image

Hauptbefehl: Images verwalten

docker build

neues Image mit Dockerfile

docker images

Images auflisten: docker image ls

docker history

Build-History eines Images

docker inspect

lokale Images analysieren

docker pull

Image herunterladen / aktualisieren

docker push

Image in Docker Repo hochladen

docker rmi

Image löschen

docker save / load

aus Images einen Tarball erzeugen

docker tag

Image-Namen bzw. -Tag anpassen

docker pull

Wenn nur ein Imagename angegeben wird, dann wird das Image mit Tag :latest gepullt!

Images mit Tag:latest müssen nicht immer die aktuellsten Images sein!

Kompletter Aufruf: docker pull [OPTIONS] REGISTRY:REG-PORT/IMAGE:TAG|@DIGEST

Optionen: -a | --all-tags um alle Images(:tags) mit einem Imagenamen zu pullen (gesamtes Image-Repository)

docker images oder auch docker image ls

Mit Option --no-trunc komplettere Ausgaben und -q für quiet, was einfach die (kurzen) IDs ausgibt!

Alle Images auflisten:

docker images -a

REPOSITORY                 TAG                 IMAGE ID            CREATED             SIZE
mariadb                    <none>              2bdd97ca79d9        6 days ago          366MB
joebrandes/testwebserver   latest              9ff70d3871d4        7 days ago          183MB
<none>                     <none>              7c54877665f7        7 days ago          183MB
<none>                     <none>              6a247201e8a3        7 days ago          183MB
<none>                     <none>              aef9419d7b92        7 days ago          183MB
<none>                     <none>              c21c0c4fe351        7 days ago          183MB
<none>                     <none>              a3ff1c7635da        7 days ago          183MB
<none>                     <none>              2bd50cd1f5b1        7 days ago          86.7MB
<none>                     <none>              86e536f3da5c        7 days ago          86.7MB
hello-world                latest              fce289e99eb9        2 weeks ago         1.84kB
wordpress                  latest              9ec2fcdda9ef        2 weeks ago         420MB
mariadb                    latest              4f2e75647d2a        2 weeks ago         366MB
ubuntu                     18.10               d4452947e3fa        2 weeks ago         73.7MB
ubuntu                     18.04               1d9c17228a9e        2 weeks ago         86.7MB
alpine                     latest              3f53bb00af94        3 weeks ago         4.41MB

Die hier aufgelisteten none:none Images enstehen durch das Layersystem von Images und belegen und verschwenden keinen Platz im System!

Problematisch sind Image die mit none:none bei normalem docker images (ohne -a) auftauchen:

Dangling Images - verwaiste Einträge

Finden von Dangling Images: docker images -f "dangling=true"

Löschen / Aufräumen: per Filtern oder mit docker image prune

docker images -f "dangling=true" -q | xargs -n1 docker rmi -f
# oder einfach mit:
docker image prune

docker inspect oder auch docker image inspect

Formatierte Ausgaben mit Parameter --format

docker inspect --format='{{.Config.Cmd}}' alpine:latest
[/bin/sh]
# oder einfacher mit:
docker inspect alpine:latest | grep -i Cmd

Das lässt sich auch wieder aufbereiten (Tool jq):

docker image inspect alpine:latest | jq -CS                       # C Color; S sortiert
docker image inspect alpine:latest | jq -CS .[0].Config.Cmd       # Zugriff auf Array
[
"/bin/sh"
]

Die Ausgabe von Docker Kommandos ist auch über Go-Templates möglich: (Go Templates )

docker image inspect alpine:latest --format '{{.Config.Cmd}}'
[/bin/sh]
docker image inspect alpine:latest --format '{{json .Config.Env}}' | jq
[
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
]

Diese Ausgabeformate lassen sich auch bei anderen cmd-Techniken nutzen (siehe docker container ls ...).

docker save | load

Speichert Images in einem Tarball - nicht mit dem Export / Import von Containern verwechseln

docker save -o ~/alpine-out.tar alpine
tar -tvf alpine-out.tar

-rw-r--r-- 0/0            1511 2018-12-21 01:21 3f53bb00af943dfdf81...129d57d5991.json
drwxr-xr-x 0/0               0 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/
-rw-r--r-- 0/0               3 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/VERSION
-rw-r--r-- 0/0            1184 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/json
-rw-r--r-- 0/0         4672000 2018-12-21 01:21 a21b1050952cdc06771...57cae64904b/layer.tar
-rw-r--r-- 0/0             202 1970-01-01 01:00 manifest.json
-rw-r--r-- 0/0              89 1970-01-01 01:00 repositories

In layer.tar befindet sich das eigentliche Image mit den Ordnerstrukturen /, /bin, /usr, …

Diese Sicherung lässt sich dann auf einem anderen Rechner wieder loaden.

5.4. docker container

Docker Kommandos für Container:

Kommandos

Funktionalität

docker container

Hauptbefehl: Container verwalten

docker attach

I/O eines Containers mit Terminal connecten

docker commit

neues Image aus Container

docker cp

Kopieren von Daten zwischen Container <-> Host

docker create

Container erzeugen, aber nicht starten

docker diff

veränderte Dateien eines Containers erzeugen

docker exec

Kommando in laufendem Container ausführen

docker export

Container in Archiv speichern

docker import

Container aus Archiv erzeugen

docker inspect

Konfiguration und Status eines Containers

docker kill

Container sofort beenden

docker logs

Container-Loggings

docker pause/unpause

Container anhalten/fortsetzen

docker port

Container Ports auflisten

docker ps

Container auflisten

docker rename

Container umbenennen

docker restart

Container neu starten

docker rm

Container löschen

docker run

neuen Container erzeugen und starten

docker start

Container starten

docker stop

Container anhalten

docker top

Container Prozesse anzeigen

docker update

Container Optionen anpassen

docker wait

Container Ende erwarten

docker attach

Auf Container die man mit docker run -it oder docker start -a -i gestartet hat, kann man ja über die interaktive Konsole zugreifen.

Andernfalls kann man mit docker attach diese Funktionalität nachholen.

docker commit

Man sollte besser über Dockerfile und Builds arbeiten, weil sonst die Aufbauten der Images nicht mehr nachvollziehbar sind!

docker cp

Manuelle Kopieren von Daten zwischen Container und Host, was normaler Weise automatisch beim Erzeugen von Images genutzt wird.

echo "Testing" > /tmp/testdatei
docker start alpinejoeb
docker container cp /tmp/testdatei alpinejoeb:/
docker exec alpinejoeb cat /testdatei
docker stop alpinejoeb

docker diff

Abweichungen zwischen Container und ursprünglichem Image auflisten.

  • A (added - hinzugefügt)

  • C (changed - geändert)

  • D (deleted - gelöscht)

docker exec

Befehle in einem laufenden Contaier aufrufen. Der Container muss aktiv sein / laufen.

Wird eine Shell im exec benutzt und mit exit verlassen, dann läuft der Container weiter!

docker export

Beim Exportieren eines Containers werden alle Layer zusammengefasst! Man spricht vom flatten für Image Layer. Das ist beim docker save | load für Images gänzlich anders.

Anm.: Daten in Volumes werden nicht berücksichtigt!

docker images

Bitte auf Plural achten! Tipp: docker images -q listet nur die IDs auf und kann somit gut zum Pipeling für andere Docker-Aufrufe genutzt werden!

docker inspect

Arbeitet mit Images und Containern und erzeugt Infos im JSON-Format.

JSON anzeigen:

docker inspect -s mariadb-test5
...
...
    {
        "Id": "cd42b1a7c4542f76174f936e5a2060f1f87e3511d3fe5e07bb27e15a1ca74ea5",
        "Created": "2019-01-06T19:56:47.958915783Z",
        "Path": "docker-entrypoint.sh",
        "Args": [
            "mysqld"
        ],
        "State": {
            "Status": "exited",
            "Running": false,
            "Paused": false,
            "Restarting": false,
            "OOMKilled": false,
            "Dead": false,
            "Pid": 0,
            "ExitCode": 0,
            "Error": "",
            "StartedAt": "2019-01-06T19:56:48.881461371Z",
            "FinishedAt": "2019-01-06T20:15:04.192413984Z"
        },
...
...

Analyse über Parameter -f (format)

docker inspect -s -f "{{.State.Status}}" mariadb-test5
docker inspect -s -f "{{.State.FinishedAt}}" mariadb-test5

docker ps (kurz für: docker container ps)

Filterung mit Kriterium: -f <Kriterium=Wert>

Filterungs-Schalter aus Hilfen zu den Tools docker-ps bzw. docker-container-ls|ps

Filter output based on these conditions:
- ancestor=(<image-name>[:tag]|<image-id>| image@digest )
  containers created from an image or a descendant.
- before=(<container-name>|<container-id>)
- expose=(<port>[/<proto>]|<startport-endport>/[<proto>])
- exited=<int> an exit code of <int>
- health=(starting|healthy|unhealthy|none)
- id=<ID> a container's ID
- isolation=(default|process|hyperv) (Windows daemon only)
- is-task=(true|false)
- label=<key> or label=<key>=<value>
- name=<string> a container's name
- network=(<network-id>|<network-name>)
- publish=(<port>[/<proto>]|<startport-endport>/[<proto>])
- since=(<container-name>|<container-id>)
- status=(created|restarting|removing|running|paused|exited)
- volume=(<volume name>|<mount point destination>)

Formatierte / tabellarische Ausgaben mit Schalter --format:

docker container ls -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Labels}}"
docker container ls -a --format '{{printf "%-30s%-30s" .Names .RunningFor}}'
# auch hier wieder JSON Formatierung möglich:
docker container ls -a --format '{{json . }}' | jq

Formatierungs-Schalter (siehe Go-Templates) gerne wieder per Hilfen zu den Tools docker-ps bzw. docker-container-ls|ps

Valid placeholders for the Go template are listed below:
- .ID           - Container ID.
- .Image        - Image ID.
- .Command      - Quoted command.
- .CreatedAt    - Time when the container was created.
- .RunningFor   - Elapsed time since the container was started.
- .Ports        - Exposed ports.
- .Status       - Container status.
- .Size         - Container disk size.
- .Names        - Container names.
- .Labels       - All labels assigned to the container.
- .Label        - Value of a specific label for this container.
                  For example '{{.Label "com.docker.swarm.cpu"}}'.
- .Mounts       - Names of the volumes mounted in this container.
- .Networks     - Names of the networks attached to this container.

Exit Status aus Aufruf docker container ps -a

Die Nummern in Angabe Exited (#) von Spalte STATUS beziehen sich auf Exit-Meldungen beim Verlassen, stoppen oder killen eines Containers.

Eigene Docker Exit Return Code:

  • 125 Docker Daemon hat Fehler

  • 126 Container Kommando kann nicht aufgerufen werden

  • 127 Container Kommando konnte nicht gefunden werden

Ansonsten orientiert sich das Exit-Coding an

docker run

Erzeugt und startet einen neuen Container. Dabei wird, falls noch kein Image lokal vorhanden das entsprechende Image erst gepullt - also lokal bereitgestellt!

Bei Image-Namen ohne Tag wird versucht das image:latest genommen!

Siehe auch Extensives Manual für Kondsolentool docker-run!

Optionen

Funktionalität

–cpus=“1.25“

maximal 1,25 CPU Cores

-d

Container im Hintergrund (detached)

-e VAR=value

Variable für Container setzen

-h

Hostname

-i

interaktiv ausführen lassen

-m 512m

Container-RAM auf 512 MiB limitieren

–name cname

Containername

–network nwname

Netzwerk verwenden

-p localport:containerport

Portweiterleitungen zwischen Host und Container

-P

alle Port des Containers mit zufälligen Host-Ports

–rm

Container nach Ausführung löschen

-t

Pseudo-Terminal mit Standardausgabe verbinden

-v containerdir

Containerverzeichnis als Volume

-v vname:cdir

Volume mit Namen erzeugen

-v /localdir:cdir

Host-Dir mit Container-Dir verbinden

–volumes-from cname

Volume eines anderen Containers nutzen

Bemerkung

Enthalten Images keine aktiven Prozesse werden Container-Instanzen nicht am Leben gehalten!

Solche Prozesse (z.B. /bin/bash) müssen natürlich im Image vorhanden sein und direkt und sofort für den Container genutzt werden: also -it und nicht -d!

docker start | stop

Mit Parameter -ai (attach) direkt in eine Shell eines Containers starten: docker start -ai containername

Tipp

Die Container-Instanz wird mit exit beendet! Mit Strg+P Strg+Q läuft Container weiter!

Alle vorhandenen Container stoppen: docker stop $(docker ps -a -q)

Alle gestoppten Container entfernen: docker rm $(docker ps --filter "status=exited")

Oder mit neuem prune (dt.: stutzen, beschneiden) Schalter: docker container prune

docker top

Angelehnt an das top Kommando - hier aber als Einzelausgabe.

Aber der Reihe nach… wir starten erst einmal einen Container: docker start alpine (oder natürlich docker run ...).

CONTAINER ID   IMAGE    COMMAND    CREATED        STATUS        PORTS    NAMES
ba4471eeb783   alpine   "/bin/sh"  10 days ago    Up 17 minutes          alpinejoeb

Analyse auf Docker-Host mit ps axf ergibt (Anm. gekürzt und Umbrüche erzeugt):

1705 ?        Ssl    0:00  \_ docker-containerd
--config /var/run/docker/containerd/containerd.toml
--log-level info

3602 ?        Sl     0:00      \_ docker-containerd-shim -namespace moby
-workdir /var/lib/docker/containerd/daemon/io.containerd.runtime.v1.linux/moby/ba4471eeb783b...

3619 pts/0    Ss+    0:00          \_ /bin/sh

Man erkennt die PIDs für Container und Shell.

Jetzt mal die Prozesse im Container klassisch: docker container exec alpinejoeb ps ax

PID   USER     TIME  COMMAND
  1   root     0:00  /bin/sh
 11   root     0:00  ps ax

Und mit dem docker container top alpinejoeb -x Kommando: (Anm.: -x verkürzte Ausgabe)

PID                 TTY                 STAT                TIME                COMMAND
3619                pts/0               Ss+                 0:00                /bin/sh

Hinweis

Also völlig unterschiedliche Prozess-IDs aus verschiedenen Ansichten! Der erste Prozess im Container hat immer die Container-PID 1.

Prozesse lassen sich jederzeit von außen stoppen (killen).

Test:

# Endlosschleife im Container exec-uten:
docker container exec -d alpinejoeb /bin/sh \
  -c "while true; do echo palimpalim; sleep 1; done"

# Prozess für Schleife im Container ermitteln
docker container exec alpinejoeb ps ax (hier: Schleife mit PID 16)
# Prozess mit Container-PID 16 stoppen
docker container exec kill 16

6. docker-compose

Jetzt wollen wir die Bereitstellungen von Containern verbessern.

Mit docker run geht das zwar relativ einfach, aber wir wollen die Anweisungen zentral organisieren.

6.1. YAML

Die Konfiguration wird in der Textdatei docker-compose.yml bereitgestellt. Es handelt sich also um ein YAML gestylte Konfigurationsdatei.

Infoseiten zu YAML:

Für die Konformität der *.yml-Dateien kann wieder ein ordentlicher Editor (siehe VS Code) mit entsprechender Unterstützung sorgen.

Hinweis

Die Einrückungen (mit Leerzeichen) müssen genau passen - sie bestimmen die Gliederungen!

Kurzanleitung:

  • Abschnitt mit —

  • Kommentar mit #

  • Liste mit Bindestrich - oder in [eins, zwei, drei]

  • Hash mit key: wert oder {name: Joe, nachname: Brandes}

  • Textblock (mit Zeilenumbrüche) mit |

  • Textblock (ohne Zeilenumbrüche) mit >

Beispiel:

Beispiel YAML
# Datei sample.yaml
data:
  list:
    - item1
    - item2
  key1: >
    Dieser Text ist dem
    Schlüssel 'data.key1' zugeordnet.
  key2: |
    code line 1
    code line 2

YAML-Tool: shyaml (ein Python-Script)

openSUSE: sudo pip install shyaml

Beispielaufruf: shyaml get-value data.key1 < sample.yaml

6.2. Technik

Technischer Hintergrund…

In aktueller Docker-Technik kann man die docker-compose Techniken auch mit docker stack deploy Techniken - also: Swarm Services - ausführen und arbeitet quasi mit einem Minimal-Swarm von einer Docker-Instanz!

Hinweis

Das docker-compose Python-Skript kann Problemchen bereiten (Python!)

Wir beschränken uns - an dieser Stelle - auf docker-compose und behalten uns die Swarm-Techniken für später auf.

Webportal zu docker-compose: Docker Compose

Releases / Downloads GitHub: docker-compose Releases

Einfacher Download bzw. Installation:

curl -L https://github.com/docker/compose/releases/download/1.23.2/docker-compose-`uname -s`-`uname -m`
        -o /usr/bin/docker-compose
chmod +x /usr/bin/docker-compose        # Originalanleitung mit /usr/local/bin - siehe $PATH

6.3. docker-compose.yml

Was für die Docker Standardtechniken (docker run) das Dockerfile darstellt ist nun die Konfigurationsdatei docker-compose.yml für unser Tool docker-compose!

docker-compose.yml (Wordpress-Installation)
# Datei test/docker-compose.yml
version: '3.7'

services:
  db:
    image: mariadb:latest
    volumes:
      - /var/dc-test-db:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: geheim
    restart: always

  wordpress:
    image: wordpress:latest
    volumes:
      - /var/dc-test-www:/var/www/html
    ports:
      - "8082:80"
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_PASSWORD: geheim
    restart: always

Dieses Hello WordPress!-Beispiel zu docker-compose zeigt die zusätzliche „Intelligenz“ des docker-compose-Tools gegenüber den Basistools Docker.

cd test                    # hier ist das docker-compose.yml
mkdir /var/dc-test-www     # Volume Wordpress HTML; kann man weglassen (!)
mkdir /var/dc-test-db      # Volume MariaDB Databases; kann man weglassen (!)
docker-compose up -d

Test hier einfach wieder mit Browser (URL): localhost:8082

Danach kann man alles beenden und löschen:

docker-compose down                        # es bleiben nur die Volumes!
rm -Rf /var/dc-test-db /var/dc-test-www    # Volumes müssen manuell gelöscht werden

Netzwerke für docker-compose.yml

services:
  web:
    ...
    networks:
      - mynet

# auf Top-Level die Netzwerke definieren
networks:
  mynet:
    external:
      name: host

Bei der letzten Konfiguration ist das Docker-eigene Host-Netzwerk gemeint (siehe docker network ls).

Netzwerkports

ports:
  - "8080:80"
  - "8443:443"

Auf die Hierarchie-Ebene für Definitionen achten.

Volumes

# Docker docker-compose.yml in Ordner testing
version: '3.7'
services:
  nginx:
    volumes:
      - webdata:/var/www/html
    ...
volumes:
  webdata:

Docker erstellt selbst ein Volume: /var/lib/docker/volumes/testing_webdata/_data

Mit einem weiteren docker-compose Beispiel (Joomla-Installation) können wir die Nutzung von Docker Volumes sehen:

Beispiel mit CMS Joomla und Volume webdata:

docker-compose.yml (Joomla-Installation) mit Volume
# Datei: joomla/docker-compose.yml
version: '3.1'
services:
  joomla:
    image: joomla:apache-php7
    ports:
      - 8080:80
    volumes:
      - webdata:/var/www/html
    environment:
      JOOMLA_DB_HOST: mariadb
      JOOMLA_DB_NAME: dockerbuch
      JOOMLA_DB_USER: dockerbuch
      JOOMLA_DB_PASSWORD: johroo2zaeQu
  mariadb:
    image: mariadb:10
    environment:
      MYSQL_ROOT_PASSWORD: eengi7suXeut
      MYSQL_DATABASE: dockerbuch
      MYSQL_USER: dockerbuch
      MYSQL_PASSWORD: johroo2zaeQu
volumes:
  webdata:

Testen der Persistierten Speicherung von Webdaten und Diskussion die Volumes in eigene Datenstrukturen zu binden.

docker-compose <commands>

  • config (Analyse)

  • up | down (up normalerweise kombiniert mit -d)

  • events

  • kill (falls stop|down nicht funzt)

  • logs

  • pause | unpause

  • ps

6.4. Volumes

Volumes lassen sich unter Docker als Mounts technisch nutzen und können unterschiedlich erstellt/gebunden sein.

  • Bind Mounts (z.B. durch -v /var/dc-test-www:/var/www/html)

  • Docker Volumes (mit docker volume create .. manuell erzeugen oder s.o. als Direktiven in docker-compose.yml oder Dockerfile)

Nur echte Volumes lassen sich mit docker volume ls auflisten.

Die Volumes lassen sich genauer mit docker volume inspect ... analysieren.

6.5. Mini-Swarm

An dieser Stelle nur zum reinschnuppern

Mit docker stack deploy einen Cluster mit nur einem Docker-Mitglied nutzen.

Hinweis

Übungen mit docker-compose (s.o.) inkl. Volumes vorher aufräumen/löschen!

Docker-Schwarm initieren: docker swarm init

docker swarm init                                      # Docker Swarm initieren
cd test                                                # hier ist das docker-compose.yml
mkdir /var/dc-test-www                                 # Volume Wordpress HTML
mkdir /var/dc-test-db                                  # Volume MariaDB Databases
docker stack deploy -c docker-compose.yml stacktest    # und los geht es...

docker stack rm stacktest                              # alles (bis auf Volumes) löschen!

Das Beispiel zeigt ganz schön die zusätzliche Abstraktionsebene beim Testen der Docker-Technik.

Testen der WordPress-Installation im Browser (URL): 172.20.0.2:8082

Also: die Portumsetzung quasi eine Netzwerk-Ebene weiter (siehe GW-Netzwerk)! Die richtige IP (hier im Beispiel: 172.20.0.2) analysieren Sie über docker network Analyse (oder einfach mit ip a s auf Docker Host: siehe GW-Bridge).

Der Docker läuft weiterhin im Swarm-Modus!

Beenden mit: docker swarm leave --force

Für Docker Swarm dann auch weitere Deploy-Einstellungen (später mehr bei Swarm):

  • deploy.mode

  • deploy.placement.constraint ; Regeln: node.id, node.hostname, node.role

Wenn später mehrere Node (Docker Host Swarm Mitglieder) gejoint werden (docker swarm join ...) müssen weitere Vorbereitungen und Konfigurationen beachtet werden: insbesondere die Nutzung von Zeitservice NTP, damit die Nodes genau gleich „ticken“.

7. Basis-Images

Für die meisten Docker-Umsetzungen werden erst einmal vorbereitete Images genutzt.

7.1. Übersicht

Alle bisher benutzten Images in allen Beispielen basieren auf Grund-Images.

Diese Basis-Images werden per Docker Registry in Form von Repositories bereitgehalten. Später wollen wir uns von der Docker Registry trennen und werden unsere eigenen Registrys betreiben wollen.

Die Suche nach vertrauensvollen Basis Images: Docker Registry

Offizielle Docker Basis-Images

Offizielle Docker Basis-Images

Mit der Registrierung auf dem Docker-Hub haben Sie Einblick in die automatisierten Sicherheitsüberprüfungen für die verschiedenen Images in einem Repository (Reiter Tags).

Docker Account - Tags

Docker Account - Tags - Sicherheitslücken

Oder natürlich mit der Docker CLI: Docker CLI Search

Beispielaufrufe:

docker search ubuntu                                # Images ubuntu suchen
docker search --filter "is-official=true" ubuntu    # offizielle Images Ubuntu
docker search --filter stars=10 debian              # min. 10 Sterne

Die offiziellen Images haben einen einfachen Namen: also alpine und nicht testcom/alpine!

Hier ein paar der offiziellen Images (Anzahl gesamt: 16; Stand: Jan 2019)

  • Scratch

    für das Imagen „FROM scratch“

  • Alpine

    Ein Imaga-Build from scratch mit kleinem Linux-rootfs-TAR - der aktuelle Docker Builds Liebling!

    Werden wir noch häufiger nutzen und bedarf einer weiteren Vertiefung, da es andere Administrationsmechanismen (z.B. Paketverwaltung) nutzt, als die Standard-Linux-OS.

  • CentOS

    Image des RED HAT Community OS

  • Debian

    Image Debian

  • Fedora

    Image des RED HAT Fedora OS

  • Ubuntu

    Image von Canonicals Ubuntu

  • Busybox

    The Swiss Army Knife of Embedded Linux

  • Bash

    … nur die Bash

  • Amazon Linux

    Amazon Linux is provided by Amazon Web Services (AWS)

Beachten: der Unterstrich in den Links für die offiziellen Images.

Hier mal eine kleine Übersicht über die gängigen Image-Größen:

Distribution

Docker Image Größe

Alpine Linux

ca. 4 MByte

CentOS 7

ca. 210 MByte

Debian 9 (Stretch)

ca. 100 MByte

Ubuntu 16.04 LTS

ca. 110 MByte

Ubuntu 18.04 LTS

ca. 80 MByte

7.2. Tags

Über Repositories in der Docker Registry können unterschiedliche Images bereitgestellt werden, die man über ihre Tags genauer bestimmt.

Beispielhaft Übersicht (online - Images Centos): https://hub.docker.com/_/centos?tab=tags

Anm.: auf dieser Übersicht sehen angemeldet Docker Hub User auch immer die Sicherheitsanalysieren zu den Images!

Das lässt sich auch in der Kommandozeile zaubern: (Anm.: Tool jq genutzt für lesbare Darstellung)

curl -sL https://index.docker.io/v1/repositories/library/centos/tags | jq '.[].name'

"latest"
"5"
"5.11"
"6"
"6.10"
"6.6"
"6.7"
"6.8"
"6.9"
"7"
"7.0.1406"
"7.1.1503"
"7.2.1511"
"7.3.1611"
"7.4.1708"
"7.5.1804"
"7.6.1810"
...

Für eigene Images gerne ein eigenes Präfix für die Images nutzen: joebrandes/alpine:15.0

7.3. Eigenes Basisimage

(s.a. Vertrauenswürdige Images)

Wichtig: jedes lokale erstellte Image kann immer nur über eine Registry genutzt werden!

Tarball

Wir erstellen/installieren ein Template-System (hier: openSUSE) und erstellen hieraus einen Tarball.

tar --numeric-owner --exclude=/proc --exclude=/sys --exclude=/.snapshots -cvf opensuse.tar /

Dieses lässt sich dann auf dem Docker-Host wieder Importieren.

docker import opensuse.tar joebrandes/opensuse:42.3

Image-Erzeugung per Skript

Beispiel: YUM-Based mit Skript online

Oder über Moby-Project:

wget https://raw.githubusercontent.com/moby/moby/master/contrib/mkimage-yum.sh
bash mkimage-yum.sh joebrandes/centos

Debian / Ubuntu

Diese Systeme gehen mit einem eigenen Tool zum Extrahieren eines Tarball aus einem System an den Start: debootstrap

Das Tool kann über das gleichnamige Paket installiert werden.

debootstrap --variant=minbase stretch ./rootfs

tar -C ./rootfs -c . | docker import - joebrandes/debian:9

Anm.: nach Test ca. 165 MB groß!

7.4. Alpine Linux

Für das Linux zeichnet die Firma Gliderlabs verantwortlich.

Quellen:

Technisches:

  • als C-Standardbibliothek wird musl statt glibc genutzt

    das stellt häufig ein Problem bei zu kompilierenden Programmen dar

    einfachere Auswertung von /etc/resolv.conf (keine domain und search Beachtung)

    es existiert für Alpine Linux optimierte glibc (pkg-glibc )

  • als Init-System wird OpenRC statt systemd oder sysv-init genutzt

    erinnert eher als klassisches init-System und arbeitet mit /etc/inittab

    Wichtig: OpenRC ist installiert! Arbeitet aber nicht! S.a. Logging (rsyslog nachinst.)

  • Linux Kommandos stammen von BusyBox

Alpine Linux lässt sich schnell ausprobieren: docker run -it -h alpine --name alpine alpine

docker run alpine
Unable to find image 'alpine:latest' locally
latest: Pulling from library/alpine
cd784148e348: Pull complete
Digest: sha256:46e71df1e5191ab8b8034c5189e325258ec44ea739bba1e5645cff83c9048ff1
Status: Downloaded newer image for alpine:latest
/ # cat /etc/os-release
NAME="Alpine Linux"
ID=alpine
VERSION_ID=3.8.2
PRETTY_NAME="Alpine Linux v3.8"
HOME_URL="http://alpinelinux.org"
BUG_REPORT_URL="http://bugs.alpinelinux.org"
/ #

Container-Analyse (in separater Shell natürlich): docker ps -s (Größen anzeigen)

zeigt einen nur wenige Bytes großen Container, was normal ist für frisch erstellte Container.

7.4.1. Shell

Die Shell ist standarmäßig /bin/sh (Teil von BusyBox)

Die Bash lässt sich nachinstallieren, was den Komfort erhöht, aber auch die Speichergrößen anschwellen lässt.

apk add --update bash bash-completion

7.4.2. BusyBox

Enthält ca. 140 Linux Standardkommandos, die als Symlinks zu busybox integriert sind.

Siehe: ls /bin /sbin -l

Hilfe zu BusyBox: https://busybox.net/downloads/BusyBox.html

7.4.3. Hilfen / Dokumentation

Es gibt keine man-Pages oder den Pager less!

Nachinstallation möglich mit:

apk add --update man man-pages mdocml-apropos less less-doc
export PAGER=less
apk add --update bash-doc

Die man-Pages der Tools habe immer die -doc Paketendung!

Hilfe zu diesen Topics: Alpine Doku

7.4.4. Paketverwaltung apk

Das Verwalten von Paketen (Software) mit apk unter Alpine Linux:

Kommando

Funktion

apk add <paketname>

installiert Pakete

apk del <paketname>

entfernt Paket

apk info (<paketname>)

listet installierte Pakete auf (auch mit -L und --who-owns)

apk search <paketname>

sucht Paket in Paketquellen

apk stats

zeigt Anzahl Pakete

apk update

zeigt, welche Pakete aktualisierbar sind

apk upgrade

aktualisiert Pakete

Paket in Roh-Alpine: apk info | sort

apk info
/ # apk update
fetch http://dl-cdn.alpinelinux.org/alpine/v3.8/main/x86_64/APKINDEX.tar.gz
fetch http://dl-cdn.alpinelinux.org/alpine/v3.8/community/x86_64/APKINDEX.tar.gz
v3.8.2-19-g151c2021d6 [http://dl-cdn.alpinelinux.org/alpine/v3.8/main]
v3.8.2-18-gd7f33f856a [http://dl-cdn.alpinelinux.org/alpine/v3.8/community]
OK: 9546 distinct packages available
/ # apk info | sort
alpine-baselayout
alpine-keys
apk-tools
busybox
libc-utils
libressl2.7-libcrypto
libressl2.7-libssl
libressl2.7-libtls
musl
musl-utils
scanelf
ssl_client
zlib
/ #

Empfehlung: ein apk update vor irgendwelchen Installationen / Konfigurationen! Es gibt gut 9500 Pakete!

Tipp

In Dockerfile ein apk add --no-cache zum installieren nutzen: es wird ein –update durchgeführt, aber nach dem Install wird das System wieder bereinigt!

apk add –no-cache nutzen
# Datei Dockerfile
...
RUN apk add --no-cache \
    build-base \
    python-dev \
    jpeg-dev \
    zlib-dev \
    ffmpeg \
    && pip install sigal \
    && pip install cssmin \
    && apk del build-base python-dev jpeg-dev zlib-dev

Paketübersicht online: https://pkgs.alpinelinux.org/packages

Hier waren jetzt auch die Paketquellen erkennbar; Anzeige mit: cat /etc/apk/repositories

8. Docker Registry

Wir wollen unsere eigene Docker Registry betreiben. Hierfür stehen verschiedene technischen Umsetzungen zur Verfügung.

Die Registry steht in den Versionen V1 und V2 zur Verfügung. Vor den Bereitstellungen sollte man die entsprechenden Versionen recherchieren (siehe CentOS / RHEL mit V1).

Techniken Registry:

  • V1 - in Python implementiert

  • V2 - in Golang

Desweiteren starten wir erst einmal mit einer Insecure Registry - also ohne verschlüsselte Transporte.

übersicht über die Bereitstellungen für Docker Registry:

  • Registry Software auf Github https://github.com/docker/distribution

    Anm.: wird hier nicht genutzt.

  • Registry als Docker Image vom Docker Hub https://hub.docker.com/_/registry

    Anm.: mit Debian nutzen.

  • Software in Linux-Distributionen - und wieder: bitte die Version der Registry vorher klären

    Anm.: mit openSUSE nutzen.

  • Docker Hub Account

    Anm.: hat auch Vorteile beim Einschätzen von Docker Hub Images

Erinnerung: die Docker Technik hält Konfiguration vor, wo sie standardmäßig die Registry erwartet:

docker system info | grep -i registry
Registry: https://index.docker.io/v1/

Das lassen wir auch erst einmal so. Auch um die verschlüsselte Kommunikation mit unseren Registries oder die Nutzung von Registry-Mirrors werden wir uns (ggf.) später kümmern.

8.1. Registry Image

Die Umsetzung möglichst auf Debian-System. Anm.: eigenes Docker-Registry-Tool dann mit Suse-System.

Ein offizielles Registry-Image lässt sich auf dem Docker Hub finden und mit docker-compose nachhaltig implementieren.

Für eine Ansprache der eigenen Docker Registry nutzen wir z.B. hub.example.org oder andere FQDNs nach Wahl.

Diese Adresse müssen wir natürlich auflösen lassen - am einfachsten über die /etc/hosts.

Tipp

Bei der Nutzung Hyper-V Default Switch erhält man FQDNs und Namensauflösungen: hostname.mshome.net.

Aber: keine echtes DNS und Routing!

Jetzt benötigen wir nur noch ein Docker Compose Verzeichnis für die docker-compose.yml und schon kann es losgehen.

Docker Compose Ordner anlegen mkdir ~/docker/registry && cd $_ und in Ordner wechseln.

docker-compose.yml (Registry)
registry:
  image: registry:2
  container_name: registry
  restart: always
  ports:
    - 5000:5000
  volumes:
    - /srv/docker/registry:/var/lib/registry

Und los geht es: docker-compose up -d

Damit jetzt auch der unsichere Zugriff auf die Registry möglich ist, muss Docker über /etc/docker/daemon.json entsprechend konfiguriert werden:

{
    [ggf. Vorherige Einträge - diese Zeile weglassen;-)],
    "insecure-registries": [ "hub.example.org:5000" ]
}

Testen der eigenen Registry:

docker pull ubuntu:16.04
docker tag ubuntu:16.04 hub.example.org:5000/ubuntu:16.04
# und jetzt pushen:
docker push hub.example.org:5000/ubuntu:16.04
# löschen der Images:
docker image rm ubuntu:16.04
docker image rm hub.example.org:5000/ubuntu:16.04
# und jetzt das Image aus eigener Registry holen:
docker pull hub.example.org:5000/ubuntu:16.04

Die genutzte Registry (quasi der Weg für das Image) erschließt sich also aus dem Image-Namen!

Hinweis

Ändern Sie den Namen der Registry muss man Anpassungen an Dockerfiles und docker-compose.yml-Dateien vornehmen!

Analyse des Registry-Containers:

docker exec registry ps aux
docker exec registry cat /etc/docker/registry/config.yml

Mit dieser config.yml kann die Registry Konfiguration dann auch angepasst/überschrieben werden.

Links zur Docker Registry:

8.2. Registry Distro-Package

Die Umsetzung erfolgt auf einem openSUSE-System mit dem Paket docker-distribution-registry.

Es muss mit systemctl entsprechend gecheckt (systemctl status registry) und gestartet (systemctl start registry) werden.

Auch hier muss wieder eine Konfiguration für insecure-registries nach obigem Beispiel für die Standard-Registry vorgenommen werden.

über /etc/docker/daemon.json also enntsprechend konfiguriert:

{
    [ggf. Vorherige Einträge - diese Zeile weglassen;-)],
    "insecure-registries": [ "opensuse.mshome.net:5000" ]
}

Repositories einer Registry anzeigen lassen:

curl http://opensuse.mshome.net:5000/v2/_catalog

Hinweis

Tests erst einmal nur mit den jeweils lokalen Maschinen, sonst benötigt man ja vollständiges DNS und Routing!

Das Löschen von Images in privaten Registries ist extrem unhandlich und umständlich (Literatr: Liebel, Kap. 6.4.4, S. 418ff).

8.3. Docker Hub

Empfehlung: eigenen Account auf https://hub.docker.com/signup erzeugen für Repositories.

Docker Befehle: docker login | logout

Authentifizierung hinterlegt (!) in /etc/docker/key.json

Docker Hub

Docker Hub - Webportal

9. Literatur

Die folgenden Docker Bücher liefern die Schwerpunkte zu unserer Seminarpraxis und den Übungen.

Hinweis

Texte und Anmerkungen zu den Büchern von Amazon bzw. Verlagen

Und natürlich liefert auch die Linksammlung viele Quellen für weitere Beschäftigungen.

9.1. Docker - Praxisbuch

Autoren: Bernd Öggl und Michael Kofler

Docker: Das Praxisbuch für Entwickler und DevOps-Teams.

Docker: Das Praxisbuch für Entwickler und DevOps-Teams.
Gebundene Ausgabe: 431 Seiten
Verlag: Rheinwerk Computing; Auflage: 1 (24. August 2018)
Sprache: Deutsch
ISBN-10: 3836261766
ISBN-13: 978-3836261760
Größe und/oder Gewicht: 17,2 x 3 x 24,6 cm

Software-Container verstehen und produktiv einsetzen

Docker ist aus der modernen Softwareentwicklung nicht mehr wegzudenken. Ob Sie Entwickler oder Administrator sind, ob Sie gerade einsteigen oder bereits produktiv mit Software-Containern arbeiten: Dieses Buch zeigt Ihnen Docker und die Containerwelt.

Dabei lässt es Sie auch bei Troubleshooting und Orchestrierung nicht alleine. Inkl. Best Practices, umfangreichem Werkzeugkasten und vielen Tipps zu Projektmigration, Container-Sicherheit, Kubernetes und mehr.

Docker: Das Praxisbuch für Entwickler und DevOps-Teams.

Docker: Das Praxisbuch für Entwickler und DevOps-Teams.

Aus dem Inhalt:

  • Konzepte und Kommandos

  • Eigene Docker-Images

  • Container-Sicherheit

  • Webserver und Tools

  • Datenbanksysteme

  • Programmiersprachen

  • Webapplikationen und CMS

  • Praxisbeispiel: Webapplikation, Grafana, Gitlab und mehr

  • Anwendungen migrieren

  • Deployment

  • Continuous Integration und Continuous Delivery

  • Orchestrierung mit Swarm und Kubernetes

  • Docker in der Cloud: AWS, Azure, Google Cloud

Rückseite - Docker: Das Praxisbuch für Entwickler und DevOps-Teams.

Rückseite - Docker: Das Praxisbuch für Entwickler und DevOps-Teams.

9.2. Skalierbare Container

Oliver Liebel

Skalierbare Container-Infrastrukturen für Ihr Unternehmen

Skalierbare Container-Infrastrukturen: Das Handbuch für Administratoren und DevOps-Teams.
Inkl. Container-Orchestrierung mit Docker, Rocket, Kubernetes, Rancher & Co.

Gebundene Ausgabe: 1071 Seiten
Verlag: Rheinwerk Computing; Auflage: 1 (28. April 2017)
Sprache: Deutsch
ISBN-10: 3836243660
ISBN-13: 978-3836243667
Größe und/oder Gewicht: 18,4 x 6,9 x 25,6 cm

Die nächste Evolutionsstufe der Virtualisierung ist ein Pflichtthema für jedes Unternehmen, dem sich DevOps-Teams und Administratoren stellen müssen: Hochskalierbare und ausfallsichere Microservice-Umgebungen.

Mit diesem Handbuch verstehen Sie die Konzepte hinter den Technologien und können Container-Infrastrukturen auf Basis von Docker in Verbindung mit Swarm Mode, Kubernetes, Rancher, Mesos und DC/OS planen, aufbauen und orchestrieren. So stellen Sie Software schneller bereit und vereinfachen das Deployment und die Wartung Ihrer Infrastruktur – damit Ihre IT-Landschaft auch zukünftig den Anforderungen an Skalierbarkeit und Planungssicherheit gewachsen ist!

Skalierbare Container-Infrastrukturen für Ihr Unternehmen

Skalierbare Container-Infrastrukturen für Ihr Unternehmen

Aus dem Inhalt:

  • Warum Container? DevOps vs. Infrastruktur-Admin. Microservices und Skalierbarkeit

  • Continuous Integration / Continuous Delivery

  • DevOps vs. Infrastruktur-Admin, Microservices und Skalierbarkeit

  • Container Basics: Namespaces, Portierbarkeit, Sicherheit

  • Docker Container: Build, Ship and Run… everywhere? Applikationen im Container, Best Build Practices

  • Fortgeschrittene Verwaltung von Docker Containern: Layer, Storage Backends, Volumes und mehr

  • Trusted Registry, TLS, LDAP-Anbindung

  • Atomic, CoreOS/Container Linux und Rocket

  • World of Tiers – Orchestrierungs-Angelegenheiten

  • Geclusterte Key/Value Stores, Service Registry und Discovery: consul, etcd, zookepper

  • Schwarmintelligenz? Container-Cluster mit Swarm Mode, Docker Data Center

  • Planung, Installation, Administration eines Kubernetes-Clusters

  • Rancher

  • Mesos und DC/OS

  • Ausfallsichere und skalierbare Software Defined Storage-Backends für Container-Cluster: Ceph und Gluster

  • Wohin führt der Weg

Rückseite - Skalierbare Container-Infrastrukturen für Ihr Unternehmen

Rückseite - Skalierbare Container-Infrastrukturen für Ihr Unternehmen

Aktuelle Auflage:

Verlag: Rheinwerk Computing; Auflage: 2 (26. Oktober 2018)
Sprache: Deutsch
ISBN-10: 3836263858
ISBN-13: 978-3836263856

9.3. Linux-Server

Linux-Server: Das umfassende Handbuch. Inkl. Samba, Kerberos, Datenbanken, KVM und Docker, Ansible u.v.m. (Ausgabe 2019)

Mit eigenen Kapiteln zu Virtualisierung (Kap. 20) und Docker Containern (Kap. 21).

Auflage: 5 (23. November 2018)

Linux-Server: Das umfassende Handbuch. Inkl. Samba, Kerberos, Datenbanken, KVM und Docker, Ansible u.v.m. (Ausgabe 2019)

Gebundene Ausgabe: 1270 Seiten
Verlag: Rheinwerk Computing; Auflage: 5 (23. November 2018)
Sprache: Deutsch
ISBN-10: 3836260921
ISBN-13: 978-3836260923
Größe und/oder Gewicht: 22,2 x 7,3 x 24,6 cm

Wie Sie Linux-Server effizient nach den aktuellen Standards administrieren, vermittelt Ihnen dieses Buch. Von Hochverfügbarkeit über Sicherheit bis hin zu Scripting und Virtualisierung: Sie lernen Linux-Server distributionsunabhängig intensiv kennen.

Das Buch bietet Ihnen über benötigtes Hintergrundwissen hinaus zahlreiche Praxisbeispiele zu den häufigsten in Unternehmen eingesetzten Distributionen. Und dank Shell-Programmierung, Python, Ansible sowie den im Buch vorgestellten Tools und Automatisierungsskripten lassen Sie Ihre Rechner für sich arbeiten!

Linux-Server (2018/2019)

Linux-Server (2018/2019)

Aus dem Inhalt:

  • Administrationsgrundlagen

  • Devices und Paketmanagement

  • Dateisysteme und Berechtigungen

  • Scripting und Shell-Coding

  • Dienste

  • Web-, Mail-, Proxy-, FTP- und Druckserver

  • Samba, LDAP, Kerberos, NFSv4

  • Infrastruktur und Netze

  • Hochverfügbarkeit

  • Virtualisierung (KVM, Docker)

  • Routing, Bonding, Firewalls

  • DHCP, DNS, OpenSSH

  • Versionskontrolle (VCS)

  • Sicherheit, Monitoring & Co.

  • Backup und Recovery

  • Verschlüsselung

  • Automatisierung

  • Ansible

  • PKI mit OCSP

Rückseite - Linux-Server (2018/2019)

Rückseite - Linux-Server (2018/2019)

9.4. Hyper-V

Microsoft Hyper-V: Das Handbuch für Administratoren. Aktuell zu Windows Server 2016

Microsoft Hyper-V: Das Handbuch für Administratoren. Aktuell zu Windows Server 2016

Gebundene Ausgabe: 948 Seiten
Verlag: Rheinwerk Computing; Auflage: 3 (29. Mai 2017)
Sprache: Deutsch
ISBN-10: 383624327X
ISBN-13: 978-3836243278
Größe und/oder Gewicht: 18,4 x 6 x 24,9 cm

Wenn Sie mit Hyper-V unter Windows Server 2016 Server oder Desktops virtualisieren und Ihre Infrastruktur noch effizienter verwalten und auslasten möchten, liegen Sie mit diesem Buch goldrichtig.

Nicholas Dille, Marc Grote, Jan Kappen und Nils Kaczenski sind gefragte und in der Community bestens bekannte Hyper-V-Experten. Gemeinsam bieten Ihnen die Autoren neben allen wichtigen Grundlagen und fortgeschrittenen Virtualisierungstechniken vor allem eines: umfangreiches Praxiswissen.

Microsoft Hyper-V

Microsoft Hyper-V

Aus dem Inhalt:

  • Grundlagen Hyper-V

  • Host-Server

  • Storage

  • Netzwerk

  • VMs und Applikationen

  • Container

  • Verfügbarkeit

  • Betrieb, Backup und Recovery

Rückseite - Microsoft Hyper-V

Rückseite - Microsoft Hyper-V

10. Linksammlung

Die folgende Linksammlung natürlich ohne Anspruch auf Vollständigkeit ;-) und mit dem Versuch einer Gliederung.

Tipp

Erst nach dem Seminar stöbern!

Und los geht es…

10.4. Cheat Sheets

Cheat Sheets - https://scriptcrunch.com/docker-useful-hacks/

Cheat Sheets - scriptcrunch.com/docker-useful-hacks/