Ein Container ist ein Image, welches gerade ausgeführt wird. Wenn ein Image mit docker run nginx ausgeführt wird, spricht man von einem Container. Es ist vergleichbar mit einem Prozess. Container wird auf Basis eines Ausgangs-Images gestartet.

Docker Volumes

There are three volume types:

Docker volumes which are stored and handled internally by docker (c.f. docker config to choose where they are actually stored).

version: '3.9'
services:
  caddy:
  	image: caddy:2.6.2
    volumes:
      - caddy_data:/data
volumes:
  caddy_data

Bind mounts which are direct access to the host file system from a container

version: '3.9'
services:
  caddy:
  	image: caddy:2.6.2
    volumes:
      - /opt/docuteam/ssl/certifcate.pem:/cert.pem:ro</code>

3. Bind mounts of remote share which are defined through docker volumes
<code>version: '3.9'
services:
  fedora:
    image: docker.cloudsmith.io/docuteam/docker/fcrepo:6.2.0
    volumes:
      - fedora_data:/fcrepo_home
volumes:
  fedora_data:
    driver_opts:
      type: cifs
      device: //remote-hostname.com/path/to/share/fedora
      o: addr=remote-hostname.com,username=user,password=mysuperpassword,nodev,noexec,nosuid,vers=2.1,uid=1000,gid=1000

Docker Installation

Windows Docker Desktop

CentOS

https://docs.docker.com/engine/install/centos/#install-using-the-repository

Ubuntu

https://docs.docker.com/engine/install/ubuntu/

configure log

https://docs.docker.com/config/containers/logging/configure/

Das file muss möglicherweise zuerst erstellt werden, unter etc/docker/daemon.json

Post installation steps

https://docs.docker.com/engine/install/linux-postinstall/

Docker als Dienst einrichten und user der Gruppe docker hinzufügen (docker Gruppe wird bei Installation erstellt).

Docker Befehle

Anzeigen aller Container

sudo docker ps -a

Nur laufende:

sudo docker ps

Anzeigen aller Images

sudo docker images

Ausgabe eines Containers anzeigen

docker logs  <docker id>

Docker logs

journalctl -xu docker.service

Container starten

docker run -it %%--%%name Test_run ubuntu:20.04 /bin/bash

ist wie

docker create -it %%--%%name <IrgendEinName> <IMAGE> <COMMAND> 
und anschliessend 
docker start -ai <IrgendEinName>

Das Docker Image ubuntu:20.04 muss vorher heruntergeladen worden sein. Man kann natürlich auch eigene Images erstellen.

Will man ein Docker starten ohne gleich in der Shell zu landen, also als Daemon, dann die Option -itd anstatt -it verwenden. Man kann später mit docker exec ein Befehl ausführen, z.B. docker exec Test_run ls -la oder um direkt in die Shell des Containers rein zu gehen docker exec -it Test_run /bin/bash.

Docker Container starten und neues Image hinzufügen (curl)

Docker Container starten aufgrund Image ubuntu:20.04 docker run -it %%--%%name Testcontainer ubuntu:20.04
apt install curl
Somit haben wir Basis Image um neues Programm erweitert
mit exit aus dem Container gehen
docker ps -a Status ist "Exited"
Commit machen: docker commit -m "curl hinzugefügt" <CONTAINER ID> <docker hub user>/ubuntu_mit_curl
docker images sieht man neues Image
Wenn man will kann man jetzt nach docker hub pushen.

Container stoppen / neu starten

