Lokaler Chatserver

Für das starten eines lokalen Chat-servers, benötigen wir eine `docker-compose.yml`, als Applikation verwenden wir in dem Falle den Chat-Dienst m1k10 aus dessen Github-Projekt.

Wie im Github Projekt erwähnt kann der Dienst Docker gestartet werden.

version: '3.8'
services:
  chat:
    container_name: chat-server
    image: m1k1o/chat:latest
    restart: unless-stopped
    ports:
      - 8082:80

Wir haben noch einige Ergänzungen an der Standard `docker-compose.yml` getätigt.

• external Port auf 8082 geändert
• Wenn nichts angegeben wird, wird der HOST-Port `8082` freigegeben, d.h jeder im gleichen Netzwerk kann den Service nun erreichen. Möchte man das verhindern und den Server nur lokal testen, kann die Freigabe auch so ausschauen `- 127.0.0.1:8082:80`. Dadurch ist der Service nur lokal über <http://localhost:8082> erreichbar.
• Container Namen vergeben: via `container_name` kann ein Name für den Container festgelegt werden. Ansonsten wird meist ein zufällig generierter Name bzw. der Name des Ordners/Dienstes als Containername festgelegt.

Drawio

Drawio ist ein Service um Zeichnungen und Diagramme erstellen zu können.

version: '3.5'
services:
  drawio:
    image: jgraph/drawio
    container_name: drawio
    restart: unless-stopped
    ports:
      - 8081:8080
      #- 8443:8443
    #environment:
    #  PUBLIC_DNS: domain
    #  ORGANISATION_UNIT: unit
    #  ORGANISATION: org
    #  CITY: city
    #  STATE: state
    #  COUNTRY_CODE: country
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://domain:8080 || exit 1"]
      interval: 1m30s
      timeout: 10s
      retries: 5
      start_period: 10s

• Wir legen den Containernamen `drawio` fest.

• Wir setzen die restart-policy auf `unless-stopped` hierdurch startet der Container von selbst neu, falls er abstürzen sollte. Notfalls kann dies deaktiviert werden, falls es Probleme verursacht.

• Als Enviroment-Variablen könnten wir wir Parameter für ein self-signed Zertifikat festlegen (falls gewünscht).

• Via Healthcheck können wir prüfen ob der Container auch wirklich läuft, falls nicht wird dieser neu gestartet.

Homeassistant

Homeassistant ist eine selfhosted Hausautomatisation.

version: '3'
services:
  homeassistant:
    container_name: homeassistant
    image: "ghcr.io/home-assistant/home-assistant:stable"
    volumes:
      - ./config:/config
      - /etc/localtime:/etc/localtime:ro
      - ./run/dbus:/run/dbus:ro
    restart: unless-stopped
    privileged: true
    ports:
      - 8084:8123
    network_mode: host

• Wir legen den Containernamen `homeassistant` fest.

• Wir setzen die restart-policy auf `unless-stopped`. Hierdurch startet der Container von selbst neu, falls er abstürzen sollte. Notfalls kann dies deaktiviert werden falls es Probleme verursacht.

• Wir mounten lokale Verzeichnisse, um die Daten zu persistieren.

• Wir geben den Port mit `8084` nach extern frei und setzen den Netzwerkmode auf `host`.

• Wir setzen den Container in den `priviliged` mode, dies ist nötig um USB-Geräte etc. im Container erreichbar zu machen. Der priviliged-mode ermöglicht es den Container mehr oder weniger als `root` User zu arbeiten.

Nginx

NGINX ist ein Open-Source Webserver.

FROM nginx:latest
COPY ./index.html /usr/share/nginx/html/index.html
COPY ./simple.gif /usr/share/nginx/html/simple.gif
EXPOSE 80

• Wir bauen uns einen eigenen Nginx-Docker-Container, den Inhalt der Angeboten index.html überschreiben wir via `COPY` in das Container-Verzeichnis `/usr/share/nginx/html/index.html`. Zur Vereinfachung legen wir die verwendete `.gif` Datei neben die `index.html`. Anschließend legen wir noch den Port via `EXPOSE` mit Port `80` fest.

• Wir bauen das Docker-Image via

docker build -t nginx:customimage .

• Anschließend können wir den Container wie gewohnt mit einer `docker-compose.yml` starten.

version: '3'

