Joopi - Docker

Docker neues handling 20221105

Sat, 23 Nov 2024 19:57:17 +0100

Neue Erkenntnisse

Heute, am 05.11.2022, habe ich mich wieder intensiver mit Docker und dessen Möglichkeiten für mich befasst.

Im Moment möchte ich hier nur einige Befehl hineinkopieren, die wichtig sind.

In dem Docker-Projektordner kann der Container so gestartet werden, dass man ein Volume erstellt, welche Daten vom Host im Container zur Verfügung stellt.
Es können naütrlich auch Ordner als Volumes zur Verfügung gestellt werden, die außerhalb des Projektordners liegen. Dann muss er eingebunden werden wie im zweiten Befehl.

Code:
docker run -it --name ubuntu -v "$(pwd):/home" ubuntu:22.04 bash

oder

Code:
docker run -it --name ubuntu -v "/media/django/webserver/dockerdaten/ubuntu2204:/home" ubuntu:22.04 bash

Ein Container, der nur einen Service zur Verfügung stellt, wie z.B. ein Webserver, sollte detached gestartet werden. Dadurch wird die Konsole wieder frei und wird nicht durch den laufenden Container blockiert. Der Webserver muss ja nur im Hintergrund laufen.

Hinweis:

Ein Container sollte nur immer einen Prozess abbilden. Wird ein CMS und eine MySQL-Datenbank benötigt, sind zwei Container erforderlich.
Diese Container können dann über eine Datei mit dem Namen docker-compose.yaml zusammengeführt werden. Die Startreihenfolge wird durch die Abhängigkeit des einen Prozess vom anderen Prozess bestimmt. Aber es laufen zwei Container!

Wenn ich in einen laufenden Container einsteigen möchte, der im detached-Modus läuft, so muss sich folgenden Befehl absetzen:

Code:
docker attach 

demnach

Code:
docker attach 80da9e62d78e

Temporärer Befehl

Code:
docker run -it --name meinubuntu --network meinnetwork -v meinvolume:/home ubuntu:22.04 bash

Update am 07.11.2022

Heute habe ich verstanden, dass gestoppte Container nicht nutzlos sind, sondern über

Code:
docker start --attach container-id

wieder genutzt werden können.

Man soll zwar in Containern nicht produktiv arbeiten, aber bei entsprechender Vorsicht können in den Containern Arbeitsstände *dauerhaft* zur Verfügung gestellt werden.

Das sind 15 Dockerbefehle, die man im Alltag gebrauchen kann

Docker-Befehle

Optionen

Beim run-Befehl wird die Option -it angegeben. Diese Option steht für:

-i = interaktiver Modus
-t = Shell als Standardinput-Gerät

Wenn beim run-Befehl die Option -d angegebenn wird, so wird der Container als *dameon* gestartet und kann grundsätzlich nicht zu sehen. Will man in einem Hintergrundcontainer etwas tun, so muss mit

docker exec (docker exec –it {container} {command})
docker attach (docker attach {container})

in den Container verzweigt werden.

Docker handling compose

Sat, 23 Nov 2024 19:55:51 +0100

Infos zum Handling von Docker-Compose

Wenn das Docker-Compose-File genutzt wird, entfallen einige Aktionen auf der Konsole. Das Stoppen und Löschen von Containern ist nicht notwendig.

Zum Schluss bleibt im Grunde genommen nur das Image übrig, welches beim neuerlichen Start von Docker-Compose wieder genutzt wird.

Damit Docker-Compose (separat zu installieren) arbeiten kann, muss im Dockerdatenordner diese Datei liegen (andere Dateinamen sind nicht möglich):

Zitat:docker-compose.yaml

Der Start erfolgt so als detached Ausführung:

Code:
docker-compose up -d

oder

Code:
docker-compse -f dateiname.yaml up -d

Das Stoppen erfolgt so:

Code:
docker-compose stop

Das Herunterfahren erfolgt so:

Code:
docker-compose down

Sobald Docker-Compose heruntergefahren ist, werden die Container und Netzwerkverbindungen scheinbar beendet und gelöscht.

Das ist der Ablauf in der Konsole, um meine vorherige Behauptung zu untermauern:

Code:
user@user:/media/django/webserver/dockerdaten$ sudo docker-compose down

Removing dockerdaten_meinghost_1 ... done

Removing network dockerdaten_default

user@user:/media/django/webserver/dockerdaten$ sudo docker ps -a

CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

user@user:/media/django/webserver/dockerdaten$ sudo docker container ls -a

CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

user@user:/media/django/webserver/dockerdaten$ sudo docker image ls

REPOSITORY  TAG      IMAGE ID      CREATED        SIZE

ghost        4        b05a58075ef6  19 hours ago  448MB

Docker images Nutzung

Sat, 23 Nov 2024 19:54:26 +0100

Hinweise zur Nutzung von Docker Images

CouchBase

CouchBase auf Docker Hub

Step - 1: Run Couchbase Server docker container

Code:
docker run -d --name db -p 8091-8094:8091-8094 -p 11210:11210 couchbase

Step - 2: Next, visit http://localhost:8091 on the host machine to see the Web Console to start Couchbase Server setup.

CouchDB

CouchDB auf Docker Hub

Code:
user@user:~$ sudo docker run -d --name my-couchdb couchdb:latest

ead0a152cfefc65ef3921534134b94d7a72cdea59dd876e231f10b5e6ac16de9

MongoDB

MongoDB auf Docker Hub

Code:
sudo docker run --name mymongo -d mongo:5.0.2-focal

eb6ed078e31adca5550c4a242033aa147c29c4bcd7c0b70e8a46cd1b6b919d25

Die für MongoDB gültigen TAG sind hier:

Supported tags and respective Dockerfile links

Ghost

Ghost - free blogging plattform

Code:
sudo docker run -d --name myghost ghost

06b77297a1e2fb0871aef98139127ea559e74c764d971e7ac00033a50129ddfe

Will man Zugang im Browser haben, dann ist folgender Befehl erforderlich:

Code:
sudo docker run -d --name some-ghost -e url=http://localhost:3001 -p 3001:2368 ghost

