Play with Docker: Draai gratis containers in je browser

Stel je voor dat je in een paar seconden een multi-node Docker Swarm-cluster opzet zonder ook maar één byte op je laptop te installeren. Jarenlang zag ik ontwikkelaars worstelen met Docker-installaties, vechten met systeemafhankelijkheden, permissiefouten oplossen en zich afvragen of hun verouderde hardware de resources wel aankon. 

Toen ontdekte ik Play with Docker, en dat veranderde volledig hoe ik containerization leer en onderwijs.

Play with Docker is een gratis, browsergebaseerde sandbox die je direct toegang geeft tot Alpine Linux-virtuele machines waarin je Docker-containers kunt bouwen en draaien. Of je nu een beginnende dataprofessional bent die net met containerization start of een doorgewinterde pro die snel een nieuwe Docker-feature wil testen, PWD biedt een toegankelijke, risicovrije omgeving. 

In deze uitgebreide tutorial neem ik je mee van je eerste container tot orkestratie met meerdere containers via Docker Compose. Aan het einde heb je een gecontaineriseerde webserver draaien zonder je browser te verlaten.

Als Docker en de concepten nieuw voor je zijn, raad ik je aan om onze Introduction to Docker-cursus te volgen of Containerization and Virtualization Concepts te bestuderen.

Wat is Play With Docker?

Play with Docker (PWD) is een gratis, tijdelijke Docker-speeltuin die rechtstreeks in je webbrowser draait. Gemaakt door Docker Captains Marcos Liljedhal en Jonathan Leibiusky, ontstond PWD uit een hackathonproject en groeide het snel uit tot een essentiële tool voor de Docker-community.

PWD draait in de kern op Docker-in-Docker (dind)-technologie, waarbij Docker-containers binnen andere Docker-containers draaien. Deze geneste architectuur klinkt misschien complex, maar dit maakt het mogelijk om te experimenteren met volledige Docker-functionaliteit, inclusief geavanceerde features zoals multi-node Swarm-clusters, zonder je lokale machine te beïnvloeden. 

Het platform neemt alle complexiteit achter de schermen weg en presenteert een strakke terminalinterface. Het biedt Alpine Linux-instances, lichtgewicht Linux-distributies die perfect zijn voor containerworkloads. Alpine is bewust minimaal, met een basisimage van slechts zo’n 5 MB vergeleken met Ubuntu’s 100+ MB. 

Die efficiëntie betekent snellere downloads en kortere opstarttijden. Elke instance heeft een volledige terminalervaring, met dezelfde command-line power als een lokale installatie, inclusief een shell, Docker CLI en Docker Compose.

PWD haalt installatiebarrières weg voor beginners en biedt gevorderde gebruikers ruimte om orkestratiefuncties zoals Docker Swarm te testen. Je kunt multi-node clusters maken, met netwerkconfiguraties experimenteren en container scheduling testen, allemaal zonder de overhead van het beheren van virtuele machines of cloudinstances.

Play With Docker vs Docker Desktop

Met een helder beeld van wat PWD biedt, vraag je je waarschijnlijk af wanneer je het gebruikt in plaats van Docker Desktop lokaal te installeren. Begrijpen wanneer je Play with Docker gebruikt versus Docker Desktop bespaart je tijd en frustratie.

Play with Docker biedt direct browsertoegang zonder installatie, nul lokaal resourceverbruik en volledige Docker Swarm-ondersteuning, helemaal gratis. Sessies duren echter slechts twee uur voordat alles wordt verwijderd, de performance is beperkt en er is geen permanente opslag na het verlopen van de sessie.

Let op: De PWD-documentatie vermeldt een sessieduur van vier uur, maar toen ik het testte, was het in werkelijkheid maar twee uur. Het lijkt erop dat de documentatie niet up-to-date is.

Docker Desktop draait lokaal op je machine en biedt permanente opslag, betere prestaties en naadloze integratie met ontwikkeltools zoals Visual Studio Code. Je kunt aan langlopende projecten werken zonder sessietime-outs.

Wanneer gebruik je Play With Docker

Play with Docker blinkt uit in de volgende situaties: 

• Eenmalige tests 
• Tutorials volgen
• Werken op laptops met lage specificaties of Chromebooks
• Live sessie-URL’s delen met teamgenoten voor debugging of demo’s

Wanneer gebruik je Docker Desktop

Docker Desktop is onmisbaar voor 

• Dagelijks ontwikkelwerk
• IDE-integratie
• Persistente projecten die weken of maanden duren
• Resource-intensieve workloads met aangepaste netwerken en volumes

Aan de slag met Play With Docker

