Leitfaden-docker

Aufgabensammlung – Docker Container Grundlagen (Linux)

Kapitel 0 - Vorbereitung im Docker.hub

Besuchen Sie die Webseite https://hub.docker.com
Klicken Sie oben rechts im Eck auf Sign up und erstellen Sie sich ein Konto im Docker Hub
Der Username wird später als ihre Docker-ID dienen

Kapitel 1 – Installation von Docker auf Linux

Öffnen Sie ein Terminal.
Aktualisieren Sie Ihre Paketquellen:

sudo apt update
sudo apt upgrade

Installieren Sie Docker:

sudo apt install docker.io

Starten Sie den Docker-Dienst:

sudo systemctl start docker
sudo systemctl enable docker

Prüfen Sie die Docker-Installation, indem Sie den Befehl „docker“ ausführen. Es sollten verschiedene Docker-Befehle angezeigt werden.
Überprüfen Sie die Docker-Version:

docker version

Frage: Was sehen Sie als Ausgabe?

Kapitel 2 – Ausführen des ersten „Hello World“ Containers

Führen Sie im Terminal den folgenden Befehl aus:

sudo docker run hello-world

Erklärung: Docker sucht lokal nach dem „hello-world“ Image. Da es nicht vorhanden ist, lädt Docker es vom Docker-Hub herunter und führt es aus. Es sollte eine Nachricht erscheinen, die bestätigt, dass Docker korrekt installiert ist.

Listen Sie die vorhandenen Images auf:

docker image ls

Frage: Was können Sie sehen?

Verwenden Sie „docker help <OPTION>“ für weitere Informationen, z.B. „docker help run“.

Kapitel 3 – Das Docker Hub

Besuchen Sie Docker Hub.
Suchen Sie nach dem Image „hello-world“ und sehen Sie sich die Details an.

Tipp: Sie können die Suche auch im Terminal durchführen:

docker search hello-world

Kapitel 3.1 – Arbeiten mit Image-Versionen

Suchen Sie auf Docker Hub nach dem „Ubuntu“-Image und wechseln Sie auf die Registerkarte „Tags“ (zeigt die verfügbaren Versionen).
Laden Sie die Version „ubuntu:xenial“ herunter:

sudo docker pull ubuntu:xenial

Starten Sie einen Container:

sudo docker run -t -d --name ubuntu-xenial ubuntu:xenial

Erklärung:: sudo -> Zum ausführen als root; docker run -> Startet einen neuen Container; -t -> Erstellt ein Pseudo-TTY für Standardausgabe und -eingabe; -d -> Startet den Container im Hintergrund; --name ubuntu-xenial Verleiht dem Container einen Namen. (Einfache für die Handhabung); ubuntu:xenial -> Gibt an welches Image und welcher Tag der Container verwenden soll

Listen Sie die laufenden Container auf:

docker ps
docker container ls

Greifen Sie mit einer Bash-Shell auf den Container zu:

sudo docker exec -it ubuntu-xenial /bin/bash

Erklärung:: sudo -> Zum ausführen des Befehls als root; docker exec -> Führt einen Befehl in einem Container aus; -i -> (interactive) Ermöglicht die Interaktion mit der Standardeingabe (STDIN) des Containers; -t -> Erstellt ein Pseudo-TTY für Standardausgabe und -eingabe; ubuntu-xenial -> Der Name des Containers in dem der Befehl ausgeführt werden soll; /bin/bash -> Der Befehl der ausgeführt wird. In diesem Fall wird eine Bash-Shell geöffnet

Prüfen Sie die Umgebung: Geben Sie den Befehl „cat /etc/issue“ ein.

Verlassen Sie die Bash-Shell des Containers mit „exit“.

Kapitel 3.2 – Transferaufgabe

Starten Sie einen Container mit „Debian Bullseye“, benennen Sie ihn und führen Sie „cat /etc/issue“ aus.
Informieren Sie Ihren Dozenten bei erfolgreicher Ausführung.

Kapitel 4 – Ein Image selbst bauen

Erstellen Sie einen Ordner für den Build-Kontext:

mkdir -p /mnt/mein-image
cd /mnt/mein-image

Erstellen Sie eine „hello.sh“-Datei:

nano hello.sh

Inhalt:

#!/bin/bash
echo Hallo *Ihr Name*

Erstellen Sie eine „Dockerfile“-Datei:

nano Dockerfile

Inhalt:

FROM ubuntu:latest
COPY hello.sh .
RUN chmod +x ./hello.sh
CMD ["/hello.sh"]

Bauen Sie das Image:

sudo docker build -t <Ihr Docker_ID>/<Image Name>:v1.0 .

Testen Sie das Image:

sudo docker run -i -t <Ihr Docker_ID>/<Image Name>:v1.0

Kapitel 4.1 – Transferaufgabe

Aufgabe 1: Passen Sie „hello.sh“ so an, dass das Skript nach einem Namen fragt und eine persönliche Begrüßung ausgibt. Nennen Sie das Image <Ihr Docker_ID>/<Image Name>:v2.0
Aufgabe 2: Erweitern Sie das Skript so, dass es wiederholt nach einem Namen fragt, bis „quit“ eingegeben wird. Nennen Sie das Image <Ihr Docker_ID>/<Image Name>:v3.0 und anschließend nochmal mit dem Namen <Ihr Docker_ID>/<Image Name>

Kapitel 4.2 – Docker Image Management im Docker Hub

Melden Sie sich beim Docker Hub an:

docker login

Laden Sie Ihr Images hoch:

docker push <Ihr Docker_ID>/<Image Name>:v1.0
docker push <Ihr Docker_ID>/<Image Name>:v2.0
docker push <Ihr Docker_ID>/<Image Name>:v3.0
docker push <Ihr Docker_ID>/<Image Name>

Überprüfen Sie Ihr Repository auf Docker Hub.

Kapitel 4.3 – Docker Container Management – Starten und Beenden

Starten Sie einen Container im „detached“-Modus.
Beenden Sie den Container:

docker stop <Container Name>

Nutzen Sie „docker container ls -a“, um alle Container zu sehen.
Anschließend nutzen Sie "docker ps"
Beenden Sie den Container mit:

docker kill <Container Name>

Verwenden Sie "docker top <Container Name> um sich die laufenden Prozesse eines Containers anzeigen zu lassen

Kapitel 5 – Einen Webserver mit NGINX erstellen

Führen sie den Befehl docker run --name test-nginx -d -p 8080:80 nginx durch
Überprüfen Sie ob der Container läuft -> docker container ls
Rufen Sie im Browser die Seite http://<IP-des-Linux-Servers>:8080
Stoppen Sie den Container wieder

Kapitel 5.1 - Einen personalisierten Webserver erstellen

Erstellen Sie einen Ordner mit einem Unterordner „html“ mkdir -p /mnt/mein-nginx/html
Legen Sie eine „index.html“ mit folgendem Inhalt in den „html“-Ordner vi index.html:

<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Webserver mit Docker</title>
</head>
<body>
    <h1>Herzlichen Glückwunsch!</h1>
    <p>Sie haben Ihren ersten Webserver mit Docker erstellt!</p>
</body>
</html>

Gehen Sie in den Ordner cd /mnt/mein-nginx/
Erstellen Sie nun ein Dockerfile mit folgendem Inhalt:

FROM nginx:latest
COPY html /usr/share/nginx/html

Bauen Sie ihr neues Images docker build -t <Docker_ID>/hello-web .
Starten Sie den Container docker run --name hello-web -d -p 8080:80 <Docker_ID>/hello-web
Öffnen Sie http://<IP-des-Linux-Servers>:8080 in Ihrem Browser.

Kapitel 5.2 - Eine PHP Website erstellen

Nun erstellen wir eine umfangreichere Website, die später für eine weitere Aufgabe benötigt wird.
Erstelle den neuen Ordner Pfad mkdir -p /mnt/telefon-app/src
Wechseln in das Verzeichnis cd /mnt/telefon-app
Erstellen der Dockerfile: vi dockerfile
- Inhalt:

FROM php:7.2-apache
COPY src/ /var/www/html/

Und nun noch die index.php unter vi src/index.php

<!DOCTYPE html>
<html lang="de">
<head>
        <title> Telefon Liste PHP </title>
</head>
<body bgcolor="lightgreen">
 <h1>Telefonnummer Suche</h1>

