Tag 02

Dienstag, 28.01.2020, 08.30 - 16.00 Uhr

Ausführliche Rekapitulation und ein paar "O-Töne Liebel", Teilnehmer-Fragen

Installation: Tilix - die bessere Konsole mit Mehrfenstermanagement in CentOS 7 installieren
yum install yum-plugin-copr  
yum copr enable ivoarch/Tilix  
yum install tilix

Die Tilix-Konsole lässt sich dann wieder per ssh (inkl. X-Server) nutzen: tilix & 
Interessanter Fenster-Modus: -quarks  (Anm.: falls die Graphikunterstützung in Windows schlecht ist)

Nachträge und Übugen zu JSON...

JSON - (siehe: docker inspect )

Bei der Analyse von Images und Containern hilft das docker [...] inspect Kommando.

Die Ausgabe entstehen in Form von JSON Dateien (Link Wikipdia)

Bitte denken Sie beim Bearbeiten von JSON-Dateien an Folgendes:

• Kommas und Hochkommas
• kein Komma mehr hinter dem letzten Listen- oder Dictionary-Element
• Saubere eckige, geschweifte Klammern

Empfehlung für saubere Ausgabe, Formatierungen und Filterungen: jq   (noch nachinstallieren)

Das kann man auch für die verbesserte Ausgabe von manuellen HTTP-RESTful-Api Docker-Test mit "Webbrowser curl" nutzen:
curl -s --unix-socket /var/run/docker.sock http://localhost/images/json | jq    

Anm./Erinnerung: die Nutzung eines Unix-Sockets stellt sicherheitstechnisch einen Nachteil dar.

JSON und jq Ausgaben

Hinweis: bei CentOS mittels der EPEL-Repos Zugriff auf jq Paket.
Standardausgaben von docker inspect ... (JSON-Format) aufarbeiten und filtern mit jq.

Beispiel: (Kurzerläuterung: JSON als Array interpretieren)

Image Inspektion - nur Abschnitt ContainerConfig - Image ausgeben:

docker image inspect hello-world:latest | jq [.[0].ContainerConfig.Image]

Links zu Tool jq:

• https://stedolan.github.io/jq/manual/
• https://wiki.ubuntuusers.de/jq/

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"
]
# weitere Beispiele
docker inspect -s -f "{{.State.Status}}" mariadb-test5
docker inspect -s -f "{{.State.FinishedAt}}" mariadb-test5

Oder aber wir optimieren die Ausgabetabelle eines Docker-Befehls:
Formatierte / tabellarische Ausgaben mit Schalter --format:

docker ps -a --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Labels}}"

Besondere Erwähnung neben dem Format table sollte hier das Format json erfahren, was uns wieder zum Tool jq bringt (s.o.)!

Registry - Repository, Image:Tag

Klärung der wichtigen technischen Zusammenhänge:

Registry

Die Standard-Registry der Docker-Umgebung analysiert man mit: docker info | grep -i registry 
Das ist normalerweise der Docker-Hub : https://index.docker.io/v1/    (Registry in Version 1 - es gibt aktuell auch schon V2)

Später wollen wir ggf. auch Private Registry betreiben (z.B. vm-opensuse-10:5000)

Online kann man den Docker Hub über das Webportal analysieren: hub.docker.com 
Empfehlung: später mal einen Account anlegen für eigene Ablagemöglichkeiten auf Docker Hub und Sicht auf technische Analysen von Images (Sicherheitschecks)!

In der Konsole:

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   

Die Images werden per docker pull aus der Registry geholt, indem man den Namen des gewünschten Repository bzw. Image angibt.

Repository, Image:Tag

Zusammenfassung aller Versionen (Tags) zu einem Image.

Offizielle Docker Images erkennt man am einfachen Namen (ohne /): ubuntu
Wird nur der Name genannt pullt Docker das Image ubuntu:latest 

Inoffizielle Repositories haben einen Schrägstrich im Bezeichner: phpmyadmin/phpmyadmin 
Der erste Teil ist die Docker ID auf dem Docker Hub (der Standard-Registry) und danach kommt der Image-Name.
Bei den Offiziellen Docker Images ist der formale komplette Name (z.B.): library/ubuntu

Images und Container

Übungen und Techniken: wie kommen wir über Images an nutzbare Container?!

