Home » Uncategorized » Docker Containers

Docker Containers

References:

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

Ablauf (Schnellversion)

docker pull postgres:latestDocker 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 lsDocker Images auflisten (die Docker kennt)
docker run — name myContainer7 – p 80:8080 testDocker Image (als Container instantieren) laufen lassen
docker psLaufende Container abfragen (–> ID auslesen)
docker ps -aInstantierte 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 helpHilfefunktion 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-slimDieses Dockerfile erbt Eigenschaften vom python:3.7.2-slim image.
COPY . /appKopier content des current directory ins app directory
WORKDIR /appDefiniere ‚/app‘ als das work directory
RUN pip install –upgrade pipFü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 psLaufende 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 psLaufende Containers auflisten (z.B. Id)
docker ps -aIn Docker existierende Container auflisten.
docker stop <containerId>
docker container rm <containerId>Einen Container von Docker entfernen.
docker image lsImages listen (die Docker kennt)
docker image rm <imageId>Image entfernen (aus der Liste der Images, die Docker kennt)

Hinterlasse einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.