docker stop. Restart: `docker restart``

Befehl in Docker Container ausführen

Z.B. MySQL, wobei wordpress-baumfreunde_db_1 der Container-Name ist, den man mit docker ps herausfindet.

sudo docker exec -it wordpress-baumfreunde_db_1 mysql -uroot -p

Import DB in docker container

sudo docker exec -i wp_db mysql -h 172.17.0.1 -P 3306 --protocol=tcp -uroot -p wp_baum < /var/www/wordpress-from-docker/wp_baum.sql

Backup DB in docker container

docker exec -it wordpress-baumfreunde_db_1 mysqldump --add-drop-table -uroot -pXXX wp_baum > /home/roru/wordpress-baumfreunde/wp_baum_backup.sql

SSH in docker

sudo docker exec –it <container-name> /bin/bash
#als root
docker exec -u root -it <container-name> /bin/bash

Copying files/folders

Copy file from host to docker

sudo docker cp "file.txt" c30c199ec89c:/home/actions

Copy folder from docker to host

sudo docker cp "c30c199ec89c:/home/actions/conf /home/rogrut

IP des Containers auslesen

docker inspect -f '{{range.NetworkSettings.Networks}}{{.IPAddress}}{{end}}' container_name

Container entfernen

Zum Container entfernen: docker stop Test_run und docker rm Test_run.

Daten Teilen

1. Möglichkeit: Verzeichnisse mappen (Host-Verzeichnis im Container mappen)

docker run -v <HOST DIR>:<DOCKER DIR>

Konkret:

$ docker run -it -v ~/Desktop/LokaleDaten:/home/daten --name Datentest ubuntu:20.04 /bin/bash

2. Möglichkeit: Daten-Container verwenden (zwischen Container und Container)

Datencontainer mit Volume /data/db erstellen

docker create -v /data/db --name datenbox busybox true

Neuen Container für Anwendung erstellen

$ docker run -it --volumes-from datenbox ubuntu:20.04 /bin/bash
$ cd /data/db
$ touch datei.txt
$ exit

Die Datei ist jetzt im Datencontainer unter /data/db. Der Datencontainer muss gar nicht gestartet werden um ihn zu verwenden.

Container verlinken

Ports verbinden

Beispiel Image martinblaha/testapp starten, localhost Port 4000, docker Port 1337

docker run -it -d --name myApp -p 4000:1337 martinblaha/testapp sh -c 'cd /var/www/test/myapp && sails lift'

Environment Variablen

Variante 1

$ docker run -it --name TestEnv -e MY_VAR="hello world" ubunut:20.04 /bin/bash
$ env

Variante 2

So wird der Wert von MY_VAR vom hostsystem automatisch mitgegeben:

$ docker run -it --name TestEnv -e MY_VAR ubunut:20.04 /bin/bash
$ env

Variante 3

Env Variable Liste übergeben

$ docker run -it --name TestEnv -env-file ./env.list ubunut:20.04 /bin/bash
$ env

Link zwischen 2 Container

Sicherer Tunnel zwischen beiden Container. Ports müssen nicht geöffnet werden. Dabei geschieht folgendes:

Umgebungsvariablen des Quellcontainers werden im Zielcontainer veröffentlicht.
Einträge in ''/etc/hosts'' des Zielcontainers gesetzt, die zum Quellcontainer führen.

Beispiel:

Ubuntu 20.04 Image erstellen und mit mongodb:mongo Container verlinken.

mongodb: NAMES, mongo: IMAGE (sieht man, wenn man docker ps macht)
$ docker run -it -P --link mongodb:mongo ubuntu:20.04 /bin/bash

Docker file

Dockerifle ist eine einfache Textdatei. Kann Images anhand der Schritte, die in einem Dockerfile definiert werden, bauen.

Wenn wir ein solches Imagefile erhalten, können wir es bauen, bevor man es mit docker run starten kann.

Dockerfile erstellen, siehe Doku unter https://docs.docker.com/reference/builder

$ docker build -t REPOSITORY/TAG .

Docker Hub

$ docker login
$ docker pull
etc.

Docker-compose

Starten

Ins Verzeichnis gehen wo docker-compose.yml liegt, und dann docker-compose start -d

Stoppen

The docker-compose stop command will stop your containers, but it won’t remove them.
The docker-compose down command will stop your containers, but it also removes the stopped containers as well as any networks that were created.
You can take down 1 step further and add the -v flag to remove all volumes too. This is great for doing a full blown reset on your environment by running docker-compose down -v.

7.5 KiB Raw Blame History Unescape Escape

Docker

Image vs Container