Im Browser ist dann das einzugeben: http://localhost:3001

und für den Adminzugang ist das einzugeben: http://localhost:3001/ghost

Container löschen und neu erstellen

Sobald der Container beendet ist, kann er gelöscht werden, da man nur mit einem neuen run-Befehl den Container später über den gewünschten Port im Browser ansprechen kann. Daher ist es wichtig, dass Anwenderdaten nicht im Container, sondern in einem Volumen gespeichert werden.

Das ist der Ablauf, um einen laufenden Container zu beenden und dann wieder später nutzbar zu machen:

Code:
user@user:~$ sudo docker stop meinghost

[sudo] Passwort für django: 

meinghost

user@user:~$ sudo docker container rm meinghost

meinghost

user@user:~$ sudo docker run -d --name meinghost -e url=http://localhost:3001 -p 3001:2368 -v /media/django/webserver/dockerdaten/ghost:/var/lib/ghost/content ghost

7cb325446ab4ab7476dfe274b3a90dc5dca7ee281f4b3d66ed3583f6e56b3171

Im Standard nutzt Ghost SQLite als Datenbank. Die Einbindung von MySQL ist aber auch möglich und auf der Ghost-Dockerseite beschrieben.

Golang

golang Official Image Go (golang) is a general purpose, higher-level, imperative programming language.

Es ist wohl ein DockerFile notwendig, um dieses Image im Container laufen lassen zu können.

Docker img installieren

Sat, 23 Nov 2024 19:53:11 +0100

Sammlung von Docker IMG

Die Docker-Grundlagen

Docker Grundlagen
Wie funktionieren Docker Container?

Achtung:
Docker IMG haben nur Leserechte.

Will man mit Docker arbeiten und Daten verändern, müssen die Container ran. Darin kann man arbeiten.

Ein Container entsteht immer aus einem Image. Es beinhaltet alle Komponenten, um eine Anwendung plattformunabhängig auszuführen.

Eine Bash ausführen in einem Container:

Code:
sudo docker run -it ubuntu bash

Docker Eigene Daten

Sat, 23 Nov 2024 19:52:09 +0100

Eigene Daten in Docker-Container erstellen und speichern

Ich habe versucht herauszufinden, ob man Daten in einem Docker-Container erstellen und speichen kann. Und ob diese Daten später noch vorhanden sind, wenn der Container gestoppt (nicht gelöscht) wurde.

Dazu habe ich mir ein Ubuntu als Betriebssystem heruntergeladen und via apt-get ein Upate und ein Upgrade gemacht. Das war notwendig, um danach den Editor nano zu installieren.

Zwar hatte ich eine Datei im Home-Verzeichnis via touch erstellt, jedoch hatte ich keinen Zugriff auf einen Editor. Komisch eigentlich.

Mit nano konnte ich die erstellte Datei dann ganz normal bearbeiten und speichern.

Dann habe ich dne Container mit exit verlassen und mit stop den Container gestoppt.

Und dann habe ich mit start den Container wieder gestartet und mich mit exec wieder in den Container eingeloggt.

Die vorher erstellte Datei und der Inhalt waren vorhanden. Somit kann man die Container durchaus produktiv nutzen. Es muss aber Möglichkeiten geben, wie man eine Sicherung der Daten außerhalb des Containers anlegen kann. Ich meine dieses im Heise-Tutorial gesehen zu haben.

Mit Docker habe ich nun den ganzen Abend probiert und habe mit CouchBase eine NoSQL-Datenbank im Container laufen. Das ist nicht schlecht. Leider kann ich MongoDB nicht starten, da ich mit dem TAG nicht klarkomme. Das muss ich morgen mal ausprobieren.

Docker Infos Heise-Tutorial

Sat, 23 Nov 2024 19:50:29 +0100

Infos aus dem 6-teiligen Heise-Tutorial

Erstellung eines Volums.

Volums sind dafür da, um eigene Daten aufzunehmen. Damit diese nicht direkt in einen Container erfasst werden, legt man unter /usr/share zum jeweiligen Programm, z.B. nginx, ein Volume an.

Die Syntax wäre in diesem Beispiel wie folgt:

Code:
sudo docker run --name my-nginx -v /some/content:/usr/share/nginx/html:ro -d nginx

some-nginx = Name des Containers
-v = ein Volume anhängen und deklarieren
-d = Dienst läuft im Hintergrund
nginx = Image
ro = read only

Hinweis:
In einem Dockercontainer sind nur die wichtigsten Pakete enthalten. Will man eine Textdatei erstellen, aber ein Editor ist nicht verfügbar, kann man pragmatisch folgendes machen:

Code:
echo "Hallo Docker!" > index.html

Damit erstellt man eine Datei, die dann verwendet werden kann. Will man künftig mehr in dem Container machen, empfiehlt es sich, einen Editor zu installieren (und daraus dann ein eigenes Build zu machen). Das wird so aber nicht empfohlen (?). Insgesamt ist das der denkbar schlechteste Weg.

Fazit:
Mit docker exec in einen Container zu gehen und dort Daten zu bearbeiten ist nicht gut und sollte so nicht gemacht werden.

Die Anwendungsdaten werden im Container nicht gespeichert. Sobald der Container beendet wird, sind die Daten weg. Daher müssen Volumes angelegt werden, die die Anwendungsdaten speichern udn vorhalten.

Um ein Volume zu erzeugen, ist folgender Befehl notwendig:

Code:
sudo docker volume create

Dieser Befehl erzeugt einen langen Name aus Zufallszahlen/-ziffern. Man kann den Volumennamen auch vorgeben:

Code:
sudo docker volume create html

Mit dem ls-Befehl kann ich mir die vorhandenen Volumes anzeigen lassen:

Code:
sudo docker volume ls

Das läuft analog zu den Images und den Containern.

Um nun das erzeugte Volume mit dem Namen html in den nginx-Container zu bringen, wird eine zweite Instanz aufgemacht und ein weiterer Port eröffnet (nicht zwingend erforderlich, nur zur Demonstration):

