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 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 --name Test_run ubuntu:20.04

Container stoppen / neu starten

docker stop
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

Bash in container

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

Dockerfile / Eigenes docker image

Dockerifle ist eine einfache Textdatei, mit der man eigene Images bauen kann. Sie basieren immer auf einem bestehenden base Image (z.B. nginx:latest)

Mit docker build wird das image erstellt, bevor man es mit docker run starten kann. Im Ordner wo das dockerfile liegt, docker build -t node-app:1.0 ., wobei node-app ein x-beliebiger Name ist für das image, und anschl. die Version.

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

Docker Hub

hier gibt es vorgefertigte Images.

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

6.0 KiB Raw Blame History Unescape Escape

Docker

Docker Installation

Image vs Container