Spiel mit Docker: Lass Container kostenlos in deinem Browser laufen

Stell dir vor, du kannst einen Docker Swarm-Cluster mit mehreren Knoten in Sekundenschnelle hochfahren, ohne auch nur ein Byte auf deinem Laptop installieren zu müssen. Jahrelang hab ich gesehen, wie Entwickler mit Docker-Installationen rumgeschmissen haben, sich mit Systemabhängigkeiten rumgeschlagen haben, Probleme mit Berechtigungsfehlern gelöst haben und sich Gedanken gemacht haben, ob ihre alte Hardware die Anforderungen an die Ressourcen bewältigen kann. 

Dann habe ich Play with Docker entdeckt, und das hat meine Art, Containerisierung zu lehren und zu lernen, komplett verändert.

Play with Docker ist eine kostenlose, browserbasierte Sandbox, mit der du sofort auf virtuelle Maschinen mit Alpine Linux zugreifen kannst, auf denen du Docker-Container erstellen und ausführen kannst. Egal, ob du ein Junior-Datenpraktiker bist, der gerade mit der Containerisierung anfängt, oder ein erfahrener Profi, der schnell eine neue Docker-Funktion testen will – PWD bietet dir eine leicht zugängliche, risikofreie Umgebung. 

In diesem umfassenden Tutorial zeige ich dir alles, was du wissen musst, von deinem ersten Container bis hin zur Orchestrierung mehrerer Container mit Docker Compose. Am Ende hast du einen containerisierten Webserver, der läuft, ohne dass du deinen Browser verlassen musst.

Wenn du noch nicht mit Docker und seinen Konzepten vertraut bist, empfehle ich dir, unsere Einführungskurs zu Docker zu machen oder dich mit den „Konzepte der Containerisierung und Virtualisierung“.

Was ist „Play With Docker”?

Play with Docker (PWD) ist ein kostenloser, temporärer Docker-Spielplatz, den du direkt in deinem Webbrowser nutzen kannst. PWD wurde von den Docker-Kapitänen Marcos Liljedhal und Jonathan Leibiusky entwickelt, entstand aus einem Hackathon-Projekt und wurde schnell zu einem unverzichtbaren Tool für die Docker-Community.

Im Grunde nutzt PWD die Docker-in-Docker-Technologie (dind), bei der Docker-Container in anderen Docker-Containern laufen. Diese verschachtelte Architektur klingt vielleicht kompliziert, aber sie ermöglicht es dir, mit der vollen Docker-Funktionalität zu experimentieren, einschließlich fortgeschrittener Funktionen wie Multi-Node-Swarm-Clustern, ohne deinen lokalen Rechner zu beeinträchtigen. 

Die Plattform kümmert sich um die ganze Komplexität im Hintergrund und zeigt dir eine übersichtliche Terminaloberfläche. Es bietet Alpine Linux-Instanzen, also leichte Linux-Distributionen, die super für Container-Workloads geeignet sind. Alpine ist bewusst minimalistisch, mit einer Basis-Image-Größe von nur etwa 5 MB im Vergleich zu den über 100 MB von Ubuntu. 

Diese Effizienz sorgt für schnellere Downloads und kürzere Startzeiten. Jede Instanz bietet eine komplette Terminal-Erfahrung und gibt dir die gleiche Befehlszeilenleistung wie bei einer lokalen Installation, einschließlich einer shell, Docker CLI und Docker Compose.

PWD macht die Installation für Anfänger einfacher und bietet Fortgeschrittenen einen Platz, um Orchestrierungsfunktionen wie Docker Swarm auszuprobieren. Du kannst Cluster mit mehreren Knoten erstellen, mit Netzwerkkonfigurationen experimentieren und die Containerplanung testen, ohne dich um die Verwaltung von virtuellen Maschinen oder Cloud-Instanzen kümmern zu müssen.

Mit Docker vs. Docker Desktop spielen