Auszug aus Trainer-Cheat-Sheet (für Teilnehmer als LibreOffice Draw und als Download auf diesem Portal)

Der Container in "einem Schritt": docker run -it --name ubu1 ubuntu:18.04 

Achtung: jedes weitere docker run ... erzeugt immer wieder neue Container!

Die Schritte im Einzelnen:

• docker pull ubuntu:18.10  
  Image ubuntu:18.10 aus Registry holen
• docker create -i -t --name ubu2 ubuntu:18.10 
  erstellt Container ubu2 aus Image ubuntu:18.10 mit interaktiv- und tty-Schaltern!
• docker start -a -i ubu2 
  startet Docker Container ubu2 attached und interaktiv

Das "Attachen" an Container kann man auch nutzen, wenn man einen Container mal einfach ohne die Schalter gestartet (start, run) hat.

• docker attach ubu2 
  Zugriff auf Container-Terminal von ubu2

Und für die "äußerliche" Nutzung von Containern hilft immer

• docker exec ubu2 cat /etc/os-release 
  Befehl in Container ubu2 ausführen

Achtung: bei den meisten Containern ist ja die Bash (oder Sh) der "Urprozess". Das heißt, das man mit dem Befehl exit natürlich auch den Container stoppt!

Stattdessen kann man das Terminal auch mittels Strg+P, Strg+Q terminieren - also ohne den Container zu stoppen.

Beispiel: Offizielles Image 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)

Wir starten einen Container für das offizielle Image mariadb:latest im detached-Mode (quasi: Hintergrund):

docker run -d --name mariadb-test1 -e MYSQL_ROOT_PASSWORD=geheim mariadb
# Stoppen des Containers:
docker stop mariadb-test1
# Containerinfos auslesen:
docker inspect maria-db-test1

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

Die Datenbank (wenn der DB-Container läuft) gerne mit MySQL/MariaDB-Client checken:

docker exec -it mariadb-test1 mysql -u root -p
# Den Container analysieren:
docker exec -it mariadb-test1 /bin/bash
cat /etc/os-release
ps ax
mysqld --version
exit

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

docker logs mariadb-test1.

Jetzt noch ein Container - hier mit Portumleitungen:

docker run -d --name mariadb-test3 \
     -p 13306:3306 mariadb

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

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


Anm.: bei Tests mit MySQL-Client-Zugriffen war es hier wichtig bei Angabe des Hosts die IP (127.0.0.1) zu nutzen und nicht den Reservierten Namen localhost.
Die Belegung von Ports ist immer zu hinterfragen, zu checken und bestenfalls zu kommentieren!

Was uns hier noch fehlt, sind Datenspeicher für die Datenbank außerhalb des Containers (Stichwort: Volumes) und eigene Netzwerke für das Verbinden mit weiteren Containern.

Für die Erstellung neuer Images dient (siehe) Kurzübersicht docker commit ... als Umsetzung. Das ist aber häufig keine saubere und gute Lösung für neue Images, da bei dieser Herstellung meist zu viele Schichten (Layers) und zu hohe Image-Größen entstehen.

Erkenntnis: Wir benötigen einen sauberen Build-Prozess mit docker build ... und Dockerfile Direktiven (Dateien).

Dockerfile (Einführung)

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

Hinweis: mit docker-compose werden später mehrere Container kombiniert in einem Arbeitsschritt eingerichtet!

Die meisten Images wären 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 die nötigen Anweisungen enthält!

Kurzanleitung

• Ordner für Image-Bauprozess 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
  und dann mit docker run oder docker create und dann docker start  nutzen
• 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 (ggf. $)
• Eigenes (privates) Docker Repository

Links:

• Automatic Builds
• Docker Registry

In einer Fortsetzung zu docker-Builds (Dockerfile) jetzt mehr zu den Anweisungen und technischen Umsetzungen...

Dockerfile - die Datei

Das Dockerfile hat eine eigene Syntax...

Schlüsselworte für ein Dockerfile (Directives) als Tabelle:

Erläuterungen:

• Reference Dockerfile 
• Best Practises Dockerfile 

Kurze Analyse / Erläuterungen:

ADD vs. 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 vs. 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

Jetzt wollen wir uns mal ein paar Beispiele erstellen und Images erzeugen (Image Building)

Dockerfile - Beispiele