Code:
sudo docker run --name myvol-nginx -p 8081:80 -v html:/usr/share/nginx/html:ro -d nginx

ro heißt readonly.

Das erzeugte Volume liegt hier:

Zitat:/var/lib/docker/volumes

Dieses Verzeichnis kann ein Normaluser, selbst wenn er in der Gruppe docker ist, nicht sehen (sudo -s)

WICHTIG:
Selbst wenn der Container zerstört wird, bleibt das Volume erhalten. Wichtig ist dann dabei, dass das Verzeichnis /usr/lib/docker gesichert wird, wenn in diesem Verzeichnis Nutzer- und Anwendungsdaten für die weitere Verarbeitung gespeichert werden, also produktiv genutzt werden.

Die Volumes müssen nicht unbedingt im Docker-Verzeichnis liegen, sondern können an jeder beliebigen Stelle gespeichert werden. Dazu wäre dann z.B. dem Volume HTML das Verzeichnis voranzustellen (Beispiel): /home/django/dockervolume/HTML

Die Prozesse, die innerhalb der Container laufen, müssen allerdings die Berechtigungen auf dieses Verzeichnis haben.

Docker und Netzwerke

Docker erzeugt ein eigenes Netzwerk: docker0

Code:
ifconfig docker0

Docker hat verschiedene Netzwerke, die man sich so anzeigen lassen kann:

Code:
docker network ls

Beispiel, wie zwei Container kommunizieren.

Ein Blogsystem auf Basis WordPress-Blogsystem

Container mit Webserver und WordPress
Container mit Datenbank MySQL / MariaDB

Container für Datenbank:

Code:
docker run --name test-mysql -e MYSQL_ROOT_PASSWWORD=meinpasswort -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wp -e MYSQL_PASSWORD=meinpasswort -d mysql:5.7

Container für WordPress / Webserver

Code:
docker run --name wordpress --link test-mysql:test-mysql -p 8082:80 -d wordpress

Hinweis:

Zitat:--link anstelle von --name

Dieser Part "test-mysql:test-mysql" bedeutet, dass der Container test-mysql auch als test-mysql angesprochen werden. Soll dieser Name dann anders lauten, müsste er angegeben werden (z.B. test-mysql:test-worpress).

Hinweis:
Docker hat einen eigenen DNS-Server laufen.

Für das obige Beispiel würde im Browser, da wir mit WordPress arbeiten wollen, folgendes einzugebenn sein:

Zitat:localhost:8082

Sodann würde die Installation von WordPress erfolgen.

Die Daten von WordPress werden in der Datenbank abgespeichert. WordPress und die Datenbank sind in zwei Containern aufgeteilt. Um mit den eingegebenen Daten weiter arbeiten zu können, müssten die Daten in ein Volume übertragen werden

Wie das geht, weiß ich noch nicht!

Wenn z.B. WordPress vom Rest der Welt trennen möchte, dann kann das über ein eigenes Docker-Netzwerk erfolgen. Das sieht dann so aus:

Code:
docker network create --driver bridge test-bridge

Prüfen, ob das Netzwerk angelegt ist bzw. welche vorhanden sind, kann man mit:

Code:
docker network ls

Dieses neue Network kann man an den Run-Befehl für mysql hängen:

Code:
docker run --name test-mysql --network=test-bridge -e MYSQL_ROOT_PASSWWORD=meinpasswort -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wp -e MYSQL_PASSWORD=meinpasswort -d mysql:5.7

Hinweis:

Es gibt den inspect-Befehl. Dieser kann auf das Netzwerk angewandt werden. Um das neue Netzwerk zu inspizieren, ist folgendes notwendig:

Code:
docker network inspect test-bridge

Man kann also in das Netzwerk "hineinschauen".

Wie kann man Docker vereinfachen?

Contaner mit Compose einrichten

Mehrere Container nebeneinander betreiben.

Docker-Compose ist ein Python-Script (offizell von Docke unterstützt), mit dem vereinfacht mehrere Container aufgebaut und miteinander verbunden werden können.

Ein Compose-File ist wie folgt strukturiert (Beispiel MySQL-Container)

Zitat:version: '3'

services:
db:
image: mysql:5.7
volumes:
- ./data/db/:/var/lib/mysql
restart: always
ports:
- "3306:3306"
environment:
MYSQ_ROOT_PASSWORD: secret123root

Die Inhalte sind quasi die gleichen wie in einem run-Befehl.

Die Aussage ist, dass selbst, wenn nur ein Container laufen soll, eine Compose-File nützlich ist.

Der data-Ordner des Volume liegt in dem Ordner, aus dem das Compose-File aufgerufen wird. Der Punkt weist auf die relative Lage hin. Hat mein einen eigenen Bereich auf der lokalen Festplatte eingerichtet, ruft man das File eben von dort aus auf.

Für das Beispiel aus dem Netzwerkabschnitt (WordPress und MySQL) sieht das Compose-File wie folgt aus:

Zitat:version: '3'

services:
db:
image: mysql:5.7
volumes:
- ./data/db/:/var/lib/mysql
restart: always
ports:
- "3306:3306"
environment:
MYSQL_ROOT_PASSWORD: secret123root
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: 12345wordpress54321

wordpress:
depends_on:
- db
image: wordpress:latest
ports:
- "80:80"
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: 12345wordpress54321
working_dir: /var/www/html
volumes:
- ./data/wordpress:/var/www/html/wp-content

portainer:
image: portainer/portainer
restart: always
ports:
mehr sehe ich nicht, scheint ein volume zu sein, ist wohl eine grafische Oberfläche gedacht, also nicht in der Konsole wichtig.

So wird die yml-Datei, in der das Compose-File abgespeichert wurde, ausgeführt:

Code:
docker-compose up

up = starten
stop = stoppen
down = herunterfahren (Container werden dabei sofort gelöscht)

Damit wird wohl alles an Compose-Files gestartet.

Die Ausführung dieses Befehl ist sichtbar, da die Option -d nicht mit angegeben worden ist.

