💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Dieses Tutorial führt Sie durch den Prozess des Zugriffs auf eine Webanwendung, die in einem Docker-Container läuft. Sie lernen die Grundlagen von Docker-Containern kennen, stellen eine einfache Webanwendung bereit und erfahren, wie Sie von Ihrem Host-Rechner aus darauf zugreifen können. Dieses Wissen ist unerlässlich für die Entwicklung und das Testen von Webanwendungen mit Docker.
Docker ist eine Plattform, die Containerisierung verwendet, um Anwendungen und ihre Abhängigkeiten zusammenzupacken. Dies ermöglicht es Anwendungen, konsistent in verschiedenen Umgebungen zu laufen.
Zuerst wollen wir prüfen, ob Docker korrekt auf Ihrem System installiert ist:
docker --versionSie sollten eine Ausgabe ähnlich dieser sehen, die die Docker-Version anzeigt:
Docker version 20.10.21, build baeda1fIn der Docker-Terminologie:
Stellen Sie sich ein Docker Image als Bauplan und einen Docker Container als Gebäude vor, das nach diesem Bauplan erstellt wurde.
Lassen Sie uns einen einfachen Container ausführen, um zu überprüfen, ob Docker korrekt funktioniert:
docker run hello-worldSie sollten eine Ausgabe wie diese sehen:
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
...Dies bestätigt, dass Docker korrekt auf Ihrem System funktioniert.
Hier sind einige wichtige Docker-Befehle, die Sie kennen sollten:
docker psdocker ps -adocker imagesProbieren Sie diese Befehle aus und beobachten Sie die Ausgaben. Nach dem Ausführen des hello-world Containers sollten Sie ihn sehen, wenn Sie docker ps -a ausführen (aber nicht in docker ps, da er sofort nach der Anzeige der Nachricht beendet wird).
In diesem Schritt erstellen wir eine einfache Webanwendung mit Python und Flask, die wir in einem Docker-Container bereitstellen können.
Zuerst erstellen wir ein neues Verzeichnis für unsere Webanwendung:
mkdir -p ~/project/my-web-app
cd ~/project/my-web-appNun erstellen wir eine einfache Flask-Anwendung. Erstellen Sie eine Datei namens app.py mit dem Nano-Editor:
nano app.pyFügen Sie den folgenden Python-Code in die Datei ein:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Drücken Sie Ctrl+O gefolgt von Enter, um die Datei zu speichern, und dann Ctrl+X, um Nano zu verlassen.
Als Nächstes erstellen Sie eine requirements.txt-Datei, um die Abhängigkeiten unserer Anwendung anzugeben:
nano requirements.txtFügen Sie die folgende Zeile in die Datei ein:
flask==2.0.1Drücken Sie Ctrl+O gefolgt von Enter, um die Datei zu speichern, und dann Ctrl+X, um Nano zu verlassen.
Nun erstellen wir ein Dockerfile, um zu definieren, wie unsere Anwendung containerisiert werden soll:
nano DockerfileFügen Sie den folgenden Inhalt in die Datei ein:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]Dieses Dockerfile macht Folgendes:
/app.Drücken Sie Ctrl+O gefolgt von Enter, um die Datei zu speichern, und dann Ctrl+X, um Nano zu verlassen.
Nun erstellen wir ein Docker-Image aus unserem Dockerfile:
docker build -t my-flask-app .Das Flag -t taggt unser Image mit dem Namen my-flask-app. Der . am Ende gibt an, dass sich das Dockerfile im aktuellen Verzeichnis befindet.
Sie sollten eine Ausgabe ähnlich dieser sehen:
Sending build context to Docker daemon x.xxxkB
Step 1/6 : FROM python:3.9-slim
---> xxxxxxxxxx
Step 2/6 : WORKDIR /app
---> Using cache
---> xxxxxxxxxx
...
Successfully built xxxxxxxxxx
Successfully tagged my-flask-app:latestÜberprüfen Sie nun, ob Ihr Image erstellt wurde:
docker images | grep my-flask-appSie sollten Ihr neu erstelltes Image in der Liste sehen.
Nachdem wir unser Docker-Image erstellt haben, lassen Sie es uns als Container ausführen und auf die Webanwendung zugreifen.
Um den Container auszuführen und den Port zuzuordnen, damit wir auf die Webanwendung zugreifen können, verwenden Sie den folgenden Befehl:
docker run -d -p 5000:5000 --name my-web-container my-flask-appDieser Befehl bewirkt Folgendes:
-d: Führt den Container im Detached-Modus (im Hintergrund) aus.-p 5000:5000: Ordnet Port 5000 vom Container Port 5000 auf dem Host zu.--name my-web-container: Weist dem Container einen Namen zu.my-flask-app: Gibt das zu verwendende Image an.Überprüfen wir, ob unser Container läuft:
docker psSie sollten eine Ausgabe ähnlich dieser sehen:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp my-web-containerNun können Sie auf die Webanwendung auf zwei Arten zugreifen:
curl über die Befehlszeile:curl http://localhost:5000Sie sollten die HTML-Antwort sehen:
<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>http://localhost:5000 in die Adressleiste ein.Wenn wir einen Container mit -p 5000:5000 ausführen, erstellen wir eine Zuordnung zwischen:
Dies bedeutet, dass jeglicher Datenverkehr, der an Port 5000 auf dem Host-Rechner gesendet wird, an Port 5000 innerhalb des Containers weitergeleitet wird.
Wir könnten auch verschiedene Portnummern verwenden. Zum Beispiel würde -p 8080:5000 den Host-Port 8080 dem Container-Port 5000 zuordnen, sodass Sie auf die Anwendung unter http://localhost:8080 zugreifen können.
Wenn Sie die Logs vom Container sehen müssen (was beim Debuggen hilfreich sein kann), verwenden Sie:
docker logs my-web-containerSie sollten die Startmeldungen der Flask-Anwendung sehen.
Um den Container zu stoppen, verwenden Sie:
docker stop my-web-containerUm den gestoppten Container zu entfernen, verwenden Sie:
docker rm my-web-containerSie können einen Container auch mit einem einzigen Befehl stoppen und entfernen:
docker rm -f my-web-containerDies ist nützlich während der Entwicklung, wenn Sie Ihren Container schnell neu erstellen und erneut ausführen möchten.
Nachdem Sie Ihre Webanwendung erfolgreich in einem Docker-Container ausgeführt haben, wollen wir einige zusätzliche Funktionen und Techniken zur Verwaltung von Docker-Containern untersuchen.
Sie können mehrere Instanzen Ihrer Webanwendung auf verschiedenen Ports ausführen. Dies ist nützlich zum Testen oder zum gleichzeitigen Ausführen verschiedener Versionen Ihrer App.
Zuerst stoppen und entfernen wir unseren vorherigen Container:
docker rm -f my-web-containerNun lassen Sie uns zwei Instanzen unserer Webanwendung auf verschiedenen Ports ausführen:
docker run -d -p 5000:5000 --name web-app-1 my-flask-app
docker run -d -p 5001:5000 --name web-app-2 my-flask-appÜberprüfen Sie, ob beide Container ausgeführt werden:
docker psSie sollten zwei laufende Container sehen:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5001->5000/tcp web-app-2
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp web-app-1Jetzt können Sie auf dieselbe Anwendung über zwei verschiedene Ports zugreifen:
Docker ermöglicht es Ihnen, Ressourcenbeschränkungen für Ihre Container festzulegen. Dies ist nützlich, um zu verhindern, dass ein Container zu viele Systemressourcen verbraucht.
Lassen Sie uns unsere vorherigen Container stoppen und entfernen:
docker rm -f web-app-1 web-app-2Nun lassen Sie uns einen Container mit Speicher- und CPU-Beschränkungen ausführen:
docker run -d -p 5000:5000 --name limited-container --memory=512m --cpus=0.5 my-flask-appDieser Befehl erstellt einen Container mit:
Überprüfen Sie, ob der Container ausgeführt wird:
docker psUmgebungsvariablen sind eine gängige Methode, um Anwendungen in Docker-Containern zu konfigurieren. Ändern wir unsere Flask-Anwendung, um eine Umgebungsvariable zu verwenden:
docker rm -f limited-containerErstellen Sie eine neue Version der Datei app.py:
cd ~/project/my-web-app
nano app_env.pyFügen Sie den folgenden Code hinzu:
import os
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
app_name = os.environ.get('APP_NAME', 'Default App')
return f"<h1>Hello from {app_name}!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Drücken Sie Ctrl+O gefolgt von Enter, um die Datei zu speichern, und dann Ctrl+X, um Nano zu verlassen.
Erstellen Sie ein neues Dockerfile:
nano Dockerfile-envFügen Sie den folgenden Inhalt hinzu:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app_env.py ./app.py
EXPOSE 5000
CMD ["python", "app.py"]Drücken Sie Ctrl+O gefolgt von Enter, um die Datei zu speichern, und dann Ctrl+X, um Nano zu verlassen.
Erstellen Sie ein neues Image:
docker build -t my-flask-app-env -f Dockerfile-env .Führen Sie nun den Container mit einer Umgebungsvariablen aus:
docker run -d -p 5000:5000 --name env-container -e APP_NAME="Customized App" my-flask-app-envGreifen Sie auf die Webanwendung zu:
curl http://localhost:5000Sie sollten sehen:
<h1>Hello from Customized App!</h1><p>This is a simple web application running in a Docker container.</p>Dies zeigt, wie Sie Konfigurationen mithilfe von Umgebungsvariablen an Ihre containerisierten Anwendungen übergeben können.
In diesem Lab haben Sie gelernt, wie Sie auf eine Webanwendung zugreifen, die in einem Docker-Container ausgeführt wird. Sie haben eine einfache Flask-Webanwendung erstellt, diese mit Docker containerisiert und über Port-Mapping von Ihrem Host-Rechner aus darauf zugegriffen.
Wichtige behandelte Konzepte:
Diese Fähigkeiten bieten eine solide Grundlage für die Arbeit mit containerisierten Anwendungen und helfen Ihnen, Webanwendungen effizient mit Docker bereitzustellen und zu testen.