Jetzt, wo du weißt, was PWD so alles kann, fragst du dich bestimmt, wann du es nutzen solltest und wann du lieber Docker Desktop lokal installieren solltest. Wenn du weißt, wann du Play with Docker und wann Docker Desktop nutzen solltest, sparst du Zeit und Nerven.

Play with Docker bietet sofortigen Browserzugriff ohne Installation, ohne lokalen Ressourcenverbrauch und mit voller Docker Swarm-Unterstützung – und das alles komplett kostenlos. Allerdings dauern die Sitzungen nur zwei Stunden, bevor alles gelöscht wird, die Leistung ist eingeschränkt und nach Ablauf der Sitzung gibt's keinen dauerhaften Speicherplatz mehr.

Anmerkung: Die PWD-Dokumentation sagt, dass eine Sitzung vier Stunden dauert, aber als ich es ausprobiert habe, waren es eigentlich nur zwei Stunden. Es sieht so aus, als ob die Dokumentation nicht auf dem neuesten Stand ist.

Docker Desktop läuft direkt auf deinem Rechner und bietet dauerhaften Speicherplatz, bessere Leistung und nahtlose Integration mit Entwicklertools wie Visual Studio Code. Du kannst an langfristigen Projekten arbeiten, ohne dass die Sitzungszeit begrenzt ist.

Wann sollte man Play With Docker verwenden?

Play with Docker ist in folgenden Situationen echt super: 

• Einmalige Tests 
• Nach den Tutorials
• Arbeiten auf Laptops oder Chromebooks mit niedrigen Spezifikationen
• Teile Live-Session-URLs mit deinen Teamkollegen, um Probleme zu beheben oder Sachen vorzuführen.

Wann sollte man Docker Desktop nutzen?

Docker Desktop wird unverzichtbar für 

• Tägliche Entwicklungsarbeit
• IDE-Integration
• Lange Projekte, die Wochen oder Monate dauern
• Ressourcenintensive Aufgaben, die spezielle Netzwerke und Volumes brauchen

Erste Schritte mit Play With Docker

Jetzt, wo du weißt, wann PWD das richtige Tool für deine Bedürfnisse ist, lass uns loslegen und deine erste Sitzung starten.

Einrichten von Play mit Docker

Bevor du loslegst, brauchst du ein Docker Hub-Konto. Schau mal bei Docker Hub, um einen zu erstellen. Wenn du noch keinen hast, gib einfach deine E-Mail-Adresse und dein Passwort ein.

Mit Docker Login spielen

Geh zur Website Website „Play with Docker“ und logg dich mit deinen Docker Hub-Zugangsdaten ein. Klick nach der Anmeldung auf den grünen „Start“-Button, um deine Sitzung zu starten. Innerhalb von Sekunden stellt PWD eine neue Alpine-Linux-Umgebung in deinem Browser bereit, mit einem Countdown-Timer, der die verbleibenden zwei Stunden deiner Sitzung anzeigt.

Navigieren im Dashboard von Play with Docker

Die PWD-Schnittstelle ist einfach, aber echt leistungsstark. Klick auf „Neue Instanz hinzufügen”, um neue Alpine Linux-Container zu erstellen. Du kannst bis zu 5 Instanzen gleichzeitig laufen lassen, um Cluster mit mehreren Knoten zu testen. Das Hauptterminalfenster hat eine komplette Bash-Shell mit vorinstalliertem Docker. 

Behalte den Countdown-Timer im Auge. Wenn es Null erreicht, wird alles gelöscht, ohne dass die Sitzung verlängert werden kann.

Dashboard in Play mit Docker

Tipp: Die Standard- Ctrl+V -Paste-Funktionen funktionieren in PWD oft nicht. Kopier mit „ Ctrl+Insert “ und füge mit „ Shift+Insert “ ein. Probier deine Tastenkombination gleich aus, um Ärger zu vermeiden.

Kernfunktionen von Docker