Ansonsten könnte man bei der Sichtbarkeit die einzelnen Aktionen sehen, die ausgeführt würde. Es gibt dann wohl, sobald der Datanbankserver oben ist mit der Installation von Wordpress im Browser.

Hinweis:
In einer yml-Datei ist die Einrückungstiefe immer 2 Leerzeichen. Man kann auch Tabs verwenden, aber zwei Leerzeichen sind wohl Standard.

Um z.B. auf der Shell in die Container mit dem exec-Befehl einzusteigen, kann folgender Befehl genutzt werden:

Code:
docker-compose excec db sh

Damit ist man im Container anstelle des komplexen Befehlaufrufes aus den Anfängen.

Die grafische Oberfläche für Docker

Portainer ist eine bekannte grafische Oberfläche

Sofern im Compose-File der Portainer integriert ist, kann man in der Adressezeile des Browsers über den Port 9000 die Webseite erreichen.

Zitat:localhost:9000

Ich unterstelle derweil, dass das möglich ist, denn in dem Beispiel bei Heise wird mittlerweile eine echte Domain genutzt. Sollte aber auch mit localhost funktionieren.

Zertifikate erstellen

Die Anwendungen, die man in Docker erstellt, kann man sind Internet bringen. Man muss dafür aber vieles beachten, um die Sicherheit zu gewährleisten. Mit Zertifikaten kann man das erreichen.

Eine Grundlage ist z.B. Watchtower (wird niht mehr entwickelt, es gibt was neues) und gehört zu vorherigen Compose-File.

Watchtower ein Image, welches sich um die Aktualisierung von Images kümmert, was durch Docker selber nicht geleistet wird.

Code:
watchtower:

  image: v2tec/watchtower

  volumes:

    - /var/run/docker.sock:/var/run/docker.sock

  command: --interval 30

Um von außen auf die Anwendung schauen zu können, wird folgendes benötigt (Revers-Server/Proxy oder so ähnlich)

Für das nachfolgende Beispiel muss der WordPress-Container angepasst werden, da diese keine Ports mehr freigeben darf (wird weiter unten mit 80 und 443 gemacht):

Code:
wordpress:

        depends_on:

            - db

        image: wordpress:php7.1

        restart: always

        environment:

            WORDPRESS_DB_HOST: db:3306

            WORDPRESS_DB_USER: wordpress

            WORDPRESS_DB_PASSWORD: 12345wordpress54321

            LETSENCRYPT_HOST: mlsjam.leipsieb.de

            LETSENCRYPT_EMAIL: mls@ct.de

            VIRTUAL_HOST: mlsjam.leipsieb.de

            VIRTUAL_PORT: 80

        working_dir: /var/www/html

        volumes:

            - ./data/wordpress:/var/www/html/wp-content

Ob das auch auf localhost läuft, weiß ich derzeit nicht.

Code:
nginxproxy:

  image: jweilder/nginx-proxy

  restart: unless-stopped

  volumes:

    - ./data/certs:/etc/nginx/certs

    - ./conf:/etc/nginx/conf.d

    - ./dhparam:/etc/nginx/dhparam

    - ./data/vhosts:/etc/nginx/vhost.d

    - ./data/html:/usr/share/nginx.html

    - /var/run/docker.sock:/tmp/docker.sock

  ports:

    - 80:80

    - 443:443

  labels:

    - "com.github.jrcs.letsencrypt_nginx_proxy_companion.nginx_proxy"

nginxproxy_comp:

  image: jrcs/letsencrypt_nginx_proxy_companion

  restart: unless_stopped

  depends_on:

    - nginxproxy

  volumes:

    - ./data/certs:/etc/bginx/certs:rw

    - ./conf:/etc/nginx/conf.d

    - ./dhparam:/etc/nginx/dhparam

    - ./data/vhosts:/etc/nginx/vhost.d

    - ./data/html:/usr/share/nginx.html

    - /var/run/docker.sock:/tmp/docker.sock:ro

In meinen Tests hatte ich mehrere Male die Probleme, dass die Ports z.B. 8080 oder 8081 als belegt gekennzeichnet wurden.

Um herauszufinden, welche Anwendungen die Ports belegen, natürlich können das auch laufende Container sein, ist folgender Befehl hilfereich:

Code:
sudo lsof -i -P -n | grep 8080

Das Ergebnis sieht so aus:

Pasted image 20210819105406.png (Größe: 49,53 KB / Downloads: 37)

Somit ist für mich klar, dass ich den Port 8081 nehme.

Wie ich mit den Ports überhaupt umgehen muss, weiß ich selber noch nicht, wenn es sich um Webanwendungen handelt.

Docker installieren

Sat, 23 Nov 2024 19:49:05 +0100

Docker über Repository installieren für Focal

Auf dieser Webseite habe ich die Installationsanleitung für Docker aus den Repositories für Ubuntu Focal gefunden:

Docker installation on Ubuntu Install via repository

Und hier kommt die Anleitung als Kopie der Webseite.

Docker installation on Ubuntu

Install via repository

Docker installation process on Ubuntu is practically the same as on Debian.

1. Update the distro and install necessary packages:

Code:
$ sudo apt update

$ sudo apt install apt-transport-https ca-certificates curl gnupg-agent software-properties-common

2. Second step is to add Docker GPG key for Docker

Code:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

3. Verify the key fingerprint:

Code:
$ sudo apt-key fingerprint 0EBFCD88

4. Add the repository:

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

5. Install Docker:

Code:
$ sudo apt-get update

$ sudo apt-get install docker-ce docker-ce-cli containerd.io

6. Start and enable the Docker:

Code:
$ sudo systemctl start docker

$ sudo systemctl enable docker

7. Test Docker also with the hello container

Code:
$ sudo docker run hello-world

Da Docker das IMG nicht findet, kommt erst eine Fehlermeldung, dann aber, wenn der Download erfolgreich war, die Meldung, dass alles gut ist. Sieht dann in der Konsole so aus:

Code:
user@user:/$ sudo docker run hello-world

Unable to find image 'hello-world:latest' locally

latest: Pulling from library/hello-world

b8dfde127a29: Pull complete 

