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

docker search ubuntu

Lokale Registry auf notebook31 benutzen:

/etc/default/docker :

DOCKER_OPTS="--insecure-registry notebook31:5000"

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

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

Docker Ansicht:

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

Linux Ansicht:

docker ps
docker stop
docker ps -a
docker rm

Installierte Files anzeigen

dpkg -L docker-ce | less

Prozesse in Baumstruktur anzeigen

 ps --forest
 ps auxf

docker Command:

  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

  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

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

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

docker run -ti --name restarttest --restart on-failure:2 ubuntu    # Bei Fehlern wird der Container 2x neu gestartet

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

docker rm $(docker ps --filter status=exited -q)   # löscht nicht mehr gestartete Container

docker commit 2865a23d7458       # WICHTIG: Volumes sind nicht Bestandteil des Commit
docker image ls
docker tag b47f3389c55c jbuntu:1.0
docker image ls

In Dockerfiles können Informationen für das Erstellen eines Images hinterlegt werden.

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

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

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"]

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

docker build -t gruppe1
docker run -P gruppe1

Mit 'docker history' kann man sich anzeigen lassen, was in einem Image „passiert“ ist.

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

Zeigt Unterschiede des laufenden Containers zum Image

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

Docker-compose automatisiert Abläufe innerhalb von docker, wie z.B. das Anlegen von Netzwerken, Images, Containers usw.

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

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

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
~                     

Mit 'docker-compose up' im entsprechenden Verzeichnis, wird das File 'docker-compose.yaml' verarbeitet.

docker-compose up
docker-compose up -d # Daemon
docker-compose logs
docker-compose logs -f
docker-compose build # bauen ohne zu starten

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

# 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

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

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)

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

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

Die Container httpd und redis können nun über das JBNET1 direkt kommunizieren.

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

„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.

docker service create --name registry --publish 5000:5000 registry:2

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

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

• git clone http://github.com/dockersamples/docker-swarm-visualizer

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

export REGISTRY=127.0.0.1:5000
export TAG=v1
docker stack deploy dockercoins --compose-file dockercoins.yml

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

• 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)

• 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