Jetzt, wo deine PWD-Umgebung fertig ist und du dich mit der Oberfläche auskennst, ist es Zeit, deinen ersten Container zu starten und die wichtigsten Docker-Befehle zu lernen.

Deinen ersten Container starten

Lass uns einen Nginx-Webserver einrichten, um Bilder und Container besser zu verstehen. Mach mal diesen Befehl:

docker run -d -p 80:80 nginx

Das passiert: „ docker run “ erstellt und startet einen neuen Container. Das Flag „ -d “ lässt es im Hintergrund laufen. Die Datei „ -p 80:80 “ ordnet Port 80 auf dem Host Port 80 im Container zu. „ nginx “ ist der Name des Docker-Images.

Stell dir ein Docker-Image wie ein Rezept vor. Das Nginx-Rezept in diesem Fall. Der fertige Behälter ist der Kuchen, den du nach diesem Rezept backst. Du kannst mehrere Kuchen (Behälter) aus einem Rezept (Bild) machen.

So verwaltest du deinen Container:

docker ps              # Show running containers
docker stop <id>       # Stop a container
docker rm <id>         # Remove a stopped container

Du brauchst nur die ersten paar Zeichen der Container-ID. Docker findet raus, was du meinst.

Portweiterleitung in Play mit Docker

Die Portweiterleitung in PWD funktioniert anders als die lokale Portweiterleitung. Wenn du einen Port freigibst, erstellt PWD automatisch eine dynamische URL für den Zugriff.

Nachdem du den Nginx-Container gestartet hast, schau oben auf deinem PWD-Bildschirm unter IP nach. Klick auf „Port öffnen“ und gib „80“ ein. Es öffnet sich ein neuer Browser-Tab mit einer einzigartigen URL wie http://ip-.direct.labs.play-with-docker.com.

Portweiterleitung mit Docker

Du greifst hier nicht auf localhost zu. PWD erstellt spezielle URLs, die den Internetverkehr zu deinem bestimmten Container leiten. Das heißt, du kannst diese URLs mit deinen Kollegen teilen, um ihnen deine Arbeit in Echtzeit zu zeigen.

Fehlersuche und Inspektion

Wenn die Dinge nicht wie erwartet laufen, brauchst du Tools, um zu checken, was in deinen Containern passiert.

Bei der Fehlerbehebung helfen dir diese Befehle, einen Blick in Container zu werfen:

docker logs <container-id>         # View container output
docker ps                          # Show running container status  
docker inspect <container-id>      # Get detailed JSON configuration

Klick auf den Link „Port 80“ und ruf dann docker logs auf. In den Nginx-Zugriffsprotokollen siehst du dann die Anfrage deines Browsers. Dieses Echtzeit-Feedback hilft dir, den Ablauf von Anfragen in deiner Anwendung zu verstehen.

Docker-Protokolle in Aktion mit Docker

Wenn du diese grundlegenden Vorgänge drauf hast, kannst du jetzt über die Ausführung vorgefertigter Images hinausgehen und deine eigenen benutzerdefinierten Container erstellen.

Bilder erstellen und Daten verwalten in Play mit Docker

Nachdem wir jetzt die grundlegenden Container-Operationen behandelt haben, wollen wir uns mit der Erstellung eigener benutzerdefinierter Images beschäftigen. Hier zeigt sich die wahre Stärke von Docker. Die Möglichkeit, deine Anwendungen mit allen ihren Abhängigkeiten in portable, reproduzierbare Images zu packen.

Ein einfaches Dockerfile schreiben

Dockerfiles machen das Erstellen von Images mit Textanweisungen automatisch. Anstatt einen Container jedes Mal manuell einzurichten, schreibst du einfach einmal eine Dockerfile, und Docker kümmert sich um den Rest. 

Erstell eine Dockerfile in Play mit Docker

Erstell zuerst die Dockerfile im Terminal:

touch Dockerfile