Digest: sha256:0fe98d7debd9049c50b597ef1f85b7c1e8cc81f59c8d623fcb2250e8bec85b38

Status: Downloaded newer image for hello-world:latest

Hello from Docker!

This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:

1. The Docker client contacted the Docker daemon.

2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

    (amd64)

3. The Docker daemon created a new container from that image which runs the

    executable that produces the output you are currently reading.

4. The Docker daemon streamed that output to the Docker client, which sent it

    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:

$ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:

https://hub.docker.com/

For more examples and ideas, visit:

https://docs.docker.com/get-started/

Hello from Docker!** ist die richtige Meldung zum IMG.

Docker nutzen

Sat, 23 Nov 2024 19:45:25 +0100

So wird Docker genutzt

Mal wieder ein guter Link:
Entfernen von Docker-Images, -Containern und -Volumen

oder hier:

Docker run reference

Sobald Docker komplett incl. Engine installiert ist, kann Docker auch genutzt werden. Um Docker zu nutzen, muss man die Image-Namen wissen. Diese sind z.B. auf dem Docker Hub zu finden.

Docker-Image herunterladen

Code:
sudo docker pull golang

Um zu prüfen, welche Images heruntergeladen worden sind, gilt folgender Befehl:

Code:
sudo docker ps -a

[sudo] Passwort für user:

CONTAINER ID  IMAGE        COMMAND    CREATED        STATUS                    PORTS    NAMES

3b4a2640dd52  golang        "bash"    19 hours ago  Exited (0) 19 hours ago            mystifying_wu

0ee81db39223  ubuntu        "bash"    21 hours ago  Exited (0) 21 hours ago            stupefied_buck

e5afa06d8d02  hello-world  "/hello"  21 hours ago  Exited (0) 21 hours ago            mystifying_bell

Um zu prüfen, welche Container laufen, ist die Option **-a** wegzulassen:

Code:
sudo docker ps

CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

Da noch kein Container gestartet wurde, wird auch noch nichts angezeigt, was an Containern läuft.

Mit dem folgenden Befehl wird ein Container aus dem vorher heruntergeladenen Image erstellt und gestartet:

Hier wäre der Dienst im Hintergrund und läuft vor sich hin (detached)

Code:
sudo docker run -d -it --name myneuesdocker golang

oder

Hier wäre der Dienst interaktiv und benutzbar (tached)

Code:
sudo docker run -it --name myneuesdocker golang

0b2cb8ecefe8dbabb95a2078419a8585dc5b224693809a1560fff8321c429f0e

Hinweis

Wenn der run-Befehl ausgeführt wird, dann wird z.B. hinten nach dem Imagenamen ein Befehl angehängt, der dann ausgeführt werden soll. Wenn nichts angegeben wird, wird der Standardprozess gestartet.

Beispiel

Ubuntu - der Aufruf des Images zur Erstellung des Container kann mit ... ubuntu bash ... enden, damit nach dem Start des Containers sofort eine Bash vorhanden ist.

Es wird eine lange ID ausgegeben, wobei die ersten 12 Stellen wohl später die ID für die laufen Container darstellen.

Um zu prüfen, ob der Container läuft, ist wieder folgender Befehl abzusetzen:

Code:
sudo docker ps

CONTAINER ID  IMAGE    COMMAND  CREATED              STATUS              PORTS    NAMES

0b2cb8ecefe8  golang    "bash"    About a minute ago  Up About a minute            myneuesdocker

Nun wird gezeigt, welche Container laufen. In diesem Falle ist es nur der Golang-Container.

Was der Name myneuesdocker, den ich selber kreiert habe, zu bedeuten hat, weiß ich noch nicht.

Ich weiß auch noch nicht, wo Docker den Pull-Download ablegt und wo der Container wirklich liegt. Denn eigentlich müsste mindestens eine Datei zu finden sein. In Linux wird alles in Dateien erledigt.

Um mit dem Container arbeiten zu können, ist folgender Befehl notwendig:

sudo docker exec -it myneuesdocker bash
root@0b2cb8ecefe8:/go#

In diesem Falle landet man als root in einem Bash-Terminal und kann loslegen.

Um zu prüfen, welche Ordner bzw. Dateien nun zur Verfügung stehen, ist nur der **ls**-Befehl notwendig:

root@0b2cb8ecefe8:/go# ls
bin src

Die Ausgabe ist sehr minimalistisch, da nur die notwendigen Abhängigkeiten erfüllt werden. Das ist eben der große Vorteil von Docker mit den Containern gegenüber den Virtualisierungstools.

Um den Container zu verlassen, ist nur dies erforderlich:

Code:
root@0b2cb8ecefe8:/go# exit

exit

user@user:~$

Damit ist man wieder auf der eigenen Maschine unterwegs und nicht mehr im Container. Der Container läuft aber noch und ist somit jederzeit wieder zu betreten.

Um einen Container mit dem Host, also dem eigenen Computer zu verbinden, ist beim Aufruf von run der Port mitzugeben:

Code:
sudo docker run -d -t -p 80:80 --name myneuesdocker golang

Dieser Aufruf wurde auf dem Kanal von NetworkChuck in Verbindung mit einem anderen Betriebssystem genutzt. Ob das mit meinem Beispiel auch so geht, weiß ich nicht. Aber man kann Container mit dem eigenen Betriebssystem verbinden.

In dem Beispiel hat er in dem Container seine Trainingswebseite in einem Browser aufgerufen.

Um einen Container zu beenden, ist folgender Befehl notwendig:

Code:
user@user:~$ sudo docker stop myneuesdocker

myneuesdocker

Wenn man prüfen will, ob das Stoppen durchgeführt wurde, hilft wieder:

Code:
user@user:~$ sudo docker ps

CONTAINER ID  IMAGE    COMMAND  CREATED  STATUS    PORTS    NAMES

Sollte man den Container nochmal benutzen müssen, kann man ihn wieder starten:

Code:
user@user:~$ sudo docker start myneuesdocker

myneuesdocker

Die Prüfung zeigt, dass der Container wieder gestartet ist:

Code:
user@user:~$ sudo docker ps

