Programmers Notes

References:

Dockerfile reference
docker build: command options and examples
docker run: command options and examples

Ablauf (Schnellversion)

docker pull postgres:latest	Docker image ‚postgres:latest‘ aus dem DockerHub holen
oder: Selbst erstellen:
docker build -t test .	Docker image erstellen gemäss dem File Dockerfile, welches sich im current Directory befindet
docker image ls	Docker Images auflisten (die Docker kennt)
docker run — name myContainer7 – p 80:8080 test	Docker Image (als Container instantieren) laufen lassen
docker ps	Laufende Container abfragen (–> ID auslesen)
docker ps -a	Instantierte Container abfragen (–> ID auslesen)
docker stop <containerId>	Container stoppen (bleibt instantiert)
docker container rm <containerId>	Container löschen
docker image rm <imageId>	Image löschen (aus Docker löschen)
docker image help	Hilfefunktion für Docker Images aufrufen.

Begriffe

Docker File: –> Ein File (Name wahrscheinlich immer ‚Dockerfile‚) welches innerhalb des SW Roots liegt und die die Erstellung des Docker Images definiert.

Docker Image –> Code, der falls instanziert, zu einem Docker Container wird.

DockerHub –> Repository für Docker Images.

Docker Registry

Einen Container beziehen und laufen lassen

Ein Docker Image aus dem DockerHub holen. (Im Beispiel ist es eine PostgresSQL DB als Docker image.)

docker pull postgres:latest

Kontrolle ob das Image nun lokal verfügbar ist:

$ docker image ls
REPOSITORY          TAG       IMAGE ID       CREATED        SIZE

postgres            latest    317a302c7480   9 days ago     374MB

Das Image laufen lassen:

docker run --name psql -e POSTGRES_PASSWORD=password! -p 5433:5432 -d postgres:latest

Parameter:

-name : Sollte eigentlich der Name des Containers sein
-e : Environment. Hier werden dem Containers Environment-Parameter mitgegeben.
-p : <outerPort>:<InnerPort> bezeichnet die den Port, der von aussen angesprochen werden kann und den Port der damit innerhalb des Containers angesprochen wird.
-d : Das Docker-Image, das gestartet wird.

Die DB benutzen:

$ psql -U postgres -p 5433
Passwort für Benutzer postgres:
psql (13.3, Server 14.0 (Debian 14.0-1.pgdg110+1))


postgres=# \l
 postgres  | postgres   | UTF8      | en_US.utf8   | en_US.utf8 |
 template0 | postgres   | UTF8      | en_US.utf8   | en_US.utf8 | =c/postgres          +
           |            |           |              |            | postgres=CTc/postgres
 template1 | postgres   | UTF8      | en_US.utf8   | en_US.utf8 | =c/postgres          +
           |            |           |              |            | postgres=CTc/postgres


postgres=#

Ein Docker Image erstellen und ausführen

Unser Beispiel stellt einen Simplen Python/Flask Webserver als Docker-Image zur Verfügung.
1. Der Simple Python/Flask Webserver:

from flask import Flask
APP = Flask(__name__)


@APP.route('/')
def hello_world():
    return 'Hello, World from Flask!\n'


if __name__ == '__main__':
    APP.run(host='0.0.0.0', port=8080, debug=True)

Das Dockerfile darf keine File-Extension haben und liegt typischerweise im Root-Directory des SW-Projekts. (Hier im selben directory wie das Python file.)

FROM python:3.7.2-slim

COPY . /app
WORKDIR /app

RUN pip install --upgrade pip
RUN pip install flask


ENTRYPOINT ["python", "app.py"]

Die einzelnen Zeilen bedeuten:

FROM python:3.7.2-slim	Dieses Dockerfile erbt Eigenschaften vom python:3.7.2-slim image.
COPY . /app	Kopier content des current directory ins app directory
WORKDIR /app	Definiere ‚/app‘ als das work directory
RUN pip install –upgrade pip	Führe ‚pip install –upgrade pip‘ aus (ich nehme mal an, dass dies auf dem Build-Server läuft und nicht auf dem Runtime server.)
ENTRYPOINT [„python“, „app.py“]	Wird das Docker-Image (der Docker-Container) gestartet soll ‚python‘ mit parameter ‚app.py‘ aufgerufen werden.

Kompilieren des Dockerfiles zum Dockerimage

docker build -t test .

-t test : Das Image soll den Titel ‚test‘ erhalten
‚.‘ : Sucht nach ‚Dockerfile‘ im current directory.

Kontrolle ob das Image erstellt wurde

docker image ls

Das Image laufen lassen

docker run --name myContainer  -p 80:8080 test

Der Container wird den namen ‚myContainer‘ tragen und unter dem Port 80 in der Aussenwelt ansprechbar sein.

docker ps	Laufende Docker Images abfragen

Kontrolle ob das Flask Webserver Image läuft:

curl http://127.0.0.1:80/

Oder im Browser: http://127.0.0.1:80/

Docker-Container/Image aufräumen

docker ps	Laufende Containers auflisten (z.B. Id)
docker ps -a	In Docker existierende Container auflisten.
docker stop <containerId>
docker container rm <containerId>	Einen Container von Docker entfernen.
docker image ls	Images listen (die Docker kennt)
docker image rm <imageId>	Image entfernen (aus der Liste der Images, die Docker kennt)