Klick dann in PWD auf die Schaltfläche „Editor“ und füge ein einfaches Bild hinzu:

FROM alpine
CMD ["echo", "Hello DataCamp"]

Zum Schluss baust du die Dockerfile und lässt sie laufen. Der Befehl „ -t “ gibt deinem Bild einen Namen (oder „Tag“), damit du es leicht wiederfinden kannst. Der Befehl „ . “ sagt Docker, dass es das aktuelle Verzeichnis als Build-Kontext nehmen soll, also den Ort, wo Docker die Dockerfile und alle anderen benötigten Dateien findet. Du wirst sehen, wie Docker jede Anweisung ausführt und die Layer-IDs ausgibt.

docker build -t my-first-image .
docker run my-first-image

Erstelle ein Docker-Image in Play mit Docker

Du wirst „Hallo DataCamp“ sehen. Herzlichen Glückwunsch! Du hast dein erstes eigenes Bild erstellt! Dieses einfache Beispiel zeigt den grundlegenden Ablauf: Anweisungen schreiben, ein Image erstellen, einen Container ausführen.

Aber es gibt eine wichtige Frage, die wir klären müssen: Was passiert mit deinen Daten, wenn Container nicht mehr laufen oder gelöscht werden?

Datenpersistenz in Play mit Docker

Das Verständnis der Datenpersistenz ist super wichtig, um effektiv mit Containern zu arbeiten. Standardmäßig sind Container so gemacht, dass sie nur kurz existieren: Wenn du einen Container löschst, verschwinden alle Dateiänderungen, alle Datenbankdatensätze und alle Protokolleinträge sofort. 

Das klingt vielleicht kompliziert, ist aber eigentlich eine der wichtigsten Funktionen von Docker. Kurzlebige Container sind einfach zu ersetzen, zu skalieren und zu debuggen, weil sie weggeworfen werden können.

Aber was ist mit den Daten, die du aufbewahren musst? Da kommen Docker-Volumes ins Spiel. Ein Volume ist ein Speicherbereich, der von Docker verwaltet wird und außerhalb des Dateisystems des Containers liegt. Stell dir das wie einen USB-Stick vor, den du in verschiedene Container einstecken kannst. Die Daten bleiben auf dem Laufwerk, auch wenn du es aus einem Container herausnimmst und in einen anderen einsteckst.

Docker-Container vs. Docker-Volume

Ich zeig dir mal, wie das in der Praxis läuft. Erstelle und benutze ein Volume:

docker volume create mydata
docker run -it -v mydata:/data alpine sh

Das Flag „ -v mydata:/data “ hängt das Volume „ mydata “ unter dem Pfad „ /data “ im Container ein. Alles, was auf /data geschrieben wird, wird tatsächlich auf dem Datenträger gespeichert. Mach mal 'ne Testdatei:

echo "This data persists!" > /data/important.txt
echo "Container ID: $(hostname)" >> /data/important.txt
exit

Der Container hat angehalten und ist weg. Jetzt startest du einen komplett neuen Container mit dem gleichen Volumen:

docker run -it -v mydata:/data alpine sh
cat /data/important.txt

Datenpersistenz mit Docker-Volumes

Die Datei ist immer noch da, komplett mit der alten Container-ID! Die Daten sind erhalten geblieben, weil sie im Volume gespeichert waren und nicht im temporären Dateisystem des Containers. Du kannst dieses Volume an so viele Container anschließen, wie du brauchst, und alle sehen dann die gleichen Daten.

Aber, und das ist echt wichtig für PWD-Nutzer, selbst Volumes werden gelöscht, wenn deine zweistündige Sitzung abläuft. Volumes bleiben innerhalb einer Sitzung bestehen, aber nicht über mehrere Sitzungen hinweg. 

Es ist super wichtig, Datenpersistenz zu verstehen, aber die meisten echten Anwendungen haben mehrere miteinander verbundene Dienste. Da kommt Docker Compose unverzichtbar.