Nu je weet wanneer PWD het juiste gereedschap is voor jouw behoeften, gaan we je eerste sessie opzetten en starten.

Play with Docker instellen

Voor je begint, heb je een Docker Hub-account nodig. Ga naar Docker Hub om er een aan te maken. Als je die nog niet hebt, volstaan een e-mailadres en wachtwoord.

Play with Docker Login

Navigeer naar de Play with Docker-website en log in met je Docker Hub-gegevens. Klik na authenticatie op de groene knop "Start" om je sessie te genereren. Binnen enkele seconden levert PWD een schone Alpine Linux-omgeving in je browser met een afteltimer die je resterende sessietijd van twee uur toont.

Navigeren door het Play with Docker-dashboard

De PWD-interface is simpel maar krachtig. Klik op "Add New Instance" om nieuwe Alpine Linux-containers te maken. Je kunt tot 5 instances tegelijk draaien om multi-node clusters te testen. Het hoofdterminalvenster biedt een volledige bash-shell met Docker vooraf geïnstalleerd. 

Houd de afteltimer in de gaten. Zodra die op nul staat, wordt alles verwijderd en is er geen manier om de sessie te verlengen.

Dashboard in Play with Docker

Tip: Standaard Ctrl+V-plakken werkt vaak niet in PWD. Gebruik Ctrl+Insert om te kopiëren en Shift+Insert om te plakken. Test je plak-sneltoets meteen om frustratie te voorkomen.

Kernhandelingen in Play With Docker

Nu je PWD-omgeving klaarstaat en je de interface kent, is het tijd om je eerste container te draaien en de essentiële Docker-commando’s te leren.

Je eerste container draaien

Laten we een Nginx-webserver deployen om images en containers te begrijpen. Voer dit commando uit:

docker run -d -p 80:80 nginxMogelijk gemaakt door

Dit gebeurt er: docker run maakt en start een nieuwe container. De -d-vlag draait ‘m in detached mode (op de achtergrond). De -p 80:80 koppelt poort 80 op de host aan poort 80 in de container. nginx is de naam van de Docker-image.

Zie een Docker-image als een recept. In dit geval het Nginx-recept. De draaiende container is de taart die je met dat recept bakt. Je kunt meerdere taarten (containers) maken van één recept (image).

Je container beheren:

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

Je hebt alleen de eerste paar tekens van het container-ID nodig. Docker weet welke je bedoelt.

Port forwarding in Play with Docker

Port forwarding in PWD werkt anders dan lokaal port forwarden. Wanneer je een poort blootstelt, maakt PWD automatisch een dynamische URL aan voor toegang.

Na het draaien van de Nginx-container kijk je bovenaan je PWD-scherm onder IP. Klik op "Open Port” en voeg “80” toe. Er opent een nieuw browsertabblad met een unieke URL zoals http://ip<numbers>-<session-id>.direct.labs.play-with-docker.com.

Port forwarding in Play with Docker

Je benadert hier niet localhost. PWD maakt speciale URL’s die internetverkeer naar jouw specifieke container routeren. Dat betekent dat je deze URL’s kunt delen met collega’s om je werk in real-time te laten zien.

Debuggen en inspecteren

Als dingen niet werken zoals verwacht, heb je tools nodig om te onderzoeken wat er binnen je containers gebeurt.

Bij troubleshooting helpen deze commando’s je om in containers te kijken:

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

Voer docker logs uit nadat je op de link naar poort 80 hebt geklikt, en je ziet het verzoek van je browser in de Nginx access logs. Deze realtime feedback helpt je de requestflow door je applicatie te begrijpen.

Docker Logs in Play with Docker

Met deze kernhandelingen onder de knie ben je klaar om verder te gaan dan kant-en-klare images draaien en je eigen custom containers te bouwen.

Images bouwen en data beheren in Play With Docker

Nu we de basis van containerhandelingen behandeld hebben, duiken we in het maken van je eigen custom images. Hier komt Docker’s echte kracht naar voren: de mogelijkheid om je applicaties met al hun afhankelijkheden te verpakken in draagbare, reproduceerbare images.

Een basis-Dockerfile schrijven

Dockerfiles automatiseren het bouwen van images via tekstgebaseerde instructies. In plaats van elke keer handmatig een container te configureren, schrijf je één keer een Dockerfile en Docker doet de rest. 

Maak een Dockerfile in Play with Docker

Maak eerst de Dockerfile in de terminal:

touch DockerfileMogelijk gemaakt door

Klik daarna op de knop "Editor" in PWD en voeg een simpele image toe:

FROM alpine
CMD ["echo", "Hello DataCamp"]Mogelijk gemaakt door

