# Lern- und Arbeitsaufgabe: Virtualisierung technischer Lernumgebungen für kompetenzorientierte Prüfungsszenarien

## Didaktisches Szenario für die Fortbildung

Für das kompetenzorientierte Prüfen Ihrer Klasse stellen Sie das Gerüst einer Anwendung bereit. Diese soll von den Schülerinnen und Schülern (SuS) weiter ausgearbeitet werden. Damit alle SuS dieselbe Ausgangsbasis haben, stellen Sie eine `docker-compose.yml`-Datei zur Verfügung. Damit zieht jedeR SuS eine frische Arbeitsumgebung hoch.[^5].

[^5]: Es ließe sich einwenden, dass an dieser Stelle manipuliert werden kann, bspw. indem die SuS die `docker-compose.yml` nach dem Herunterladen modifizieren. Eine andere Möglichkeit wäre demzufolge, nicht die `docker-compose.yml` in der Prüfung zu verwenden, sondern ein siginiertes Docker Image bereitzustellen.

Für die Docker-Fortbildung verwenden wir exemplarisch [Python Django](https://www.djangoproject.com/) und stellen uns vor, dass die SuS damit eine Aufgabe lösen. Bei Django handelt es sich um ein weit verbreitetes Webentwicklungsframework, das an verschiedene Datenbankmanagementsysteme angebunden werden kann. Natürlich funktioniert dieses Szenario auch mit ganz anderen Beispielen.

## Vorbereitung und Ablauf der Prüfung

Die folgende Abbildung zeigt die Vorbereitung und Durchführung der Prüfung im Ablauf:

sequenceDiagram
    Note left of GitLab: Vorbereitungen
    Lehrkraft->>GitLab: Lehrkraft stellt Images bzw. Dockerfile bereit (Repo: DI)
    Lehrkraft->>GitLab: Lehrkraft stellt docker-compose.yml bereit (Repo: DI)
    Lehrkraft->>GitLab: Lehrkraft stellt rudimentären Anwendungscode bereit (Repo: BA)
    Note left of GitLab: Beginn der Prüfung
    Lernende->>GitLab: Lernende forken BA
    GitLab->>Lernende: Lernende klonen BA[Fork] und DI ihren Rechner
    Lernende->>Lernende: Lernende ziehen Container mit docker-compose hoch
    Note left of GitLab: Sicherung der Prüfungsergebnisse
    Lernende->>GitLab: Lernende pushen Code aus Prüfung in BA[Fork]
    Note left of GitLab: Ende der Prüfung

**Abb.:** DI steht für das Repository mit dem Docker Image bzw. Dockerfile, [BA](https://collaborating.tuhh.de/transferworkshops/app_virtualization_with_docker/django-basisanwendung) steht für Basisanwendung.

## Aufgabenstellung Lehrkräfte
### Softwareanwendung entwickeln und bereitstellen

Für diese Lernaufgabe steht unter https://collaborating.tuhh.de/itbh/transferworkshops/app_virtualization_with_docker/django-basisanwendung eine entsprechende Anwendung zur Verfügung. Sie kann der Einfachheit halber für die Fortbildung genutzt werden.

- Überlegen Sie gemeinsam, welche Vorbereitungen für die Prüfung notwendig sind. Welche (technischen) Rahmenbedingungen müssen für die SuS gegeben sein (Zugänge, Accounts etc.)?
- Entwickeln bzw. verwenden Sie für die Prüfung eine Softwareanwendung (hier: Django), zu der die Aufgaben für die SuS gestellt werden.
- Stellen Sie die Basisanwendung auf Git[Hub|Lab] den SuS zur Verfügung (hier nicht notwendig).

### Dockerfile schreiben und ausprobieren

- Klonen Sie die Basisanwendung [Django Basisanwendung](https://collaborating.tuhh.de/itbh/transferworkshops/app_virtualization_with_docker/django-basisanwendung) aus GitLab auf Ihren Arbeitsplatzrechner.

  git clone https://collaborating.tuhh.de/itbh/transferworkshops/app_virtualization_with_docker/django-basisanwendung.git

- Schreiben Sie die Datei `Dockerfile` für die Prüfungsanwendung *neben* dem geclonten Ordner. Ein funktionierendes Beispiel finden Sie [auf GitLab](https://collaborating.tuhh.de/itbh/transferworkshops/app_virtualization_with_docker/django_image).
- Legen Sie, wenn nötig, noch eine Datei `requirements.txt` neben dem `Dockerfile` mit folgendem Inhalt an:

  Django~=2.0

Ihr Dateibaum könnte nun wie folgt aussehen:

  ├── django-basisanwendung
  │   ├── db.sqlite3
  │   ├── django-basisanwendung
  │   ├── hello
  │   ├── manage.py
  │   ├── README.md
  │   └── web_project
  ├── Dockerfile
  └── requirements.txt

- Bauen Sie zum Überprüfen das **Image** auf Ihrem eigenen Arbeitsrechner.
- Starten Sie einen **Container** auf dem Image mit den notwendigen Parametern. Mounten Sie dabei auf jeden Fall das Verzeichnis der Django-Basisanwendung in den Container.
Ein möglicher Befehl könnte der folgende sein:

  docker run --rm -d -v $(pwd)/django-basisanwendung:/usr/src/app -p 8000:8000 [Name des Images]

- Rufen Sie die Webanwendung im Browser mit `http://127.0.0.1:8000` auf.
- Starten Sie Ihren Editor mit dem Verzeichnis der Django Basisanwendung. Ändern Sie in der Datei `/django-basisanwendung/hello/views.py` die Ausgabe im Browser. Kontrollieren Sie die Änderung, indem Sie die Webseite aktualisieren.
- Woran liegt es, dass sich Änderungen auf dem Host sofort im Docker Container abbilden?

### Umgebung mit Docker Compose konfigurieren
Schreiben Sie die Datei `docker-compose.yml` aus folgenden Gründen:
1. Der Start von Containern wird einfacher, da Sie die Parameter der Kommandozeile in einer Datei festlegen können.
2. In der Datei können Sie angeben, mit welchen weiteren Diensten der Container kommunizieren soll. Im Fall von Django wird noch ein Datenbankserver benötigt (hier: MariaDB). Zusätzlich kann (optional) auch ein phpMyAdmin als Container gestartet werden, um die Vorgänge in der Datenbank besser nachvollziehen zu können.
- Prüfen Sie die Syntax Ihrer Datei mit `docker-compose config`. **Beachten Sie bitte, dass Pfade von zu mountenden Volumes ggf. an Ihre Rechnerumgebung angepasst werden müssen!**
- Starten Sie mit Eingabe von `docker-compose up -d` die Containerumgebung.[^6]
- Rufen Sie erneut die Seite im Browser auf.
- Stoppen Sie die Umgebung bei Bedarf mit `docker-compose down` im Verzeichnis der Datei `docker-compose.yml`.
- Veröffentlichen Sie die `docker-compose.yml` auf Git[Hub|Lab] für die SuS in der Prüfung.
- Machen Sie das Repository den SuS zugänglich.

[^6]: Zum Debuggen wird empfohlen, die Umgebung zunächst ohne `-d` zu starten, um mögliche Fehlermeldungen beim Start mitlesen zu können.

## Aufgabenstellung SuS

Die folgenden möglichen Aufgaben richten sich an die SuS in der Prüfung.

### Vorbereitung der Prüfung

1. Starten Sie Ihren Arbeitsplatzrechner.
2. Forken Sie auf Git[Hub|Lab] das Repository [Django Basisanwendung](https://collaborating.tuhh.de/transferworkshops/app_virtualization_with_docker/django-basisanwendung) in Ihren Account.
3. Klonen Sie das Repo auf Ihren Rechner.
4. Klonen Sie [das Repository mit der `docker-compose.yml`](https://collaborating.tuhh.de/itbh/transferworkshops/app_virtualization_with_docker/django_image) auf Ihren Arbeitsrechner. Wechseln Sie auf der Kommandozeile in das Verzeichnis.
5. Passen Sie in der `docker-compose.yml` den Pfad in Zeile 12 an, so dass er Ihrer Rechnerumgebung entspricht!
5. Starten Sie die Prüfungsumgebung mit dem Kommando `docker-compose up -d`.
6. Öffnen Sie Ihren Editor mit dem aktuellen Verzeichnis und beginnen Sie mit den Prüfungsaufgaben.

### Prüfungsaufgaben

Prüfungsaufgaben Können individuell erstellt werden.

###### tags: `wb-hessen`