Container-Orchestrierung mit Docker Compose

Nachdem wir uns mit einzelnen Containern beschäftigt haben, ist es Zeit, uns mit echten Anwendungen zu beschäftigen, die meistens aus mehr als einem Dienst bestehen. Moderne Anwendungen haben meistens mehrere Teile: ein Web-Frontend, ein API-Backend, eine Datenbank, einen Cache und vielleicht eine Nachrichtenwarteschlange. All diese Teile mit separaten Befehlen wie „ docker run “ zu verwalten, wird zu einem Koordinationsalbtraum.

Warum Docker Compose nutzen?

Stell dir mal folgendes Szenario vor: Du stellst eine Anwendung bereit, die einen Webserver, eine PostgreSQL-Datenbank und einen Redis-Cache braucht. 

Ohne Compose bräuchtest du drei separate Befehle „ docker run “, jeder mit vielen Flags für Netzwerk, Port-Mapping, Volume-Mounting und Umgebungsvariablen. Du musst dir die genaue Reihenfolge merken, in der du sie starten musst (zuerst die Datenbank, dann den Cache, dann den Webserver), und wenn was schiefgeht, wird das Debuggen zu einer Suche durch mehrere Terminalfenster.

Docker Compose löst dieses Problem mit der Orchestrierung auf elegante Weise. Anstatt mehrere Befehle zu jonglieren, legst du deine ganze Multi-Container-Anwendung in einer einzigen YAML-Datei namens „ docker-compose.yml “ fest. Diese Datei ist die einzige zuverlässige Quelle für die Architektur deiner Anwendung und beschreibt alle Dienste, ihre Konfigurationen, wie sie miteinander verbunden sind und welche Volumes sie nutzen.

Mit Compose kannst du deinen ganzen Stack mit einem einzigen Befehl bereitstellen: ` docker-compose up`. Das Abbauen ist genauso einfach: docker-compose down. Dieser Ansatz macht die Infrastruktur reproduzierbar. Jeder kann dein Repository klonen und deinen ganzen Anwendungsstack mit einem einzigen Befehl ausführen, egal welches Betriebssystem oder welche lokale Konfiguration er hat.

Die Struktur der Docker-Compose-Datei

Lass uns eine einfache Docker Compose-Datei erstellen.

Erstell zuerst die Datei im Terminal mit „ touch docker-compose.yml “, klick dann in PWD auf „Editor“ und füge Folgendes zur Datei hinzu:

services:
  web:
    image: nginx
    ports:
      - "80:80"
  redis:
    image: redis

Der Abschnitt „Services“ erklärt jeden Container. Dienstnamen (wie „web“ und „redis“) werden zu Hostnamen im Docker-Netzwerk. Der Bildschlüssel sagt dir, welches Docker Hub-Bild du nehmen sollst. Einsetzen:

docker-compose up -d

Jetzt, wo beide Container laufen, fragst du dich vielleicht: Wie finden sie sich und wie kommunizieren sie miteinander?

Vernetzung und Dienstermittlung

Compose baut automatisch ein Netzwerk auf, das alle Dienste verbindet, und macht so die Dienstermittlung möglich. Die Container kommunizieren über Servicenamen als Hostnamen.

Probier das mal aus, indem du den Web-Container aufrufst und Redis anpingst:

docker-compose exec web sh
apt-get update && apt-get install -y iputils-ping
ping redis

Erfolgreiche Pings zeigen, dass die Container miteinander reden können! Der Container „ web “ kommt auf „ redis “ drauf, ohne die IP-Adresse zu kennen. Das interne DNS von Docker übersetzt Servicenamen automatisch in die richtigen Containeradressen.

Fehlerbehebung und bewährte Vorgehensweisen bei der Verwendung von Docker

Wenn du mehr mit PWD arbeitest, wirst du auf häufige Herausforderungen stoßen. Hier erfährst du, wie du effektiv damit umgehst.