<?php
if(!isset($_GET['surname']))
{
        $currentName= "";
}
else
{
        $currentName = $_GET[ 'surname'];
}
if($currentName != "")
{
        if(checkName($currentName))
        {
                echo "Der Name ". $currentName . " wurde gefunden";
        }
        else
        {
                echo "Unbekannter Name: ". $currentName;
        }
}
function checkName($userName)
{
        $userList = array(      "Hannes" =>     "089/73227",
                                "Heidi" =>      "089/73226",
                                "Philipp" =>    "099/5755",
                                "Paul" =>       "099/12345"
                                );
        if (array_key_exists($userName, $userList))
        {
                echo "<p>Name: $userName, Tel: $userList[$userName]</p>";
                return true;
        }
        return false;
}
?>

<form action="index.php" method="get">
    <p>Geben Sie einen Namen ein:
    <input type="text" name="surname"> </p>

    <p>
    <input type="submit" value="Suchen">
    </p>
</form>

</body>
</html>

Nun den Container zusammenbauen docker build -t <Docker_ID>/telefon-app .
Anschließend den Container starten docker run --name telefon-app -d -p 8808:80 <Docker_ID>/telefon-app
Besuchen Sie die Website: http://<IP-des-Linux-Servers>:8808
- Tippen Sie in die Leiste den Namen "Heidi" ein und einmal den Namen "Tim"
Pushen Sie nun ihr Image in ihren Docker Hub Account

Kapitel 6 - Installation von Visual-Studio Code

Besuche https://code.visualstudio.com und klicke auf Download for Windows
Anschließend installieren Sie die .exe
Nun installieren wir weitere Extensions um die Nutzung von VSC zu verbessern
- Dafür im VSC in der linken Seite auf den Extensions Button klicken (4 kleine Vierecke)
- Nun die Extensions "Docker", "Docker Compose", "Remote - SSH" installieren
Verbinden Sie nun ihren Linux Server mit der VSC Instanz mittels SSH

Kapitel 7 – Docker Volumes erstellen und einbinden

Erstellen Sie ein Volume:

docker volume create test-volume

Starten Sie einen Container und binden Sie das Volume ein:

docker run -i -t --name=vol-test --mount source=test-volume,destination=/test_data ubuntu /bin/bash

Erstellen Sie die Datei „hello.txt“ im „/test_data“ Verzeichnis und überprüfen Sie den Inhalt:

echo "Hello World" > /test_data/hello.txt
cat /test_data/hello.txt

Starten Sie einen weiteren Container und binden Sie das Volume erneut ein:

docker run -i -t --name=vol-test2 -v test-volume:/test_data ubuntu /bin/bash

Rufen Sie wieder folgenden Befehl auf:

cat /test_data/hello.txt

Was stellen Sie fest?

Führen Sie nun folgenden Befehl durch um eine detaillierte Information über das volume zu bekommen:

docker volume inspect test-vol

Kapitel 7.1 – Docker Volumes entfernen

Um das Volume zu entfernen müssen Sie erstmal alle container Entfernen die dieses Volume benutzen:

docker rm vol-test
docker rm vol-test2

Entfernen Sie nun das Volume:

docker volume rm test-volume

Kapitel 7.2 – Docker Volumes - zum live bearbeiten von Dateien

Führen Sie folgenden Befehl durch docker run --name telefon-app -d -p 8808:80 -v /mnt/telefon-app/src:/var/www/html <Docker_ID>/telefon-app
- Anmerkung: Dadurch exposen wir die index.php nach außen und können die Seite im Live Betrieb ändern.
Rufen Sie zunächst ihre Website auf http://<IP-des-Linux-Servers>:8808
Bearbeiten Sie nun die index.php vi /mnt/telefon-app/src/index.php und ändern Sie folgenden Wert in der Zeile 6:

 
<body bgcolor="lightgreen">

ändern zu:

<body bgcolor="yellow">

Aktualisieren Sie nun ihren Webbrowser

Kapitel 8 - Docker Logs

Für ein Debugging von Containern wird auf die Docker Logs zurückgegriffen.
Schauen Sie sich ihre Log Einträge des telefon-app Containers an: docker logs telefon-app
Weitere Optionen
- --details: Anzeigen weiterer Details des Logs
- --tail <Anzahl>: Zeigt die letzten X Zeilen des Logs an
- --timestamp: liefert einen Zeitstempel mit
Um das Log Live zu betrachten führen Sie nun den Befehl: docker logs telefon-app -f aus
Suchen Sie in der Telefonnummer Suche nun nach einem Namen (In der Website des Containers) und beobachten Sie gleichzeitig ihr Log

