# Tutorial Container 
% ASE WS 2022/23

In diesem Tutorial werden wir:

* die Grundlagen von Containern wiederholen
* die beiden wichtigsten Container-Plattformen, Docker und Podman, anschauen
* mit verschiedenen Quellen für Images arbeiten 
* Images mit Dockerfiles selbst bauen
* mit docker-compose mehrere zusammenhängende Container starten und überwachen
* die Integration von Docker/Podman in CI/CD-Workflows mit Gitlab/GitHub anschauen

**Achtung:** Dieses Dokument unterstützt lediglich die Übung und ist keine vollständige Anleitung

## Setup

Wir arbeiten dieses Mal mit einer lokalen Docker/Podman-Installation 
Alternativ kann man sich auch wie beim letzten Mal als Nutzer `root` auf einem 'disposable root server' [via segfault.net](https://blog.thc.org/disposable-root-servers) einloggen.

  ssh root@segfault.net # Password is 'segfault'
  
**Achtung:** Der Server ist nicht sicher - keine vertraulichen Infos/Passwörter dort eintippen

Oder: ich richte einen Account auf unserem Projektserver ein (bitte melden)

## Docker und Podman

[Docker](https://docker.io/) und [Podman](https://podman.io/) sind beides Tools zur Erstellung, Ausführung und Verwaltung von Containern. 
Sie ermöglichen es, Anwendungen und deren Abhängigkeiten in isolierten Umgebungen auszuführen, ohne dass sie sich gegenseitig beeinflussen.

### Docker
Docker ist das am weitesten verbreitete Container-Management-System. Es nutzt eine daemonbasierte Architektur, bei der der Docker-Daemon auf dem Host-System läuft und die Container verwaltet. Docker erfordert Root-Rechte, um den Daemon auszuführen. 

Die einfachste Art, Docker unter Windows und macOS zu installieren, ist [Docker Desktop](https://www.docker.com/products/docker-desktop/)

Unter Linux: Installation über Paketmanager (apt install docker)

### Podman
Podman ist ein neueres, von Redhat entwickeltes Tool, das eine ähnliche Funktionalität wie Docker bietet, aber ohne die Verwendung eines Daemons auskommt. Es ermöglicht es, Container als normale Benutzer auszuführen und erfordert keine Root-Rechte.

Installation auf verschiedenen Betriebssystemen am einfachsten über [Podman Desktop](https://podman-desktop.io/) oder:

* Windows: https://www.redhat.com/sysadmin/run-podman-windows
* macOS via [Homebrew](https://brew.sh/): brew install podman.
* Linux: apt install podman

Podman speichert Images und Container-Konfiguration im Verzeichnis /var/lib/containers wenn es als Root gestartet wird. Für normale User landen die Images unter $HOME/. local/share/containers/storage/ (spezifiziert durch Open Container Initiative (OCI)).

## Aufgabe 1 - Container starten

(in allen Beispielen kann man docker auch durch podman ersetzen)

* Installiere Docker und/oder Podman
* Starte einen neuen Docker-Container: `docker run -it --name mein_test debian /bin/bash`
* Installiere in diesem Container ein Paket (z.B. `python3`) und logge dich aus
* starte den Container erneut - ist das Paket noch installiert?
* zeige mit `docker --help` die Hilde zu allen Befehlen an. 
* erzeuge einen neuen Docker-Container "mein_test_2" mit `docker create`
* starte den Container mit `docker start`
* Schaue nach, ob der Container auch läuft mit `docker ps`
* Starte eine Shell in diesem Container mit `docker exec mein_test  -sh /bin/bash`

## Dockerfiles

Ein Dockerfile erlaubt es, ein eigenes Image zu generieren und diesem Dateien und Befehle hinzuzufügen:

    # Use the official Debian image as the base image
    FROM debian:latest
    
    # Update the package list and install additional packages
    RUN apt-get update && apt-get install -y \
        package1 \
        package2 \
        package3
    
    # Add any necessary configuration files
    COPY config_file1 /etc/config_file1
    COPY config_file2 /etc/config_file2
    
    # Set the working directory
    WORKDIR /app
    
    # Add any necessary files or scripts
    COPY script1.sh /app/script1.sh
    COPY script2.sh /app/script2.sh
    
    # Set the entrypoint
    ENTRYPOINT ["/app/script1.sh"]

Mittels `docker build` erzeugt man aus der Datei `Dockerfile` ein Image

[Dockerfile-Referenz](https://docs.docker.com/engine/reference/builder/)

## Aufgabe 2

Erstellen eine Dockerfile, das einen simplen Webserver startet:

* in einem Verzeichnis /srv/www liegen einige hübsche Bilder
* eine Python-Installation ist vorhanden
* ein Start-Script startet einen Webserver, der die Dateien aus dem Verzeichnis bereitstellt (`python -m http.server`)

**Tipp:** damit man vom Host aus auf den Webserver im Container zugreifen kann, muss man die Container-Ports auf Host-Ports mappen ([`-p 8000:8080`](https://docs.docker.com/config/containers/container-networking/))

## docker-compose

docker-compose verwendet die Spezifikation in einer YAML-Datei um mehrere Container gemeinsam zu konfigurieren und zu administrieren.

* separat zu installieren: `apt install docker-compose`
* `docker-compose up -d` (starte alle Services und 'detache' vom Output)
* `docker-compose down` 
* `docker-compose logs -f` (zeige die Log-Ausgaben der Container an)
* `docker-compose scale` erlaubt es, weitere Container für einen Dienst bereitzustellen

Beispiel-Konfiguration: [WikiBase Docker images](https://github.com/wmde/wikibase-release-pipeline/tree/wmde.10/example)


## Aufgabe 3

Erstelle eine Datei `docker-compose.yml`, die den Server aus Aufgabe 2 baut, startet und auf Port 1234 des Hosts antworten lässt.


## Docker-Integration in Gitlab und GitHub

* https://docs.docker.com/build/ci/
* https://www.digitalocean.com/community/tutorials/how-to-set-up-a-continuous-deployment-pipeline-with-gitlab-ci-cd-on-ubuntu-18-04