====== Docker ======

====== Installation ======

Paketmanagement vorbereiten:

  apt-get install apt-transport-https ca-certificates curl software-properties-common
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -

Docker Repository hinzufügen:

  add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Docker CE installieren:

  apt-get update
  apt-get install docker-ce




====== Erster Zugriff auf die docker-hub Registry ======

  docker search ubuntu


====== Zugriff auf lokale Registry ======
Lokale Registry auf notebook31 benutzen:

''/etc/default/docker'' :
<file>
DOCKER_OPTS="--insecure-registry notebook31:5000"
</file>

  docker search notebook31:5000/ubuntu
  docker images
  docker pull notebook31:5000/ubuntu

====== erste Container starten ======
extra Fenster öffnen mit:
  docker events

Container mit shell:
  docker run -i -t --rm ubuntu bash

Pipe von einem Container zum Nächsten:
  docker run --rm ubuntu ls| docker run --rm -i ubuntu tr [:lower:] [:upper:]

Wordpress Container starten:
  docker run -d -P --name wordpress tutum/wordpress
  docker ps
  docker port wordpress
  docker stop wordpress
  docker ps
  docker ps -a

Alle Container löschen:
  docker ps -aq | xargs docker rm

====== Innen- und Außenansicht ======

Docker Ansicht:
  docker run -ti ubuntu:latest bash
  ip a s
  ps ax

Linux Ansicht:
  docker ps
  docker stop
  docker ps -a
  docker rm


====== Zusätzliche Commands ======
Installierte Files anzeigen
  dpkg -L docker-ce | less
  
Prozesse in Baumstruktur anzeigen  
   ps --forest
   ps auxf
  
docker Command:
<code bash>
  docker run ubuntu # docker Container "Ubuntu" starten (wird ggfls. runtergeladen)
  docker info  # Allgemeine Informationen zum Docker System
  docker ps    # Laufende Container anzeigen
  docker ps -a # Alle Container - auch nicht laufende anzeigen 
  docker run -it ubuntu # Startet den Container und öffnet ein interaktives (-i) Terminal (-t)
  docker run -it ubuntu /bin/bash
  docker run -it ubuntu hostname
  docker attach <id|container-name>  # mit laufendem Container verbinden (<id> muss nur soweit eingegeben werden, bis sie eindeutig ist)
  docker exec -it elated_tesla /bin/bash # im laufenden Container "elated_tesla" etwas (/bin/bash) ausführen.
  docker run -d ubuntu /bin/sh -c 'while true; do date; sleep 1;done' # -d = daemon
  docker logs [-f] <id|name> # Ausgabe des Containers anzeigen [-f = follow]
  docker ps -l # letzter Container
  docker ps -q # zeigt die ID an
  docker top <id|name> # Top zum Container
  docker inspect <id|name> # Zeigt Informationen zum Container
</code>

===== Erweiterte Funktionen =====
<code bash>
  docker run -P httpd        # startet den Container mit Default-Portweiterleitung
  docker run -p 80:80 httpd  # -p gibt externen/internen Port an
  
  docker container ls        # = docker ps
</code>  

=== Netzwerk ===
<code>
  docker network create <netzwerkname>     # Netzwerk erstellen
  docker run --net <netzwerkname> ..
  docker run --net <netzwerkname> --network-alias <alias> # -> alias wird im docker-internen DNS vergeben.
</code>

=== Volumes ===
<code bash>
docker run -d -p 80:80 -v /home/nutzer15/webserver:/usr/local/apache2/htdocs httpd
docker volume create webserver
docker run -d -p 80:80 -v webserver:/usr/local/apache2/htdocs httpd
docker run -d -p 80:80 -v webserver:/usr/local/apache2/htdocs --read-only httpd     # READ-ONLY
</code>

=== Restart ===
<code bash>
docker run -ti --name restarttest --restart on-failure:2 ubuntu    # Bei Fehlern wird der Container 2x neu gestartet
</code>