Kapitel 9 - Netzwerke und Docker

Aufgabe: Erstellen Sie ein einen neuen Container mit dem Image "alpine" und achten Sie darauf das die "Ash" Shell ausgeführt wird und der Container im Hintergrund gestartet. Der Container soll im Netzwerk "demo-net" agieren.

Erstellen eines neuen Netzwerkes = docker network create demo-net
Führen Sie nun den Container mit den obigen Anforderungen aus. Die Option um ein Container einem Netzwerk zuzuweisen ist --network demo-net.
Lösung:

docker run -dit --name my-alpine --network demo-net alpine ash

Kapitel 9.1 - Weitere Netzwerkaufgaben

Aufgabe: Erstellen Sie einen weiteren Container mit dem Image "nginx" und fügen Sie diesen ebenfalls in das Netzwerk demo-net. Finden Sie nun raus welche IP-Adresse der Nginx Container bekommen hat

Lösung zum erstellen des Containers:

Starten des Containers: "docker run -dit --name nginx --network demo-net nginx"
Lösung für die Ermittlung der IP:

docker network inspect demo-net

Aufgabe: Verbinden Sie sich mit der STDIN & STDOUT des my-alpine Containers und führen Sie von dort fünf Pings auf den nginx Rechner durch.

Lösung für das Verbinden auf den my-alpine container:

docker attach my-alpine
Lösung für die Pings:

ping -c 5 <IP-des-nginx-Containers> (Statt der IP können Sie auch den Namen des Containers verwenden, da Docker einen internen DNS-Dienst bietet

Kapitel 10 - Erstellen einer Multi-Container-Umgebung

Beenden Sie zunächst alle laufenden Container die ihnen mit docker container ls angezeigt werden.
Aufgabe: Erstellen einer Wordpress Instanz mit einer angebunden Datenbank.

Herunterladen der Images docker image pull mysql:5.7 & docker image pull wordpress:latest
Erstellen eines Volumens damit die Daten nicht bei neustart verschwinden: docker volume create database-data
Erstellen eines gemeinsamen Netzwerkes für beide Container: docker network create wordpress-net
Erstellen des Datenbank Containers: docker container run -d --name database -e MYSQL_ROOT_PASSWORD=Passw0rd -e MYSQL_DATABASE=wordpress -e MYSQL_USER=wordpress -e MYSQL_PASSWORD=Passw0rd --network wordpress-net -v database-data:/var/lib/mysql mysql:5.7
Erstellen des Wordpress Containers: docker container run -d --name wordpress -e WORDPRESS_DB_HOST=database:3306 -e WORDPRESS_DB_USER=wordpress -e WORDPRESS_DB_PASSWORD=Passw0rd -e WORDPRESS_DB_NAME=wordpress --link database:database --network wordpress-net -v /mnt/wordpress:/var/www -p 8080:80 wordpress:latest
Besuchen sie die Seite http://<Die-Linux-Server-IP>:8080
Wordpress Installation durchführen.

Kapitel 10.1 - Entfernen der Multi-Container-Umgebung

Aufgabe: Entfernen Sie nun die gesamte Umgebung wieder.

docker stop database wordpress
docker rm database wordpress
docker volume rm database-data
docker network rm wordpress-net

Kapitel 11 - Docker-Compose

Installiere Docker-Compose apt install docker-compose

Kapitel 12 - Wordpress in Docker-Compose

Aufgabe: Erstellen der Multi-Container-Umgebung von Wordpress und mysql in Docker-Compose

Erstellen eines Wordpress Directorys: mkdir -p /mnt/wordpress
Wechseln in das Verzeichnis: cd /mnt/wordpress
Erstellen der docker-compose.yml: vi docker-compose.yml

version: "3.7"
services:
  database:
    image: mysql:5.7
    volumes:
      - database-data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: Passw0rd
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: Passw0rd

  wordpress:
    image: wordpress:latest
    depends_on:
      - database
    ports:
      - 8080:80
    restart: always
    environment:
      WORDPRESS_DB_HOST: database:3306   
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: Passw0rd
    volumes:
      - .wordpress/plugins:/var/www/html/wp-content/plugins
      - .wordpress/themes:/var/www/html/wp-content/themes
      - .wordpress/uploads:/var/www/html/wp-content/uploads

volumes:
  database-data:

Docker Aufgabensammlung - linux

Inhaltsverzeichnis