Die folgenden einfachen Beispiele lassen sich beliebig im "Netz" oder auch auf den Docker-Portalen finden.

Die folgenden Verweise zeigen an, dass die Beispiele dem aktuellen Buch "Docker - Das Praxisbuch für Entwickler und DevOps-Teams von Bernd Öggl, Michael Kofler" aus dem Rheinwerk-Verlag entstammen. Die beiden Autoren haben ebenfalls seit Ende Januar 2020 eine neue Auflage dieses Fachbuchs herausgebracht!

Alle Beispiele wurden ausführlich mit den gelernten Docker-Techniken "containerisiert" und getestet.

Beispiel 01

Einfaches Images mit PHP 7 und Apache2 Webserver basierend auf Basisimage mit dieser Kombination:

FROM php:7-apache
ENV TZ="Europe/Amsterdam"
COPY index.php /var/www/html

Man erkennt die Festlegung einer Umgebungsvariablen und das Kopieren einer Datei in den Container.

Image erstellen mit (z.B.): docker build -t joebseminar/myphpapache:1.0 . 

Zu beachten ist hier der Punkt am Ende für den Basisordner (hier: dieser Ordner) des Build-Prozesses mit dem Dockerfile und der index.php .

Beispiel 02

Mit Basisimage Ubuntu (Tag: 18.04) ein Image mit Editor-Installation joe und Aufräumen  der Apt-Technik. Hier stellen wir auch eine Shell (hier: Bash) bereit, mit der wir später "-i / --interactive" und "-t / --tty" über ein Terminal kommunizieren können.