Bouw en draai tenslotte de Dockerfile. De -t-vlag geeft je image een naam (of "tag"), zodat je er makkelijk naar kunt verwijzen. De . vertelt Docker om de huidige map als buildcontext te gebruiken, de plek waar Docker de Dockerfile en benodigde bestanden vindt. Je ziet Docker elke instructie uitvoeren en de layer-ID’s tonen.

docker build -t my-first-image .
docker run my-first-imageMogelijk gemaakt door

Bouw een Docker-image in Play with Docker

Je ziet "Hello DataCamp" verschijnen. Gefeliciteerd! Je hebt je eerste custom image gebouwd! Dit simpele voorbeeld toont de kernworkflow: instructies schrijven, een image bouwen, een container draaien.

Maar er is een cruciale uitdaging die we moeten adresseren: wat gebeurt er met je data wanneer containers stoppen of worden verwijderd?

Datapersistente in Play with Docker

Datapersistente begrijpen is fundamenteel om effectief met containers te werken. Standaard zijn containers vluchtig: wanneer je een container verwijdert, verdwijnen elke bestandswijziging, elk databaserecord en elke logregel meteen. 

Dat lijkt misschien problematisch, maar het is juist een van Docker’s sterke punten. Vluchtige containers zijn makkelijk te vervangen, te schalen en te debuggen omdat ze wegwerpbaar zijn.

Maar hoe zit het met de data die je wilt bewaren? Daar komen Docker-volumes om de hoek kijken. Een volume is opslag die door Docker beheerd wordt en buiten het containerbestandssysteem bestaat. Zie het als een USB-stick die je in verschillende containers kunt prikken. De data blijft op de stick staan, zelfs wanneer je hem uit de ene container haalt en in een andere stopt.

Dockercontainer vs. Dockervolume

Ik laat je zien hoe dit in de praktijk werkt. Maak en gebruik een volume:

docker volume create mydata
docker run -it -v mydata:/data alpine shMogelijk gemaakt door

De -v mydata:/data-vlag mount het mydata-volume op het pad /data in de container. Alles wat naar /data wordt geschreven, wordt in het volume opgeslagen. Maak een testbestand:

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

De container is gestopt en verdwenen. Start nu een volledig nieuwe container met hetzelfde volume:

docker run -it -v mydata:/data alpine sh
cat /data/important.txtMogelijk gemaakt door

Datapersistente met Docker-volumes

Het bestand is er nog steeds, inclusief het ID van de oude container! De data bleef bewaard omdat die in het volume stond, niet in het tijdelijke bestandssysteem van de container. Je kunt ditzelfde volume aan zoveel containers koppelen als je wilt, en ze zien allemaal dezelfde data.

Maar – en dit is cruciaal voor PWD-gebruikers – zelfs volumes worden verwijderd wanneer je twee uur durende sessie verloopt. Volumes blijven binnen een sessie bestaan, maar niet over sessies heen. 

Datapersistente begrijpen is cruciaal, maar de meeste echte applicaties bestaan uit meerdere onderling verbonden services. Daar wordt Docker Compose essentieel.

Containerorkestratie met Docker Compose

Nu individuele containers onder de knie zijn, is het tijd voor real-world applicaties, die zelden uit één service bestaan. Moderne applicaties bevatten meestal meerdere componenten: een webfrontend, een API-backend, een database, een cache en misschien een message queue. Al deze onderdelen met losse docker run-commando’s beheren wordt al snel onwerkbaar.

Waarom Docker Compose gebruiken?

Stel je voor: je deployt een applicatie die een webserver, een PostgreSQL-database en een Redis-cache nodig heeft. 

Zonder Compose heb je drie aparte docker run-commando’s nodig, elk met talloze vlaggen voor networking, poortkoppelingen, volumemounts en omgevingsvariabelen. Je moet de exacte volgorde onthouden (eerst database, dan cache, dan webserver), en als er iets misgaat, wordt debuggen een zoektocht door meerdere terminalvensters.

Docker Compose lost deze orkestratie-uitdaging elegant op. In plaats van met meerdere commando’s te jongleren, definieer je je volledige multi-containerapplicatie in één YAML-bestand genaamd docker-compose.yml. Dit bestand wordt de single source of truth voor de architectuur van je applicatie, met alle services, hun configuraties, hoe ze met elkaar verbinden en welke volumes ze gebruiken.

Met Compose wordt het deployen van je hele stack één commando: docker-compose up. Afbreken is even eenvoudig: docker-compose down. Deze declaratieve aanpak maakt infrastructuur reproduceerbaar. Iedereen kan je repository clonen en je volledige applicatiestack met één commando draaien, ongeacht hun besturingssysteem of lokale configuratie.