CONTAINER ID  IMAGE    COMMAND  CREATED          STATUS          PORTS    NAMES

0b2cb8ecefe8  golang    "bash"    54 minutes ago  Up 25 seconds            myneuesdocker

Dieses Start und Stop ist nicht mit dem **run**-Befehl zu verwechseln, denn damit wurde das Image gestartet. Der Container wurde dann separat in einem nächsten Schritt gestartet (docker exec ...)

Je nach dem mit welcher Computerausstattung man unterwegs ist, muss man die Ressourcen im Auge behalten. Auch dafür ist gesorgt und mit folgendem Befehl kann man die Speicherauslastung prüfen:

Code:
sudo docker stats

Die Ausgabe dieses Befehls zeigt die Auslastung von CPU, RAM usw.
Da nur ein Container läuft, ist die Ausgabe relativ knapp:

Pasted image 20210816172422.png (Größe: 10,52 KB / Downloads: 32)

Code:
CONTAINER ID  NAME            CPU %    MEM USAGE / LIMIT  MEM %    NET I/O      BLOCK I/O  PIDS

0b2cb8ecefe8  myneuesdocker  0.00%    824KiB / 62.73GiB  0.00%    12.2kB / 0B  0B / 0B    1

Das Management von Images und Containern ist nicht unbedingt einfach. Über folgenden Befehl kann man sich die Hilfe anzeigen lassen:

Code:
docker --help

Will man zu einzelnen Kommandos etwas wissen, muss der Befehl so aussehen:

Code:
docker system --help

Damit werden dann weitere Hilfen angezeigt, was man eben machen kann.

Im Laufe der Zeit werden sich vielleicht einige Images und Container ansammeln, die man nicht mehr haben will oder gebrauchen kann/möchte.

Um herauszufinden, welche Images vorhanden sind, ist dieser Befehl notwendig:

Code:
sudo docker images -a

REPOSITORY    TAG      IMAGE ID      CREATED        SIZE

golang        latest    0821480a2b48  10 days ago    862MB

ubuntu        latest    1318b700e415  2 weeks ago    72.8MB

hello-world  latest    d1165f221234  5 months ago  13.3kB

Dieser Befehl ist nicht mit der ps-Option zu verwechseln, die Container betrifft.

Diese Auflistung kann dazu verwendet werden, dass Images, die nicht mehr gewünscht sind, entfernt werden (es können mehrere Images angegeben werden):

Code:
user@user:~$ sudo docker rmi hello-world

Error response from daemon: conflict: unable to remove repository reference "hello-world" (must force) - container e5afa06d8d02 is using its referenced image d1165f221234

Der Löschbefehl wurde nicht akzeptiert. Verstanden habe ich das bislang noch nicht.

Exkurs

Das habe ich hier gefunden Docker error cannot delete docker container, conflict: unable to remove repository reference

Code:
docker container ls -a

docker image ls

docker container rm 

docker image rm 

Mit dem ersten Befehl werden alle Container gelistet.
Mit dem zweiten Befehl werden alle Images gelistet.
Diese Befehle sind notwendig, um die ID von Container und Images herauszufinden. Anscheinend müssen erst die Container entsorgt werden, bevor die Images gelöscht werden können.

Nun wird zunächst ein Container (Hello-World aus der Installation) gelöscht:

Code:
user@user:~$ sudo docker container rm e5afa06d8d02

e5afa06d8d02

Hiermit wird dann geprüft, ob der Container weg ist:

Code:
user@user:~$ sudo docker container ls -a

CONTAINER ID  IMAGE    COMMAND  CREATED        STATUS                    PORTS    NAMES

0b2cb8ecefe8  golang    "bash"    2 hours ago    Up 41 minutes                      myneuesdocker

3b4a2640dd52  golang    "bash"    20 hours ago  Exited (0) 20 hours ago            mystifying_wu

0ee81db39223  ubuntu    "bash"    23 hours ago  Exited (0) 23 hours ago            stupefied_buck

Sobald der Container gelöscht ist, kann auch das Images gelöscht werden:

Code:
django@django:~$ sudo docker image rm d1165f221234

Untagged: hello-world:latest

Untagged: hello-world@sha256:0fe98d7debd9049c50b597ef1f85b7c1e8cc81f59c8d623fcb2250e8bec85b38

Deleted: sha256:d1165f2212346b2bab48cb01c1e39ee8ad1be46b87873d9ca7a4e434980a7726

Deleted: sha256:f22b99068db93900abe17f7f5e09ec775c2826ecfe9db961fea68293744144bd

Und hier die Prüfung der vorhandenen Images:

Code:
user@user:~$ sudo docker image ls

REPOSITORY  TAG      IMAGE ID      CREATED      SIZE

golang      latest    0821480a2b48  10 days ago  862MB

ubuntu      latest    1318b700e415  2 weeks ago  72.8MB

Das Image wurde tatsächlich gelöscht.

Es gibt auch eine radikale Methode, um verwaiste Container zu entsorgen. Da muss man schon ein bisschen aufpassen, um nicht zu viel zu entsorgen:

Code:
docker system prune -a

WARNING! This will remove:

all stopped containers

all networks not used by at least one container

all unused images

all build cache

Aus der Webseite zum Entfernen von Containern

Entfernen von Containern

Entfernen von einem oder mehreren spezifischen Containern

Verwenden Sie den Befehl docker ps mit dem Flag -a, um den Namen oder die ID der Container zu finden, die Sie entfernen möchten.

Auflisten:

Code:
docker ps -a

Entfernen:

Code:
docker rm ID_or_Name ID_or_Name

Entfernen eines Containers beim Beenden

Falls Sie bei der Erstellung eines Containers wissen, dass Sie ihn nicht behalten möchten, wenn Sie damit fertig sind, können Sie `docker run --rm` ausführen, um ihn beim Beenden automatisch zu löschen.

Ausführen und entfernen:

Code:
docker run --rm image_name

Entfernen aller beendeten Container