=== Export ===
<code bash>
docker export -o my-export.tar <id|name>     # Exportiert den angegebenen Container in das angegebene tar
</code>

===Systempflege ===
<code bash>
docker rm $(docker ps --filter status=exited -q)   # löscht nicht mehr gestartete Container
</code>

====Images====
<code bash>
docker commit 2865a23d7458       # WICHTIG: Volumes sind nicht Bestandteil des Commit
docker image ls
docker tag b47f3389c55c jbuntu:1.0
docker image ls

</code>

====Dockerfile===
In Dockerfiles können Informationen für das Erstellen eines Images hinterlegt werden.
<code bash Gruppe1>
FROM centos:latest

RUN yum -y install httpd

VOLUME ["/var/www"]

RUN echo "hello world" > /var/www/html/index1.html
RUN echo "hello world" > /tmp/index1.html

ADD docker-logo.png /var/www/html/

EXPOSE 80

CMD /usr/sbin/httpd -D FOREGROUND
</code>

<code bash Gruppe2>

FROM centos:latest

RUN yum -y install httpd

CMD /usr/sbin/httpd -D FOREGROUND

ENV JAVA_HOME=/opt/java

RUN sed -i 's/Listen 80/ Listen 8080/' /etc/httpd/conf/httpd.conf

RUN groupadd apache2
RUN useradd -g apache2 -s /bin/bash apache2

RUN chown apache2:apache2 /etc/httpd/logs
RUN chown apache2:apache2 /run/httpd

WORKDIR /home/apache2/webapps

USER apache2:apache2

RUN touch /home/apache2/docker-test.txt
RUN echo $JAVA_HOME > /home/apache2/docker-test.txt
</code>

<code bash Gruppe3>

https://docs.docker.com/engine/reference/builder

ARG USER=defaultuser
FROM centos:latest
ENV USER=${USER}
RUN yum -y install httpd
ENTRYPOINT ["/usr/bin/htpasswd", "-c", "/htpasswd"]
CMD ["USER"]
</code>

<code bash Gruppe4>

1.
FROM centos:latest
ONBUILD RUN echo Hallo > /var/www/html/index.html
ONBUILD RUN rm /etc/httpd/conf.d/welcome.conf
RUN yum -y install httpd
CMD /usr/sbin/httpd -D FOREGROUND

2.
FROM gruppe4:latest
HEALTHCHECK --interval=10s --timeout=3s --resries=1 CMD curl -f http://localhost/ || exit 1
LABEL version="0.1"
LABEL description="Dies ist ein Test LABEL"
LABEL vendor="Linuxhotel"
STOPSIGNAL 9
CMD /usr/sbin/httpd -D FOREGROUND
</code>

<code bash>
docker build -t gruppe1
docker run -P gruppe1
</code>