services:
  web:
    container_name: web
    image: nginx:customimag
    restart: unless-stopped
    ports:
      - "8080:80"

Falls wir trotzdem noch weitere Dateien hinzufügen möchten, könnten wir eine Volume via `volume:` mounten und die `index.html` sowie weitere Dateien hinzufügen.

Postgres-DB

Postgres ist eine Opensource-Datenbank. Hierzu haben wir noch pgadmin hinzugefügt, welches eine Webui für die Datenbank bereitstellt.

version: '3.9'

services:
  postgres:
    container_name: postgres-db
    image: postgres:14-alpine
    ports:
      - 5432:5432
    volumes:
      - ./postgres:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=S3cret
      - POSTGRES_USER=indibit-user
      - POSTGRES_DB=indibit-db
  pgadmin:
    image: dpage/pgadmin4
    container_name: postgres-pgadmin
    restart: unless-stopped
    ports:
      - "8888:80"
    environment:
      PGADMIN_DEFAULT_EMAIL: admin@indibit.eu
      PGADMIN_DEFAULT_PASSWORD: strong-s3cret-password
    volumes:
      - ./pgadmin-data:/var/lib/pgadmin

• Wir setzen die Containernamen: `postgres-db` und `postgres-pgadmin`

• Wir mounten die Lokalen Verzeichnisse: `- ./postgres:/var/lib/postgresql/data` und `- ./pgadmin-data:/var/lib/pgadmin`.

• Wir setzen die Datenbank/Login-Passwörter via Enviroment-Variablen.

• Per Portfreigaben geben wir die Datenbank über den Default-Postgres Port `5432` frei, sowie das Webinterface auf den externen Port `8888`.

posio

Posio ist ein Städte-Rate-Spiel, bei der ein Nutzer Städte auf der Welt möglichst Präzise bestimmen muss.

FROM python:3.9-slim
WORKDIR /app
COPY /posio /app
RUN pip install -r /app/requirements.txt
EXPOSE 5000
ENV FLASK_APP=/app/posio
CMD [ "flask", "run", "--host=0.0.0.0"]

Erklärung der Dockerfile

Wir starten mit dem Basis-Image `python:3.9-slim`, legen das `WORKDIR` nach `/app` fest. Anschließend kopieren wir den lokalen Ordner (den Gitprojektordner) `posio` in den Containerpfad `/app`. Danach installieren wir die für den Service nötigen Python Abhängigkeiten, welche in der `requirements.txt` festlegt sind. Der Container soll wie das Original-Projekt per Port `5000` erreichbar sein, das geben wir mit `EXPOSE` an. Wir setzen eine Enviromentvariable mit `ENV` mit den Variablennamen `FLASK_APP` und den dazugehörigen Wert `/app/posio` um Flask den Projektordner zu „zeigen“. Per `CMD` starten wir nun die Applikation.

• Wir erstellen uns hierzu eine Dockerfile um das Github Projekt als Docker-Container lauffähig machen zu können. Hierzu klonen wir das github repo per

git clone https://github.com/abrenaut/posio.git

• in den lokalen Projektordner. Die Dockerfile sollte in diesem Falle neben den git-Projektordner liegen.

./posio
├── Dockerfile
└── posio
    ├── LICENSE.txt
    ├── README.md
    ├── data
    │   └── cities.db
    ├── infrastructure
    │   └── ansible
    ├── posio
    │   ├── __init__.py
    │   ├── config.py
    │   ├── game.py
    │   ├── game_master.py
    │   ├── static
    │   ├── templates
    │   └── views.py
    ├── requirements.txt
    ├── screenshot.png
    └── tests
        └── test_game.py

• Wir bauen das Docker-Image via

docker build -t myownposio:latest .

• Anschließend können wir den Container wie gewohnt mit einer `docker-compose.yml` starten.

version: '3.8'
services:
  posio:
    container_name: posio
    image: myownposio:latest
    restart: unless-stopped
    ports:
      - 8080:5000

Wir setzen den Containernamen auf `posio`, verwenden als Image unser eigenes lokal gebautes Image `myownposio:latest`. Anschließend setzen wir noch die restart policy auf `unless-stopped` um einen automatischen neustart bei einen möglichen Applikationsfehler auszuführen. Als Port geben wir nach extern `8080` frei, nämlich in Richtung des festgelegten internen Container-Ports `5000`.