Sie können Container mit `docker ps -a` finden und anhand ihres Status filtern: erstellt, wird neu gestartet, wird ausgeführt, angehalten oder beendet. Zum Überprüfen der Liste der beendeten Container verwenden Sie das Flag `-f`, um anhand des Status zu filtern. Wenn Sie wissen, dass Sie diese Container entfernen möchten, nutzen Sie `-q`, um die IDs an den Befehl `docker rm` zu übergeben.

Auflisten:

Code:
docker ps -a -f status=exited

Entfernen:

Code:
docker rm $(docker ps -a -f status=exited -q)

Löschen aller unbenutzten oder unreferenzierten Images, Container, Volumen und Netzwerke

Docker bietet einen einzelnen Befehl zur Bereinigung beliebiger Ressourcen – Images, Container, Volumen und Netzwerke –, die unreferenziert (also nicht mit einem Container verknüpft) sind:

Code:
docker system prune

Um auch angehaltene Container und alle nicht verwendeten Images zu entfernen (nicht nur unreferenzierte Images), fügen Sie dem Befehl das Flag `-a` hinzu:

Code:
docker system prune -a

Entfernen von Docker-Images

Entfernen von einem oder mehreren spezifischen Images

Verwenden Sie den Befehl `docker images` mit dem Flag `-a`, um die ID der Images zu finden, die Sie entfernen möchten. Dadurch wird Ihnen jedes Image angezeigt, einschließlich dazwischenliegender Image-Ebenen. Wenn Sie die Images gefunden haben, die Sie löschen möchten, können Sie ihre ID oder ihr Tag `docker rmi` übergeben:

Auflisten:

Code:
docker images -a

Entfernen:

Code:
docker rmi Image Image

Entfernen von unreferenzierten Images

Docker-Images bestehen aus mehreren Ebenen. Unreferenzierte Images sind Ebenen, die keine Beziehung zu getaggten Images haben. Sie dienen keinem Zweck mehr und verbrauchen Festplattenspeicher. Sie lassen sich finden, indem Sie das Filter-Flag (`-f`) mit dem Wert `dangling=true` zum Befehl `docker images` hinzufügen. Wenn Sie sicher sind, dass Sie sie löschen möchten, können Sie den Befehl `docker images purge` verwenden:

Anmerkung:

Wenn Sie ein Image erstellen, ohne es mit einem Tag zu versehen, wird das Image in der Liste der unreferenzierten Images angezeigt, da es keine Zuordnung zu einem getaggten Image aufweist. Sie können diese Situation vermeiden, indem Sie beim Erstellen ein Tag angeben; außerdem können Sie Images mit dem Befehl docker tag im Nachhinein mit einem Tag versehen.

Auflisten:

Code:
docker images -f dangling=true

Entfernen:

Code:
docker images purge

Entfernen von Images gemäß einem Muster

Sie können alle Images finden, die mit einem Muster übereinstimmen, indem Sie eine Kombination aus docker images und grep nutzen. Wenn Sie damit zufrieden sind, können Sie sie durch awk löschen, um die IDs an `docker rmi` zu übergeben. Beachten Sie, dass diese Dienstprogramme nicht von Docker bereitgestellt werden und nicht unbedingt für alle Systeme verfügbar sind:

Auflisten:

Code:
docker images -a |  grep "pattern"

Entfernen:

Code:
docker images -a | grep "pattern" | awk '{print $3}' | xargs docker rmi

Alle Images entfernen

Alle Docker-Images in einem System können aufgelistet werden, indem Sie dem Befehl docker images -a hinzufügen. Wenn Sie sicher sind, dass Sie alle löschen möchten, können Sie das Flag -q hinzufügen, um die Image-ID an docker rmi zu übergeben:

Auflisten:

Code:
docker images -a

Entfernen:

Code:
docker rmi $(docker images -a -q)

Noch eine Hilfe, sollte man mehrere Container laufen haben:

If you want to cleanup docker images and containers

CAUTION: this will flush everything

stop all containers

Code:
docker stop $(docker ps -a -q)

remove all containers

Code:
docker rm $(docker ps -a -q)

remove all images

Code:
docker rmi -f $(docker images -a -q)

Wo liegen die Docker-Images?

Mit folgendem Befehl kann man die Docker-Infos ermitteln:

Code:
sudo docker info

Die Ausgabe länger und die Antwort auf die Frage im letzten Teil der Ausgabe zu sehen:

Code:
user@user:~$ sudo docker info

Client:

Context:    default

Debug Mode: false

Plugins:

  app: Docker App (Docker Inc., v0.9.1-beta3)

  buildx: Build with BuildKit (Docker Inc., v0.6.1-docker)

  scan: Docker Scan (Docker Inc., v0.8.0)

Server:

Containers: 0

  Running: 0

  Paused: 0

  Stopped: 0

Images: 0

Server Version: 20.10.8

Storage Driver: overlay2

  Backing Filesystem: extfs

  Supports d_type: true

  Native Overlay Diff: true

  userxattr: false

Logging Driver: json-file

Cgroup Driver: cgroupfs

Cgroup Version: 1

Plugins:

  Volume: local

  Network: bridge host ipvlan macvlan null overlay

  Log: awslogs fluentd gcplogs gelf journald json-file local logentries splunk syslog

Swarm: inactive

Runtimes: io.containerd.runc.v2 io.containerd.runtime.v1.linux runc

Default Runtime: runc

Init Binary: docker-init

containerd version: e25210fe30a0a703442421b0f60afac609f950a3

runc version: v1.0.1-0-g4144b63

init version: de40ad0

Security Options:

  apparmor

  seccomp

  Profile: default

Kernel Version: 5.11.0-25-generic

Operating System: Ubuntu 20.04.2 LTS

OSType: linux

Architecture: x86_64

CPUs: 16

Total Memory: 62.73GiB

Name: django

ID: RTKL:M23W:E6CV:JO3K:YVNJ:GXXS:I5XO:3UU3:R654:KJQX:AXYO:L43R

Docker Root Dir: /var/lib/docker

Debug Mode: false

Registry: https://index.docker.io/v1/

Labels:

Experimental: false

Insecure Registries:

  127.0.0.0/8

Live Restore Enabled: false

