Docker is een gratis en open-source oplossing voor het ontwikkelen, implementeren en beheren van apps in lichtgewicht virtualisatie op besturingssysteemniveau. In deze handleiding laten we zien hoe u een Python app maakt binnen een Docker-container.
Vereisten
Om de stappen in deze handleiding uit te voeren, heeft u de volgende componenten nodig:
-
Een Linux-systeem. Bekijk het configureren van uw eigen Ubuntu VPS op CloudSigma.
-
De nieuwste versie van Docker is geïnstalleerd en geconfigureerd. Lees meer over het installeren van Docker op Ubuntu.
Docker-containers
Wanneer u verschillende programma's binnen dezelfde omgeving uitvoert, kunnen er dingen kapotgaan (en dat zal ook gebeuren). Hoe meer programma's u toevoegt, hoe onstabieler het wordt. Voor de gemiddelde persoon is dat misschien geen groot probleem. Als het echter gaat om bedrijfskritische toepassingen, kan dit ernstige gevolgen hebben.
Hoe meer apps er in het systeem worden geïntroduceerd, hoe groter het aanvalsoppervlak. Een enkele gecompromitteerde app kan gemakkelijk leiden tot de ondergang van het hele systeem.
Om deze problemen op te lossen, kunnen we Docker-containers gebruiken voor sandboxing op softwareniveau:
-
Apps binnen de container hebben beperkte toegang tot bestanden.
-
Gecontaineriseerde apps kunnen geen andere processen zien die in het systeem draaien.
-
Aan de container kan een specifieke hoeveelheid hardwarebronnen worden toegewezen.
-
Netwerkpoorten van een container worden niet naar buiten toe blootgesteld.
-
Consistente verpakking van vrijwel alles over lokale/productieomgevingen.
Ter demonstratie gaan we een eenvoudige Python-server bouwen binnen een Docker-container, de container omzetten in een image en de image implementeren in een fictieve productieomgeving.
Stap 1 – Bestandssysteemconfiguratie
Om het project te hosten, gaan we eerst een speciale map aanmaken:
|
1 |
mkdir -pv python-server-container/ |
|
1 |
cd !$ |
Maak binnen de map een submap aan src om onze code in op te slaan:
|
1 |
mkdir -pv src/ |
Stap 2 – De Python-server bouwen
In deze stap gaan we een eenvoudige HTTP-server in Python maken. Maak het bestand aan server.py:
|
1 |
touch server.py |
Open het in een teksteditor:
|
1 |
nano server.py |
Voer de volgende Python-code in:
|
1 2 3 4 5 6 7 8 9 10 11 |
from http.server import HTTPServer, SimpleHTTPRequestHandler def run(server_class=HTTPServer, handler_class=SimpleHTTPRequestHandler): """server entrypoint""" server_address = ("0.0.0.0", 8080) httpd = server_class(server_address, handler_class) print("starting server...") httpd.serve_forever() if __name__ == "__main__": run() |
Hier,
-
We gebruiken de HTTPServer-klasse en vragen een handler aan uit de standaard Python-bibliotheek, waardoor het programma eenvoudig blijft.
-
De functie run start een instantie van de HTTPserver.
-
Zoals de argumenten van server_address suggereren, zal de server luisteren naar elke inkomende verbinding op poort 8080.
Nu gaan we controleren of de server naar verwachting werkt. Start de server:
|
1 |
python3 server.py |
Vanuit een nieuwe terminal kunnen we curl gebruiken om een verzoek naar de server te sturen:
|
1 |
curl -iv localhost:8080 |
Als alternatief kunt u de link openen in een webbrowser:
|
1 |
http://localhost:8080 |
Stap 3 – Een Dockerfile maken
Een Dockerfile bevat de benodigde instructies om een Docker-image te genereren. De instructies in het bestand worden opeenvolgend uitgevoerd. Lees meer over Dockerfile.
Maak een nieuwe Dockerfile voor ons project:
|
1 |
touch Dockerfile |
Nu zullen we de benodigde codes erin zetten. Open het in een teksteditor:
|
1 |
nano Dockerfile |
Voer de volgende code in:
|
1 2 3 4 5 6 7 8 9 |
FROM python:latest ENV SRC_DIR /usr/bin/src/test_server/src COPY src/* ${SRC_DIR}/ WORKDIR ${SRC_DIR} ENV PYTHONUNBUFFERED=1 CMD ["python", "server.py"] |
Hier,
-
Elke Dockerfile moet beginnen met de FROM instructie. In ons geval declareren we Python als de basis van de Docker-image.
-
De ENV SRC_DIR instructie specificeert de locatie van de containermap.
-
De COPY instructie kopieert de bestanden uit de src map die momenteel de Python-server host.
-
De variabele PYTHONBUFFERED=1 specificeert dat Python uitvoer rechtstreeks zal printen en loggen naar STDOUT. Anders zouden de logs niet naar een buffer worden verzonden.
-
De CMD instructie specificeert een standaardcommando dat moet worden uitgevoerd bij het starten van de container. In dit geval gebruiken we de instructie om onze Python-server te starten.
Stap 4 – Docker-image genereren
Nu de Dockerfile gereed is, kunnen we een image bouwen. Voer het volgende Docker-commando uit om het proces te starten:
|
1 |
docker build . -t python_server |
Hier,
-
De -t vlag wordt gebruikt om onze Docker-image te taggen als python_server.
-
Docker zal alle benodigde componenten downloaden en deze combineren in een image.
Stap 5 – De image uitvoeren
De image is klaar voor implementatie. We kunnen deze uitvoeren met het volgende commando:
|
1 |
docker run -p 8080:8080 python_server |
Hier sturen we poort 8080 van de lokale machine door naar de Docker-image met behulp van de -p vlag.
We kunnen eenvoudig controleren of de server actief is met behulp van curl:
|
1 |
curl -iv localhost:8080 |
Stap 6 – De server beëindigen
Druk in de terminal op “Ctrl + C” om het Docker-proces te beëindigen:
Stap 7 – De Docker-image exporteren en importeren
We hebben nu een functionele Docker-image die onze Python-server host. Met behulp van de export- en importfuncties van Docker kunnen we deze naar elk ander systeem migreren.
Controleer eerst de lijst met Docker-images op het huidige systeem:
|
1 |
docker images |
Ons doel is de python_server Docker-image die we zojuist hebben gemaakt. Het volgende commando exporteert deze als een TAR-archief:
|
1 |
docker save python_server:latest > python_server.tar |
Na het overzetten van het python_server.tar-bestand naar de doelmachine, gebruikt u het volgende commando om de Docker-image te importeren:
|
1 |
docker load < python_server.tar |
Tot slot
In deze handleiding hebben we gedemonstreerd hoe u een Docker-image bouwt van een Python-applicatie. We hebben een eenvoudige Python-webserver gemaakt en daar een Docker-image van gebouwd. De Docker-image kan nu in elke omgeving worden geïmplementeerd met de verwachting van consistent gedrag.
Wilt u meer leren over Docker? Bekijk dan de volgende handleidingen:
-
Een Flask-applicatie bouwen en implementeren met Docker op Ubuntu 20.04
-
Een Django-applicatie beveiligen en schalen met Docker, Nginx en Let’s Encrypt
-
WordPress implementeren met Docker-containers op Ubuntu 20.04
Veel computerplezier!
Reacties
Nog geen reacties. Wees de eerste.