FROM ubuntu:18.04
LABEL maintainer "Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!;
RUN apt-get update && \
 apt-get install -y joe && \
 apt-get clean && \
 rm -rf /var/lib/apt/lists/*
CMD ["/bin/bash"]

Zu beachten ist hier, dass durch das "einzeilige" RUN-Command die Image-Größe und die Layer-Erzeugung (hier: 1 Layer für RUN) optimiert wird.

Beispiel 03

Wieder wird das Basisimage ubuntu:18.04 genutzt: Webserver Apache2 mit http/https-Unterstützung und einer kleinen (von mir vorbereiteten) Beispiel-Website.

FROM ubuntu:18.04
LABEL maintainer "Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!;
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 -r /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"]

Nach dem Building mit bekanntem Aufruf
docker build -t joebseminar/mywebserver:1.0 .  

muss das Image nur geschickt für die äußere Netzanbindung über Ports gemappt werden:
docker run --hostname webserver --name mywebserver \
  -p 8080:80 -p 8443:443 \
  joebseminar/mywebserver:1.0  

Jetzt kann man die Beispielseite über einen Browser erreichen.

• Image whalesay
• docker mit Tilix
• Image mariadb
• mysql-Client Testing
• docker build
• https Port Forwarding

Tag 03

Mittwoch, 29.01.2020, 08.30 - 16.00 Uhr

Rekapitulation zu Docker Builds mit Dockerfile-Dateien, Teilnehmer-Fragen

Hinweis auf meine Online-/Offline HandOuts für die Teilnehmer: RestructuredText-Dokumente für SphinxDoc Dokumenterstellungen (HTML, EPUB, PDF, ...)

Übungen (Forts.) zu Dockerfile

Weitere Beispiele für die Umsetzungen Image-Build-Prozess und Inbetriebnahmen über docker run ... und/oder docker start ...  

Alpine Linux

Für das Linux zeichnet die Firma Gliderlabs verantwortlich.

Quellen:

• Gliderlabs
• Wikipedia
• Alpine Linux
• Alpine Docker Image
• Alpine Packages Online

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

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 Alpine-Container, basierend auf einem wenige Megabytes (!) großem Alpine-Image.

Shell

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

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

apk add --update bash bash-completion

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

Hilfen / Dokumentation

Es gibt keine man-Pages oder den Pager less! Nachinstallationen wären aber 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: siehe Alpine Doku 

Paketverwaltung apk

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

Pakete in Roh-Alpine: apk info | sort 

/ # 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!

# 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 

Alpine Linux mit Apache2 Webserver

Hier sind wir durch Recherchen zu Alpine Linux und diversen Dockerfile Analysen herausgefordert worden:
Anm.: Apache muss als Prozess am Laufen gehalten werden im Container - sonst ist der Container ja gleich wieder beendet!

FROM alpine

LABEL maintainer "Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!"
LABEL description "Test Alpine und Apache"

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

# dieses run-Verzeichnis musste mal erstellt werden!
# RUN mkdir /run/apache2

ENV APACHE_RUN_USER=apache \
    APACHE_RUN_GROUP=www-data 

EXPOSE 80

COPY samplesite/ /var/www/localhost/htdocs

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

Anm.: die benutzte Beispielseite (HTML-Projekt in Ordner samplesite) als einfaches HTML5-Gerüst mit einfachem Prüftext.
Vorschlag: alternatives Dockerfile mit apk add --no-cache  Direktive bzw. komplette Umsetzung inklusive https/ssl.
Anm.: letztere Varianten gibt natürlich schon vorbereitet auf dem Docker Hub.

Übung: Drei Container mit Netz und Mounts

Wir komplettieren die Container-Techniken und verdrahten unsere Container mit

• Netzwerken - docker network create ...
• Mounts - Ordnerbindungen zwischen Container und (lokalem) Dockerhost

Wir erstellen uns ein neues Docker Netzwerk:
docker network create test-net   (Anm.: wenn nicht angegeben --driver bridge  )

Übersicht über die Docker Netzwerke:
docker network ls  

Inspektion (Eigenschaften) unseres neuen Netzwerks:
docker network inspect test-net | jq   (Hier: Subnet 172.18.0.0 / 16 )

Im Seminar zeige ich gerne über mehrere Erstellungsphasen die nötigen Bauteile für das gewünschte Szenario:

• Datenbank-Server (Image: mariadb)
• WordPress (Image: wordpress)
• PhpMyAdmin (Image: phpmyadmin/phpmyadm)

Und schon kann es mit der Produktion der Container losgehen...

Container: MariaDB4WP

docker run -p --name MariaDB4WP \
    --network test-net \
    -e MYSQL_ROOT_PASSWORD=geheim \
    -v /home/joeb/dockerdata/wpmysql:/var/lib/mysql \
    mariadb

Container: WP01

docker run -p --name WP01 \
    --network test-net -p 8081:80 \
    -e WORDPRESS_DB_PASSWORD=geheim \
    -e WORDPRESS_DB_HOST=MariaDB4WP \
    -v /home/joeb/dockerdata/wphtml:/var/www/html \
    wordpress

Container: PMA01

docker run -p --name PMA01 \
    --network test-net -p 8080:80 \
    -e PMA_HOST=MariaDB4WP \
    phpmyadmin/phpmyadmin

Und die Tests - wie immer - mittels Browser im Docker-Host.

Als Nächstes werden wir dann die Container versuchen in einem Arbeitsschritt zu starten / zu komponieren.

• Hilfe docker run
• Alpine Linux
• CMD / ENTRYPOINT
• WordPress Dockerfile
• Drei Container Ein Netz
• PhpMyAdmin

Tag 04

Donnerstag, 30.01.2020, 08.30 - 16.00 Uhr

Rekapitulation, Teilnehmer-Fragen

docker-compose

Jetzt wollen wir die Bereitstellungen von weiter Containern verbessern. Mit docker run ... geht das zwar relativ einfach, aber wir wollen die Anweisungen für mehrere Container zentral organisieren.

Die docker-compose Technik betreibt die Container hierbei in ihrer nativen (puristischen) Weise: die Container werden beim Beenden entfernt!
Getreu dem Docker Motto: "Container sind zum Wegschmeißen!"

Konfigurationsformat: YAML

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

Infoseiten zu YAML:

• Wikipedia
• YAML Webportal

Für die Konformität der *.yml-Dateien (oder *.yaml) 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:

# 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

Anm.: ein Python-Script - Entwicklerlink zu shyaml

openSUSE: sudo pip install shyaml   
Anm.: z.B. bei CentOS muss erst Paket python-pip installiert werden!

Beispielaufrufe: shyaml get-value data.key1 < sample.yaml  oder alternativ
cat docker-compose.yml | shyaml get-value services.joomla.image  (s.u.: ergibt: joomla)
cat docker-compose.yml | shyaml get-value services.joomla.ports  (s.u. ergibt: -8083:80)

Technik

Technischer Hintergrund: (Anm.: bei Docker Desktop für Windows ist docker-compose bereits verfügbar)

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! In 2019/2020 hat Docker verkündet zukünftig die eigene Swarm-Technik mit Kubernetes (K8s) zu ersetzen.

Anmerkungen:

• Das docker-compose Python-Skript kann Problemchen bereiten (Python!)
• Wir beschränken uns - an dieser Stelle - auf docker-compose und behalten uns die Swarm-/K8s-/Orchestrierungs-Techniken für später auf.

Online / Links:

• Webportal zu docker-compose: Docker Compose 
• Releases / Downloads GitHub: docker-compose Releases
• Installationen / Bereitstellungen: Docker Portal: docker compose install  

Einfacher Download bzw. Installation: (alternative Bereitstellungen - siehe Webportal - sollten analysiert werden; Versionen beachten)

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

docker-compose <commands>

• config (Analyse)
• up -d | down (up normalerweise kombiniert mit -d)
• events
• kill (falls stop|down nicht funzt)
• logs (Logging zeigen)
• pause | unpause
• ps (listet die Container auf)
• images (listet die Images auf)

Beispiele: 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!

Beispiel 01: Wordpress-Installation:

# Datei test/docker-compose.yml
version: '3.7'

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

  wordpress:
    image: wordpress:latest
    volumes:
      - /var/dc-wp-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. Nicht einmal Netzwerkkonfigurationen werden benötigt! Und in dieser Konfiguration wird (sehr einfach und unsicher) der Zugriff auf die Wordpress-DB mit dem MySQL-/MariaDB-root verdrahtet. Wir wollen später eigene DB-Accounts für die Web-/CMS-Projekte nutzen.

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  # Schalter -d bietet wieder detached mode - sonst habe ich Logging Konsole

Test hier einfach wieder mit Browser (URL): localhost:8082 und man schaut sich mal Docker Netzwerke und alle möglichen Container, Netzwerke (und später Volumes) an.
Hinweis: ohne Schalter -d sieht man - wie auch sonst bei Docker - das Logging der Dienste in der Konsole!

Danach kann man alles wieder 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

Übung: weiteren Container einbauen!
Einbau von PhpMyAdmin in die Technik wie in den manuellen Vorübungen mit einzelnen Docker-Run Aufrufen für die einzelnen Container.

Beispiel 02: CMS Joomla!

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

# 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: dockerbuchuser
      JOOMLA_DB_USER: dockerbuch
      JOOMLA_DB_PASSWORD: joomlageheim
  mariadb:
    image: mariadb:10
    volumes:
      - mysqldata:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: geheim
      MYSQL_DATABASE: dockerbuch
      MYSQL_USER: dockerbuchuser
      MYSQL_PASSWORD: joomlageheim
volumes:
  webdata:
  mysqldata:

Hier wurde also die (für die Persistenz von Projekten) nötigen Docker Volumes mit den Namen webdata: und mysqldata: deklariert und (oben) genutzt!
Tipp/Hinweis: quasi wie Laufwerke - denke an C:

Außerdem gibt es einen exklusiven Account für die Joomla-DB, die im MariaDB-Container genutzt wird.

Übung: Wenn man das CMS Joomla - mit den hier vorgegeben Werten - durchinstalliert, darf man bei der Info zum DB-Server einfach den Hostname "mariadb" nutzen, obwohl man schnell herausfinden kann, dass der Container eigentlichen einen der kryptischen Hostnames hat (z.B. "6ad8549bb310"). Wie funktioniert das? Tipp: Inspektion!

Recherchen auf dem Docker Hub zeigen:
statt angebotenen docker-compose.yml Dateien sieht man stattdessen die stack.yml Dateien. Dieses kompatible (eigentlich identische) Format gehört zu der Docker Swarm Technik (Container Orchestrierung mit Docker Technik; aktuell in Ablösung befindlich - auch bei Fa. Docker - durch Kubernetes/K8s). 
Tipp: für die Nutzung als "stack.yml" die Version (z.B.) auf '3' stellen.

Wir wollen uns also jetzt mal die Techniken ansehen, mit denen Docker uns Datenträgermangements außerhalb der Container für persistente Daten anbietet..

Volumes

Volumes lassen sich unter Docker als Mounts oder Volumes 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
  • als Direktiven volumes: in docker-compose.yml oder Dockerfile automatisch erzeugen

Nur echte Volumes lassen sich mit docker volume ls auflisten - nicht die Mounts!

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

Wenn man mit docker-compose Container gearbeitet hat und dann beim docker-compose down noch den Schalter -v anhängt werden automatisch alle Volumes der docker-compose.yml gelöscht.

Übung: Container Prinzip mit neuem Debian 10 Docker Host

Wir haben eine vorbereitete VM (hier: Debian 10 Buster) einfach in VirtualBox-Umgebung entpackt und in Betrieb genommen.

Installations-Hinweise:
Installation des Pakets "docker.io" (hier: Docker 18.09) statt einem "veralteten" Paket "docker".:
apt install docker.io 
Bereitstellung von docker-compose gemäß Anleitungen (s. Docker Portal: docker compose install)

Recherchen und Installationen mit: apt search ... / apt show ... / apt install ...
Für ssh (ggf.) gleich den openSSH-Server nachinstallieren: apt install openssh-server 

Für die Inbetriebnahme unserer heute getesteten und entwickelten docker-compose-Container-Umgebungen müssen wir nur einen docker-compose-Ordner in den neuen Docker-Host kopieren und die komplette Technik mit einem einfachen docker-compose up -d  in Betrieb nehmen - fertig!

In der nächsten Stufe für die Container - der Orchestrierung von vielen und mehrfachen Containern auf mehreren Docker Hosts - kann diese Technik dann ebenfalls prinzipiell genau so einfach etabliert werden - ich find's Super ;-)

• Hilfe docker-compose
• docker-compose up -d
• docker-compose.yml
• 3 Container per compose
• stack.yml
• Docker Volume

Tag 05

Freitag, 31.01.2020, 08.30 - 16.00 Uhr

Rekapitulation, Teilnehmer-Fragen

Topics / To-Do:

• Linux-Alternativen:
  siehe Vorinstallationen Debian, CentOS 7 (ohne Gui), openSUSE Leap, ...
• Nach all der Konsolentechnik: der Portainer
  ein wenig Oberflächenluxus für die Verwaltung mit portainer
• Docker Desktop für Windows
  jetzt werden wir den Hyper-V benötigen
• Eigene Basis Images
  Wir sollten uns auch Gedanken machen, um Basis-Images selbst zu erstellen, damit wir wirklich die volle Kontrolle über das Grundtechniken für unsere Container haben.
• Registries
  Docker Hub Account / Private Docker Registry
• Einblick in Orchestrierungen
  • Docker Swarm (auch wenn mittlerweile abgekündigt!)
  • MiniKube,
  • Kubernetes (K8s), Kubic (Suse), ...
  • siehe KodeKloud Video (gegen Ende ab ca. 1:54:44)
• ... gibt so vieles auszubprobieren und zu Entdecken ;-)

Und los geht es ...

Portainer

Auf portainer.io - oder natürlich über den Docker Hub - kann man eine Container-Oberflächentechnik finden, die sich einfach und schnell als Container nutzen lässt.

docker volume create portainer_data  
docker run -d -p 8000:8000 -p 9000:9000 \ 
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \  
    portainer/portainer    

Die Administrations-Oberfläche lässt sich dann auf dem Dockerhost über Port 9000 erreichen.

Hier sind die Standard-Konnektionen sichtbar für die Admininstrationspartner: von Docker/Local bis zur Azure Cloud.

Wir haben uns ein wenig umgeschaut...

Docker Desktop for Windows

Installation: Spezielles Installationsarchiv für eine Windows-Umgebung mit Hyper-V-"Rolle".
Anm.: Für den Download ist ein Docker Account nötig

WICHTIG bei Parallelinstallation mit anderen Virtualisierern (siehe hier Oracle VirtualBox in unserer Seminarwoche):
wenn Windows mit aktiviertem Hyper-V läuft können diese anderen Virtualisierer nicht mehr funktionieren, da das Windows auf dem sie laufen quasi selber eine virtuelle Instanz darstellt (Stichwort: Hyper-V ist Hypervisor Typ 1).

Lösung bei Parallelinstallationen: wenn nicht Hyper-V - sondern die anderen Virtualisierer genutzt werden sollen dann mit "administrativer" Konsole (cmd):
bcdedit /set hypervisorlaunchtype Off   (stellt Hyper-V aus - benötigt Neustart)
bcdedit /v  (zeigt die Konfiguration)
bcdedit /set hypervisorlaunchtype Auto  (stellt Hyper-V wieder an - benötigt Neustart)

Installiert werden verschiedenste ISOs (docker-for-win.iso, config.iso, docker.iso) und ein eigenes Hyper-V-Netzwerk DockerNat. 
Virtuelle Docker-Linux-VM: klassisch MobyLinuxVM - aktuell als DockerDesktopVM in der der Hyper-V VM-Verwaltung sichtbar.

Die Docker-Installation wird über ein "Managment-Symbol" in der Systemleiste/Taskleiste verwaltbar.
Vorteil: wir haben gleich einige andere Docker-Tools (siehe docker-compose, Kubernetes, ...) mit an Bord!

Die Konfiguration der Docker-Umgebung kann angepasst werden (z.B. Anzahl CPU Kerne).

Die Docker Aufrufe sollte man mittels PowerShell durchführen. Ein Aufruf von docker version zeigt dann die genaue Ausgangssituation nach einer Standardinstallation:

Client: Docker Engine - Community
 Version: 18.09.1
 API version: 1.39
 Go version: go1.10.6
 Git commit: 4c52b90
 Built: Wed Jan 9 19:34:26 2019
 OS/Arch: windows/amd64
 Experimental: false

Server: Docker Engine - Community
 Engine:
 Version: 18.09.1
 API version: 1.39 (minimum version 1.12)
 Go version: go1.10.6
 Git commit: 4c52b90
 Built: Wed Jan 9 19:41:49 2019
 OS/Arch: linux/amd64
 Experimental: false

Wir nutzen hier eine Docker Linux Engine (Host bzw. Server - also Linux Container) und einen Docker Windows Client! Wir können den Docker Desktop auch auf die Nutzung von Windows Containern umschalten und umgekehrt (Anm.: ggf. benötigen wir einen Neustart).

Back to Linux/Container-Business... ;-)

Docker Registry

Wir wollen unsere eigene Docker Registry betreiben. Hierfür stehen verschiedene technische 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 (Go)

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 beliebiger Distro nutzen.
• Software in Linux-Distributionen - und wieder: bitte die Version der Registry vorher klären
  Anm.: z.B. mit openSUSE nutzen.

Registry Image

Ein offizielles Registry-Image lässt sich auf dem Docker Hub finden (https://hub.docker.com/_/registry) und mit docker-compose nachhaltig implementieren.

Für eine bessere Ansprache der eigenen Docker Registry kann man z.B. hub.example.org oder andere FQDNs nach Wahl konfigurieren (DNS bzw. /etc/hosts).
Diese Adresse müssen wir natürlich auflösen lassen - am einfachsten über die /etc/hosts.
Hinweis: Bei der Nutzung Hyper-V Default Switch erhält man FQDNs und Namensauflösungen: hostname.mshome.net.
Aber: keine echtes DNS und Routing!

Empfehlung: für einfache erste Gehversuche kann man die Registry einfach mittels localhost:5000 ansprechen, was dann auch gleich die Voreinträge zu "insecure-registries" (siehe docker info) nutzt. Siehe auch die Ausführungen und ersten Anleitungen auf dem Docker Hub zur Registry.

Imagenutzung 1 - Manuell mit docker

Schnelllösung per docker run ... :
docker run -d -p 5000:5000 --restart always --name registry registry:2    

Imagenutzung 2 - mit docker-compose

Wir benötigen nur 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.

Datei docker-compose.yml:

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 sein:
Anm.: siehe Ergebnis von docker info 

{
   [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!

Analyse des Registry-Containers:

docker exec registry ps aux
docker exec registry cat /etc/docker/registry/config.yml
curl -X GET http: // localhost:5000/v2/_catalog | jq
curl -X GET http: // localhost:5000/v2/hallo-welt-image/tags/list

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

Links zur Docker Registry:

• https://github.com/docker/distribution/blob/master/docs/configuration.md
• https://docs.docker.com/registry/configuration/

Registry Distro-Package

Die Umsetzung erfolgt (z.B.) 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 (Literatur: Liebel, Auflage 1, Kap. 6.4.4, S. 418ff).

Docker Hub Account

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

Erinnerung: die Docker Technik hält eine 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.

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)

Eigenes Basisimage

... s.a. Stichwort: Vertrauenswürdige Images

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

Tarball

Wir erstellen/installieren ein Template-System (hier: openSUSE) und erstellen daraus 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 (Docker Entwickler): YUM-Based mit Skript online
oder über das Moby-Project: wget https://raw.githubusercontent.com/moby/moby/master/contrib/mkimage-yum.sh

Aufruf: 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ß!

Und jetzt wollen wir noch (kurz) über Orchestrierungen sprechen!
Übersicht: (ohne Anspruch auf Vollständigkeit)

• Docker Swarm - Stacks und Services von Docker
• Kubernetes (K8s) - der "Steuermann" von Google
• Mesos - von Apache Foundation

And the winner is ... K8s
Wir schauen uns aber zum Seminarende nur mal kurz das "Original" an ...

Docker (Mini) Swarm

An dieser Stelle nur zum reinschnuppern: ein 1-Node-Swarm!

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                                 # Dir Wordpress HTML erstellen
mkdir /var/dc-test-db                                  # Dir MariaDB Databases erstellen
docker stack deploy -c docker-compose.yml stacktest    # und los geht es...

docker stack rm stacktest                # alles (bis auf Volumes, Dirs) 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 (bwz. 172. ...)

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

Achtung: 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".

(Digitale) Unterlagen für TN

Hand-Outs Trainer J. Brandes - Ausarbeitungen Online / Offline zu Docker:
Anm.: erstellt per RestructuredText

• Portal: docker.pcsystembetreuer.de
• HTML-Versionen (HTML & SingleHTML)
• PDF oder EPUB
• Aktualisierung / Überarbeitung geplant für 05.02.2020
  Nachtrag: mein Schreibtisch war zu "voll"!
  Überarbeitung - auch wegen Seminarauslastung - erst ab KW 8 (17.02.2020)

Allgemeine Unterlagen

• Screenshots Seminarwoche ("Diashow" zum Seminar)
  Screenshots nach Seminaren Link (siehe Screenshots Tag 05)
• Diverse PDF / Workshops
• Sicherungen / Backups der TN-VMs

Letzte TN-Fragen, Feedback-Bögen, TN-Bescheinigungen

• Services in Seconds
• portainer.io
• Docker Desktop für Windows
• CentOS Image per Skript
• Private Registry
• Orchestrierungen (Video: KodeKloud)

Literatur

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.

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

Aktuelle 2. Auflage:

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

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!

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

Auch hier gibt es bereits eine 2. Auflage von Januar 2020!

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.

Linux-Server

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

mit einem eigenen Kapitel "Docker Container"

Auflage: 5 (23. November 2018)

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!

Links

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… 

Docker

• Docker Portal
• Docker Documents - Infoportal
• Docker Enterprise Edition (Docker EE vs. CE)
• Docker Community Edition (CE) - Release Notes
• Docker für Windows - Release Notes
• Docker Hub
• Docker Hub - Offizielle Basis Images
• Intro to Docker - A Slideshow
• Docker - What is a Container
• Docker Engine Referenz CLI

Docker Registry

• https://github.com/docker/distribution/blob/master/docs/configuration.md
• https://docs.docker.com/registry/configuration/

Best Practises & HowTos

• ueberdosis.io - Tipps für schlanke Docker-Images
• Jonny Langefeld - How to Docker
• Simplilearn Slideshare
• Wie funktionieren Docker Container
• Edureka - Deep Dive in Docker

Tools

• Portainer

Ausgabeformatierungen

• Go Programming Templates
• jq Tutorial
• jq Manual (s.a. man jq)
• jq Ubuntuusers

Diverses

• www.opencontainers.org

Cheat Sheets

• Docker
• Github md
• Rebellabs
• Painless Docker GitHub
• Painless Docker Website
• Scriptcrunch

Security

• Docker Security
• Introduction to User Namespaces in Docker Engine

seccomp

• seccomp
• seccomp Profile
• seccomp default Profile syscalls blocks

exit-Codes

• Technik chroot: Exit Codes with special Meaning
• Docker run Exit Status: Docker reference run

Videos

• Youtube - KodeCloud - Docker for Beginners: Full Course
• Youtube Docker Recherche
• Youtube Docker Kanal
• Youtube - Docker Basics (Live Stream)
• Youtube Recherche: Difference Virtualization and Container
• Youtube Heise - Docker Praxis mit Linux
• Youtube Edureka
• Youtube Simplilearn