De structuur van het Docker Compose-bestand

Laten we een basis-Docker Compose-bestand maken.

Maak eerst het bestand aan in de terminal met touch docker-compose.yml, klik daarna op "Editor" in PWD en voeg het volgende toe:

services:
  web:
    image: nginx
    ports:
      - "80:80"
  redis:
    image: redisMogelijk gemaakt door

De sectie services definieert elke container. Servicenamen (zoals web en redis) worden hostnamen op het Docker-netwerk. De sleutel image specificeert welke Docker Hub-image wordt gebruikt. Deploy het:

docker-compose up -dMogelijk gemaakt door

Nu beide containers draaien, vraag je je misschien af: hoe vinden en communiceren ze met elkaar?

Netwerken en service discovery

Compose maakt automatisch een netwerk dat alle services verbindt en service discovery mogelijk maakt. De containers communiceren met elkaar via servicenamen als hostnamen.

Test dit door de webcontainer binnen te gaan en Redis te pingen:

docker-compose exec web sh
apt-get update && apt-get install -y iputils-ping
ping redisMogelijk gemaakt door

Geslaagde pings bewijzen dat de containers kunnen communiceren! De web-container bereikt redis zonder het IP-adres te kennen. Docker’s interne DNS lost servicenamen automatisch op naar de juiste containeradressen.

Troubleshooting en best practices in Play With Docker

Naarmate je meer met PWD werkt, kom je veelvoorkomende uitdagingen tegen. Zo ga je er effectief mee om.

“Session expired”

De limiet van twee uur is de grootste beperking van PWD. Zodra de timer op nul staat, verdwijnt alles, inclusief instances en data. Werk efficiënt door code lokaal voor te bereiden voordat je die in PWD plakt en maak back-ups. Push custom images naar Docker Hub voordat je sessie afloopt:

docker tag my-first-image yourusername/my-first-image
docker push yourusername/my-first-imageMogelijk gemaakt door

Focus per sessie op één concept in plaats van complexe systemen te bouwen. De twee uur zijn ruim voldoende om te leren, dus hak je werk in behapbare stukken.

Fouten op poort 80/443

In tegenstelling tot lokale Docker, waar je containers via localhost benadert, gebruikt PWD dynamische URL’s. Probeer niet localhost:80. Klik in plaats daarvan op de portbadge bovenaan de PWD-interface. Als badges niet meteen verschijnen, wacht een paar seconden of ververs je browser.

Best practices

Houd daarnaast deze best practices in gedachten:

• Gebruik kleine basisimages zoals Alpine (5 MB vs Ubuntu’s 100+ MB) om bandbreedte te besparen
• Draai geen containers als root tenzij het echt nodig is
• Gebruik nooit echte inloggegevens in PWD, het is een publiek platform
• Schrijf duidelijke Dockerfiles met comments die je keuzes toelichten
• Houd images gericht op één verantwoordelijkheid.

Conclusie

Je hebt in deze tutorial veel terrein bestreken. Je leerde wat Play with Docker is, wanneer je het gebruikt in plaats van Docker Desktop, draaide je eerste container, begreep port forwarding en gebruikte debugcommando’s. We bouwden custom images met Dockerfiles, verkenden datapersistente met volumes en orkestreerden multi-containerapplicaties met Docker Compose.

Play with Docker biedt een risicovrije omgeving om Dockerfundamentals te leren zonder lokale installatieverplichting. De skills die je oefende — Dockerfiles schrijven, containers beheren en netwerken configureren — vertalen direct naar echt Docker-gebruik.

Nu je deze basis begrijpt, installeer Docker Desktop lokaal. Hoewel PWD uitstekend is om te leren en snel te testen, heb je voor serieus ontwikkelwerk de persistentie, performance en toolingintegratie nodig die alleen een lokale installatie biedt. Alles wat je in PWD leerde, geldt direct voor Docker Desktop: de commando’s zijn identiek en de concepten hetzelfde.

Bouw verder op deze basis. Experimenteer met verschillende basisimages, verken de netwerkcapaciteiten van Docker en oefen met het schrijven van production-ready Dockerfiles. Blijf leren, experimenteren en bouwen. 

Onze Containerization and Virtualization with Docker and Kubernetes biedt een uitstekende basis voor werken met containers. Om door te leren, raad ik ook de volgende resources aan:

• Docker Compose-gids: vereenvoudig multi-container development

• How to Expose a Docker Port

• Docker for Beginners: A Practical Guide to Containers

• Run a Docker Image as a Container: A Practical Beginner’s Guide

• Install Docker on Ubuntu: From Setup to First Container