Der docker-root-ordner liegt hier:

Zitat:/var/lib/docker

docker ist ein Ordner, der mit einem Schloss versehen ist:

Pasted image 20210816181843.png (Größe: 48,83 KB / Downloads: 33)

Die Images und Container werden in diesem Pfad abgespeichert, aber nicht namtlich erkennbar, sondern mit SHA256-Codenamen. Somit sind diese Dateien außerhalb der Einflussnahme durch den User, also durch mich. Ich kann nur das Management betreiben. So sieht der Ordner im Midnight-Commander aus:

Pasted image 20210816182255.png (Größe: 50,4 KB / Downloads: 38)

Somit kann ich nun am 16.08.2021 in das echte Handling von Docker einsteigen.

Docker kann nur Serversoftware verarbeiten. Grafische Oberflächen kann Docker nicht darstellen und war auch nicht Sinn und Zweck für die Entwicklung dieses Tools. Die möglichen Betriebssystem, die in Docker laufen, sind also immer nur die Serverversionen, nie die Desktop-Versionen.

Damit der Normaluser mit Docker arbeiten kann, ist er zur Gruppe Docker hinzuzufügen:

Code:
sudo usermod -aG docker django

Nach einer Neuanmeldung ist die Gruppenzuordnung aktiv.

Exkurs

Im Normalfall wird erst der Pull-Befehl und dann der Run-Befehl ausgeführt. Man kann aber auch direkt den Run-Befehl ausführen. Wird das Images nicht gefunden, wird es heruntergeladen. Also wird der Pull-Befeh implizit ausgeführt.

Die Option -d im Run-Befehl sorgt dafür, dass der Container im Hintergrund läuft.

Die Option -p 8080:80 sorgt dafür, dass man innerhalb des Container einen nach außen geöffneten Port zur Verfügung hat. Bei Webserver, die später im Webbrowser ausgeführt werden, oder bei anderen Webanwendungen (z.B. Ghost) ist das notwendig. Im Browser wäre anzugeben: localhost:8080

Die wichtigsten Befehle nochmal zusammengefasst:

docker pull imagename
docker ps
docker ps -a (zeigt auch laufende Container)
docker run -d -t --name **platzname** imagename
docker exec -it **platzname** bash oder sh (wo der Container laufen soll)
exit (aus Container aussteigen)
docker stop **platzname** (Container stoppen)
docker start **platzname** (Container starten)
docker info
docker stats
docker --help
docker command --help
docker images -a
docker container ls -a
docker image ls
docker volume ls
docker container rm ID-Container oder Name
docker image rm ID-Image oder Name
docker system prune -a (mit Vorsicht, alles alle Container, die unbenutzt sind.
docker run --rm image_name (Vorsicht: beim Beenden wird der Container direkt wieder gelöscht)

Eigene Daten sollte man nicht in den Container kopieren, sondern via Volumes bereitstellen, die dann vom Container genutzt werden. Da ist z.B. für einen Webserver gut, der in einem Container läuft und die HTML-Seiten liegen dann im Volume.

Zwar läuft z.B. ein Webserver in einem Container, aber gleichzeitig wird er auch vom Host, also vom eigenen Computer erkannt. Mit folgendem Befehl kann man prüfen, ob z.B. nginx ausgeführt wird, der in eiinem Container läuft:

Code:
ps axu | grep nginx

Das Docker-MOC

Sat, 23 Nov 2024 19:43:45 +0100

Das MOC für Docker

Meine eigenen Aufzeichnungen zum Handling von Docker. Sehr unvollständig, weil neben dem Erlernen einfach mitgeschrieben.

Hinweis

Am 06.11.2022 habe ich den Ablageort der Docker-Images von **/var/lib/docker** nach **/media/django/virtualbox/dockerworld/docker** verändert.
Der Grund ist und war, dass die separate SSD mehr Platz für solche Dateien hat.

ACHTUNG

Beim Run-Befehl von Docker bedeutet die Option -v nicht die Hinzunahme eines Volumes, sondern eines Bind-Mounts.
Ein Volume wird anders angegeben.
Ein Volume ist auch ein Ordner, aber ein leerer Ordner, der von Docker später verwaltet wird.

Ein Volum wird erstellt mit

Code:
docker volume create my_volume

und kann angeschaut werden mit:

Code:
docker volume ls

Die Volumes liegen dort, wo auch die Images abgelebt werden (/var/lib/docker oder an veränderter Stelle)

Beim Weiterreichen des Volumes ist die gleiche Schreibweise zu nutzen wie vom Bind-Mount, also mit der Option -v.

Scripte und Beschreibungen

Docker nutzen
Docker installieren
Docker Infos Heise-Tutorial
Docker Eigene Daten
Docker img installieren
Docker images Nutzung
Docker handling compose
Docker neues handling 20221105

Dockerfile

Sat, 23 Nov 2024 19:21:05 +0100

Von Zeit zu Zeit befasse ich mich mit Docker, allerdings ohne durchschlagenden Erfolg. Es fehlt mir an Möglichkeiten und auch an Phantasie.

In meinen Dokumentationen habe ich noch eine Notiz gefunden, die sich mit der Erstellung von Dockerfiles befasst. Diese möchte ich nicht verlieren, also archiviere ich das Thema hier.

Da ich mich auch mit DOCKER-SAP befassen will, erscheint mir dieses Forum gut für die Sammlung von Informationen zu sein.

Code:
# Zugrundliegendes Image

# steht so in der requirements.txt

FROM python:3.7-slim

# Mir ist noch nicht klar, ob das in DIR im Container sein wird.

WORKDIR /app

# Kopieren der Requirements - alle Dateien im aktuellen Verzeichnis kopieren (der Punkt ist das aktuelle Verzeichnis

ADD . /app

# Installieren der Requirements

# --trusted-host sollte tunlichst immer dabei sein (muss aber nicht)

RUN pip install --trusted-host pypi.python.org -r requirements.txt

#Port 80 (Webanwendung) veröffentlichen

EXPOSE 80

# app.py ist die erstellte Flask-App

CMD ["pyhton", "app.py"]