===== docker history =====
Mit 'docker history' kann man sich anzeigen lassen, was in einem Image "passiert" ist.
<code bash>
docker history jasonrivers/nagios:latest
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
8dcbe7de7b64        7 days ago          /bin/sh -c #(nop)  CMD ["/usr/local/bin/st...   0B                  
<missing>           7 days ago          /bin/sh -c #(nop)  VOLUME [/opt/nagios/var...   0B                  
<missing>           7 days ago          /bin/sh -c #(nop)  EXPOSE 80/tcp                0B                  
<missing>           7 days ago          /bin/sh -c echo "ServerName ${NAGIOS_FQDN}...   125B                
<missing>           7 days ago          /bin/sh -c #(nop)  ENV APACHE_LOG_DIR=/var...   0B                  
<missing>           7 days ago          /bin/sh -c #(nop)  ENV APACHE_LOCK_DIR=/va...   0B                  
<missing>           7 days ago          /bin/sh -c ln -s /etc/sv/* /etc/service         58B                 
<missing>           7 days ago          /bin/sh -c rm /opt/nagiosgraph/etc/fix-nag...   0B                  
...
</code>

===== docker diff =====
Zeigt Unterschiede des laufenden Containers zum Image
<code bash>
docker diff 09bb184ebe39
C /etc/mailname
C /etc/postfix
C /etc/postfix/main.cf
C /etc/sv/apache
A /etc/sv/apache/supervise
A /etc/sv/apache/supervise/control
...

</code>
===== docker-compose =====
Docker-compose automatisiert Abläufe innerhalb von docker, wie z.B. das Anlegen von Netzwerken, Images, Containers usw.
<code bash>
curl -L https://github.com/docker/compose/releases/download/1.17.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
chmod 755 /usr/local/bin/docker-compose
</code>

Setzt ein File 'docker-compose.yaml' voraus.

<code yaml docker-compose.yaml>
version: "2"

services:
  www:
    build: www
    ports:
      - 8000:5000
    user: nobody
    environment:
      DEBUG: 1
    command: python counter.py
    volumes:
      - ./www:/src

  redis:
    image: redis
~                     
</code>

Mit 'docker-compose up' im entsprechenden Verzeichnis, wird das File 'docker-compose.yaml' verarbeitet.
<code bash>
docker-compose up
docker-compose up -d # Daemon
docker-compose logs
docker-compose logs -f
docker-compose build # bauen ohne zu starten
</code>
===== portainer =====
Web-Oberfläche zur Verwaltung von docker. (Vorsicht: benötigt Zugriff auf docker.sock und hat damit alle Rechte im Docker)
  * https://portainer.io
  * https://portainer.io/install.html

<code bash>
# im swarm
docker service create --name portainer --publish 9000:9000 --replicas=1 --constraint 'node.role == manager' --mount type=bind,src=//var/run/docker.sock,dst=/var/run/docker.sock portainer/portainer -H unix:///var/run/docker.sock
</code>

===== docker-machine =====
Nutzt virtualbox um mehrere virtuelle Docker-Systeme anzulegen. Diese können dann z.B. als docker swarm genutzt werden.

<code bash>
curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/usr/local/bin/docker-machine
chmod +x /usr/local/bin/docker-machine

apt-get install virtualbox

docker-machine create node1
docker-machine create node2
docker-machine create node3

docker-machine env node1         # Umgebungsvariablen der VM

eval $(docker-machine env node1) # Umgebungsvariablen in der Shell setzen
docker info                      # liefert nun docker infos der VM
docker-machine ssh node1         # ssh zum docker-machine node1 (Auth über ssh-key)
</code>


===== docker swarm =====
<code bash>
docker swarm init --advertise-addr 192.168.99.100   # docker swarm erstellen - IP ist die externe IP
docker node ls
# Node hinzufügen
docker swarm join --token SWMTKN-1-1996mwovs1uv1n2yay0r80g4uvfl59dujv14rymxdbx5jy0gd8-54373om4g69ttk8e6pt2vjsuh 192.168.99.100:2377

# JOIN-Token neu anzeigen lassen
docker swarm join-token worker
docker swarm join-token manager

docker node promote node2
docker node denote node2

docker service create ...    # wie docker run - nur im Swarm
</code>

==== Netzwerk im Swarm anlegen ====

<code bash>
docker network create JBNET1 --driver overlay --attachable   # reicht auf einem Node (z.B. node1)
docker run -d --net JBNET1 --name httpd httpd                # auf node1
docker run -d --net JBNET1 --name redis redis                # auf node2
</code>
Die Container httpd und redis können nun über das JBNET1 direkt kommunizieren.

==== Commands im Swarm  ====
<code bash>
docker service create --name registry --publish 5000:5000 registry:2
docker service ls
docker service ps <servicename>
# z.B.:
docker service ps registry
docker service ps portainer

# Service skalieren
docker service create --name ping alpine ping 8.8.8.8
watch -n 1 docker service ps ping
docker service update ping --replicas 6

# Globaler Service - läuft auf jedem Node genau 1x
docker service create --name pingglobal --mode global alpine ping 8.8.8.8
</code>


====== docker registry ======
"Kleine Lösung" zur Weitergabe von Images innerhalb eines Swarm. 127.0.0.1 ist default-mäßig als "insecure"-Quelle zugelassen.
Ergebnis lässt sich im Browser unter http://192.168.99.100:5000/v2/_catalog anzeigen.
<code bash>
docker service create --name registry --publish 5000:5000 registry:2
</code>

<code bash>
docker pull centos
docker image ls 
docker tag centos 127.0.0.1:5000/centos     # Name wird geändert. Anfang des Namen wird automatisch als Ziel
docker push 127.0.0.1:5000/centos           #    genutzt. Fehlt das Ziel, wird docker-hub angenommen
# nächster Node
docker pull 127.0.0.1:5000/centos
docker image ls
</code>

== Übung ==
<code bash>
REGISTRY=127.0.0.1:5000
TAG=v1
for s in hasher rng webui worker; do docker tag dockercoins_$s $REGISTRY/dockercoins_$s:$TAG; done
for s in hasher rng webui worker; do docker push $REGISTRY/dockercoins_$s:$TAG; done
</code>

  * git clone http://github.com/dockersamples/docker-swarm-visualizer
====== docker stack ======

<code yaml dockercoins.yml>
version: "3"

services:
  rng:
    build: dockercoins/rng
    image: ${REGISTRY-127.0.0.1:5000}/rng:${TAG-latest}
    deploy:
      mode: global

  hasher:
    build: dockercoins/hasher
    image: ${REGISTRY-127.0.0.1:5000}/hasher:${TAG-latest}

  webui:
    build: dockercoins/webui
    image: ${REGISTRY-127.0.0.1:5000}/webui:${TAG-latest}
    ports:
    - "8000:80"

  redis:
    image: redis

  worker:
    build: dockercoins/worker
    image: ${REGISTRY-127.0.0.1:5000}/worker:${TAG-latest}
    deploy:
      replicas: 10

</code>

== Übung ==
<code bash>
export REGISTRY=127.0.0.1:5000
export TAG=v1
docker stack deploy dockercoins --compose-file dockercoins.yml
</code>
====== Minicub ======
<code bash>
curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 && chmod +x minikube && sudo mv minikube /usr/local/bin/

curl -Lo kubectl https://storage.googleapis.com/kubernetes-release/release/$(curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt)/bin/linux/amd64/kubectl && chmod +x kubectl && sudo mv kubectl /usr/local/bin/

minikube start
</code>

====== Notizen ======
===== Grundsätzlich =====
  * Ein Prozess pro Container
    * Übergabe der Informationen über Volumes
      * z.B. Filebeat (sidecar)
      * aber auch nagios.cmd / Livestatus rw-file

  * Nagios in x Containern
    * nagios-core
      * plugins über Image zur Verfügung stellen
      * max-worker sehr klein setzen
    * mk-livestatus
    * nagflux
    * (ohne Apache?)

  * Aufsetzen der Umgebung 
    * git clone
    * docker-compose
   
  * Configurations über Umgebungsvariablen (Container unabhängig von den Daten)
  * Config-Änderungen ohne Image-Anpassungen
  * Keine Datenhaltung im Container
  * .dockerignore-Datei nutzen
  * Layerzahl minimieren (apt-get update && apt-get install .... && ... )
  * tags benutzen (Namen und Versionen, latest pflegen)
  * Container ggfls. unter Benutzernamen laufen lassen (z.B. nagios)

====== Links ======
  * https://blog.programster.org/docker-swarm-cheatsheet
  * https://docs.docker.com/network/proxy/  - Docker in einer Umgebung mit Proxy
  * https://docs.docker.com/config/daemon/systemd/  - Docker und systemd