„Sitzung abgelaufen“

Die Zwei-Stunden-Begrenzung ist das größte Problem für PWD. Wenn der Timer auf Null steht, verschwindet alles, auch Instanzen und Daten. Arbeite effizient, indem du den Code lokal vorbereitest, bevor du ihn in PWD einfügst, und Backups machst. Schick deine eigenen Bilder vor dem Ende deiner Sitzung an Docker Hub:

docker tag my-first-image yourusername/my-first-image
docker push yourusername/my-first-image

Konzentrier dich lieber auf ein Konzept pro Sitzung, statt komplizierte Systeme aufzubauen. Zwei Stunden sind genug Zeit zum Lernen, also teil die Arbeit in kleinere Abschnitte auf.

Fehler bei Port 80/443

Anders als bei lokalem Docker, wo du über localhost auf Container zugreifst, nutzt PWD dynamische URLs. Probier's nicht mit localhost:80. Klick stattdessen auf das Port-Symbol oben in der PWD-Oberfläche. Wenn die Badges nicht sofort angezeigt werden, warte ein paar Sekunden oder aktualisiere deinen Browser.

Bewährte Verfahren

Denk außerdem an diese bewährten Vorgehensweisen:

• Benutz kleine Basis-Images wie Alpine (5 MB im Vergleich zu über 100 MB bei Ubuntu), um Bandbreite zu sparen.
• Lass Container nicht als Root laufen, wenn es nicht unbedingt nötig ist.
• Benutz niemals echte Zugangsdaten in PWD, weil es eine öffentliche Plattform ist.
• Schreib klare Dockerfiles mit Kommentaren, die deine Entscheidungen erklären.
• Halte Bilder auf einzelne Aufgaben fokussiert.

Fazit

Du hast in diesem Tutorial echt viel gelernt. Du hast gelernt, was Play with Docker ist, wann du es anstelle von Docker Desktop verwenden solltest, deinen ersten Container ausgeführt, Portweiterleitung verstanden und Debugging-Befehle verwendet. Wir haben mit Dockerfiles eigene Images erstellt, uns mit Volumes mit Datenpersistenz beschäftigt und mit Docker Compose Multi-Container-Anwendungen organisiert.

Mit Docker spielen bietet dir eine risikofreie Umgebung, um die Grundlagen von Docker zu lernen, ohne dass du es lokal installieren musst. Die Sachen, die du geübt hast: Dockerfiles schreiben, Container verwalten und Netzwerke einrichten, kannst du direkt in der echten Welt mit Docker anwenden.

Jetzt, wo du die Grundlagen kennst, installiere Docker Desktop auf deinem Rechner. PWD ist zwar super zum Lernen und für schnelle Tests, aber für ernsthafte Entwicklung braucht man die Ausdauer, Leistung und Tool-Integration, die nur eine lokale Installation bieten kann. Alles, was du in PWD gelernt hast, kannst du direkt auf Docker Desktop anwenden: Die Befehle sind die gleichen und die Konzepte sind identisch.

Mach einfach weiter so. Probier verschiedene Basis-Images aus, schau dir die Netzwerkfunktionen von Docker an und übe, produktionsreife Dockerfiles zu schreiben. Lerne weiter, probiere Neues aus und entwickle dich weiter. 

Unsere Containerisierung und Virtualisierung mit Docker und Kubernetes bietet eine super Grundlage für die Arbeit mit Containern. Um weiter zu lernen, schau dir auch mal diese Quellen an:

• Docker Compose-Anleitung: Entwicklungen mit mehreren Containern einfacher machen

• Wie man einen Docker-Port freigibt

• Docker für Anfänger: Ein praktischer Leitfaden für Container

• Führ ein Docker-Image als Container aus: Ein praktischer Leitfaden für Anfänger

• Installiere Docker auf Ubuntu: Von der Einrichtung bis zum ersten Container