Wie man eine Python-Anwendung mit Okteto in Kubernetes bereitstellt

Einführung

Okteto ist eine Entwicklungsplattform, die die Entwicklung von Kubernetes-Anwendungen vereinfacht. Entwickler können ihre Anwendungen direkt auf Kubernetes-Clustern erstellen und testen, ohne komplexe lokale Entwicklungsumgebungen einrichten zu müssen. Okteto ermöglicht Live-Updates von Anwendungen, die auf Kubernetes-Clustern laufen. So können Entwickler Codeänderungen in Echtzeit sehen, ohne ihre Anwendungen neu erstellen oder bereitstellen zu müssen.

In diesem Tutorial erstellen Sie eine Python-Anwendung und stellen sie mithilfe von Okteto in Kubernetes bereit.

Voraussetzungen

• Ein Kubernetes 1.28 Cluster
• kubectl ist installiert und für die Kommunikation mit Ihrem Cluster konfiguriert.
• Ein Docker Hub-Konto
• Docker läuft auf Ihrem lokalen Rechner.
• Für die Nutzung von Okteto ist eine Lizenz erforderlich. Um einen Lizenzschlüssel zu erhalten, melden Sie sich für eine 30-tägige kostenlose Testversion von Okteto an.
• Der Paketmanager Helm ist auf Ihrem lokalen Rechner installiert.
• Ein vollständig registrierter Domainname, der auf den von Nginx Ingress verwendeten Load Balancer verweist. Sie müssen einen A-Record mit dem Namen * und der IP-Adresse des Load Balancers erstellen.

Schritt 1 – Erstellen Sie ein Python-Programm

Zuerst müssen Sie sicherstellen, dass Python auf Ihrem Ubuntu-System installiert ist. Dies können Sie überprüfen, indem Sie ein Terminal öffnen und Folgendes eingeben:

python3 --version

Wenn Python installiert ist, zeigt dieser Befehl die Python-Version an. Andernfalls können Sie es mit folgendem Befehl installieren:

sudo apt install python3 python3-venv python3-pip -y

Erstellen Sie anschließend ein Verzeichnis, in dem der Anwendungscode und weitere Einstellungen gespeichert werden.

mkdir my-app

Als Nächstes wechseln Sie in Ihr Anwendungsverzeichnis und erstellen eine virtuelle Umgebung, um die Abhängigkeiten Ihres Projekts zu isolieren.

cd my-app
python3 -m venv python-env

Aktivieren Sie anschließend die virtuelle Umgebung mit dem folgenden Befehl.

source python-env/bin/activate

Erstellen Sie als Nächstes eine neue Python-Datei für Ihre Anwendung. Erstellen Sie beispielsweise eine einfache app.py-Datei:

nano app.py

Fügen Sie folgenden Code hinzu:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "Hello, This is a simple Python App!"
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')

Installieren Sie anschließend das Flask-Webframework.

pip install flask

Führen Sie nun Ihr Python-Programm mit dem folgenden Befehl aus.

python3 app.py

Sie sehen die folgende Ausgabe.

Output * Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000
* Running on http://172.20.10.2:5000
Press CTRL+C to quit
* Restarting with stat
* Debugger is active!
* Debugger PIN: 311-959-468

Nachdem die Flask-Anwendung nun lokal ausgeführt wird, können Sie dies mit curl überprüfen:

curl -X GET -H "Content-Type: application/json" http://localhost:5000

Sie sollten von der Flask-Anwendung die folgende Antwort erhalten.

OutputHello, This is a simple Python App!

Sobald Sie die Arbeit an Ihrem Projekt abgeschlossen haben, können Sie die virtuelle Umgebung deaktivieren, indem Sie Folgendes ausführen:

deactivate

An diesem Punkt haben Sie ein Python-Programm erstellt und es lokal getestet.

Schritt 2 – Die Python-Anwendung dockerisieren

Die Dockerisierung einer Python-Anwendung beinhaltet die Erstellung eines Docker-Images, das die Python-Umgebung und die zum Ausführen der Anwendung benötigten Abhängigkeiten enthält.

Erstellen Sie zunächst eine Datei namens Dockerfile im Stammverzeichnis Ihrer Python-Anwendung.

nano Dockerfile

Fügen Sie folgenden Inhalt hinzu:

# Use an official Python runtime as a parent image
FROM python:3.8-slim
# Set the working directory in the container
WORKDIR /app
# Copy the current directory contents into the container at /app
ADD . /app
# Install any needed dependencies specified in requirements.txt
RUN pip install flask
# Make port 5000 available to the world outside this container
EXPOSE 5000
# Define environment variable
ENV NAME DockerizedPythonApp
# Run app.py when the container launches
CMD ["python3", "./app.py"]

In dieser Dockerfile:

• FROM python:3.8-slim: Gibt das zu verwendende Basis-Image an. Sie verwenden ein offizielles Python-Image mit installiertem Python 3.8.
• WORKDIR /app: Legt das Arbeitsverzeichnis innerhalb des Containers auf /app fest.
• Fügen Sie . /app hinzu: Kopiert den Inhalt des aktuellen Verzeichnisses in den Ordner /app des Containers.
• RUN pip install flask: Installiert das Flask-Framework.
• EXPOSE 5000: Gibt Port 5000 frei, um eingehende Verbindungen zu ermöglichen.
• CMD [“python3″, “app.py”]: Gibt einen Befehl an, der beim Start des Containers ausgeführt wird. In diesem Fall wird die Anwendung app.py gestartet.

Führen Sie nun den folgenden Befehl aus, um das Image gemäß den Anweisungen in Ihrer Dockerfile zu erstellen.

docker build -t my-app .

Nachdem Sie das Docker-Image erstellt haben, können Sie Ihre Anwendung in einem Container mit dem erstellten Image ausführen:

docker run -dit -p 5000:5000 my-app:latest

Dieser Befehl startet einen Container aus dem Image „my-app“ und ordnet den Container-Port dem Host-Port 5000 zu.

Sie können den Status Ihres laufenden Anwendungscontainers mit dem Befehl docker ps überprüfen.

docker ps

Die Ausgabe lautet:

Output
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
761c54c77411 my-app:latest "python3 ./app.py" 3 seconds ago Up 3 seconds 0.0.0.0:5000->5000/tcp, :::5000->5000/tcp pedantic_wescoff

Öffnen Sie einen Webbrowser oder verwenden Sie curl, um über die URL http://your-server-ip:5000 auf die Anwendung zuzugreifen. Sie sollten die Meldung „Hallo, dies ist eine einfache Python-App!“ sehen, die darauf hinweist, dass Ihre Python-Anwendung in einem Docker-Container ausgeführt wird.

Sie haben Ihre Python-Anwendung nun erfolgreich in einen Docker-Container verschoben.

Schritt 3 – Das Python-Docker-Image in die DockerHub-Registry hochladen

Zunächst benötigen Sie ein DockerHub-Konto. Falls Sie noch keins haben, können Sie eines auf der DockerHub-Website erstellen.

Um sich bei Docker Hub anzumelden, verwenden Sie den Befehl `docker login`. Sie werden aufgefordert, Ihren Docker Hub-Benutzernamen und Ihr Passwort einzugeben.

docker login

Die Ausgabe dieses Befehls lautet wie folgt:

OutputLogin with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one.
Username: [email protected]
Password: 
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded

Bevor Sie das Image auf Docker Hub hochladen, müssen Sie es außerdem mit Ihrem Docker Hub-Benutzernamen und dem Namen des gewünschten Repositorys taggen.

docker tag my-app yourusername/my-app:latest

Sie können Ihr Docker-Image jetzt mit dem Befehl docker push zu Docker Hub hochladen.

docker push yourusername/my-app:latest

Nach dem Hochladen des Images können Sie überprüfen, ob es auf Docker Hub verfügbar ist, indem Sie mit der Docker Hub CLI danach suchen.

docker search yourusername/my-app

Ihr Docker-Image für Ihre Python-Anwendung ist jetzt auf Docker Hub verfügbar und kann von anderen heruntergeladen oder in verschiedenen Umgebungen bereitgestellt werden.

Schritt 4 – Kubernetes-Manifeste erstellen, um die Python-Anwendung bereitzustellen

Nun müssen Sie mit Okteto eine Kubernetes-Manifestdatei erstellen, um die Bereitstellung, den Service und die Eingaberessourcen für eine Anwendung namens my-app zu definieren.

nano k8s.yaml

Fügen Sie der Datei die folgenden Einstellungen hinzu.

apiVersion: apps/v1
kind: Deployment
metadata:
name: my-app
spec:
selector:
matchLabels:
app: my-app
template:
metadata:
labels:
app: my-app
spec:
containers:
- image: yourusername/my-app
name: my-app
---
apiVersion: v1
kind: Service
metadata:
name: my-app
spec:
type: ClusterIP
ports:
- name: "my-app"
port: 5000
selector:
app: my-app
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-app
annotations:
dev.okteto.com/generate-host: my-app
spec:
rules:
- http:
paths:
- backend:
service:
name: my-app
port:
number: 5000
path: /
pathType: ImplementationSpecific

Die obige Datei implementiert eine Anwendung namens „my-app“ mit Okteto, stellt sie intern über einen ClusterIP-Dienst auf Port 5000 bereit und richtet eine Ingress-Ressource ein, um HTTP-Traffic an die Anwendung weiterzuleiten. Okteto-spezifische Annotationen werden verwendet, um einige von Okteto bereitgestellte Funktionen zu aktivieren, wie beispielsweise die automatische Hostnamengenerierung.

Schritt 5 – Okteto mit Helm installieren

Als Erstes müssen Sie das Okteto Helm-Repository zu Ihrem Helm-Client hinzufügen.

helm repo add okteto https://charts.okteto.com

Nachdem Sie das Okteto Helm-Repository hinzugefügt haben, müssen Sie Ihre Helm-Repositories aktualisieren, um sicherzustellen, dass Sie über die aktuellsten Informationen zu den verfügbaren Charts verfügen:

helm repo update

Erstellen Sie anschließend eine config.yaml-Datei für Okteto.

nano config.yaml

Fügen Sie den Okteto-Lizenzschlüssel, die Subdomain und weitere Einstellungen wie unten gezeigt hinzu:

license: FT7YCAYBAEDUY2LDMVXHGZIB76BAAAIDAECEIYLUMEAQUAABAFJAD74EAAAQCUYB76CAAAAABL7YGBIBAL7YMAAAAD77N74CAH7YU6ZCOZSXE43JN5XCEORSFQRGK3LBNFWCEORCNBUXIZLTNBVGK5DIOZQUA3DJNZ2XQYTVPIXGG33NEIWCEY3PNVYGC3TZEI5CE3DJNZ2XQYTVPIRCYITTMVQXI4ZCHIZTALBCORUWK4RCHIRHGY3BNRSSELBCORZGSYLMEI5HI4TVMUWCEZLOMQRDUIRSGAZDILJQGQWTCMCUGA2TUMJUHI2DQWRCPUATCAWDZA5DGNLGYAT25X6NRCJVJNWBQMG2LD7DWY36ZYXOZ7X5B37HZOBHXYV7OSCZ5HKH4G4EOIHJ7XOACMICRENEMSP5CHENLAE2XHXY44AMKKMHR5LB6IEWXNF56KJE6RGDVSGM2JW63F7DNP5ZS6REKK55RYIBMAA=
subdomain: okteto.example.com
buildkit:
persistence:
enabled: true
registry:
storage:
filesystem:
persistence:
enabled: true

Installieren Sie nun die neueste Version von Okteto mithilfe der Konfigurationsdatei config.yaml.

helm install okteto okteto/okteto -f config.yaml --namespace okteto --create-namespace

Nach der Installation von Okteto erhalten Sie die folgende Ausgabe.

OutputNAME: okteto
LAST DEPLOYED: Tue Mar 12 20:27:21 2024
NAMESPACE: okteto
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Congratulations! Okteto is successfully installed!
Follow these steps to complete your domain configuration:
1. Create a wildcard A record "*.okteto.example.com", pointing it to the Okteto NGINX ingress controller External-IP:
$ kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto
2. Access your Okteto instance at `https://okteto.okteto.example.com/login#token=88f8cc11`

Warten Sie einen Moment und weisen Sie dann die IP-Adresse zu, die DigitalOcean dem NGINX Ingress dynamisch zugewiesen hat, den Sie gerade im Rahmen von Okteto installiert und konfiguriert haben:

kubectl get service -l=app.kubernetes.io/name=ingress-nginx,app.kubernetes.io/component=controller --namespace=okteto

Sie sehen die folgende Ausgabe.

OutputNAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
okteto-ingress-nginx-controller LoadBalancer 10.101.31.239 45.76.14.191 80:31150/TCP,443:31793/TCP 3m21s

Sie müssen die externe IP-Adresse nehmen und sie in Ihren DNS-Einträgen für die gewählte Domain hinzufügen. Dies geschieht durch Erstellen eines A-Eintrags mit dem Namen *.

Öffnen Sie nun Ihren Webbrowser und greifen Sie auf Ihre Okteto-Instanz unter https://okteto.okteto.example.com/login#token=88f8cc11 zu.

Schritt 6 – Okteto CLI installieren und konfigurieren

Okteto CLI ist ein Open-Source-Befehlszeilentool, mit dem Sie Ihre Anwendungen direkt auf Kubernetes entwickeln können.

Sie können die Okteto-Befehlszeilenschnittstelle unter Linux und macOS mithilfe von curl installieren. Öffnen Sie Ihr Terminal und führen Sie folgenden Befehl aus:

sudo curl https://get.okteto.com -sSfL | sh

Sobald die Installation abgeschlossen ist, können Sie die korrekte Installation der Okteto CLI überprüfen, indem Sie den folgenden Befehl ausführen:

okteto version

Dieser Befehl zeigt die auf Ihrem System installierte Version der Okteto CLI an.

Outputokteto version 2.25.2

Als Nächstes müssen Sie Ihre persönlichen Zugangscodes verwenden, um sich bei der Okteto-CLI zu authentifizieren.

/* okteto context use https://okteto.okteto.example.com --token 88f8cc11 --insecure-skip-tls-verifycode... */

Die Ausgabe lautet:

Output ✓ Using okteto-admin @ okteto.okteto.example.com

Führen Sie anschließend den folgenden Befehl aus, um sicherzustellen, dass Ihre Okteto-CLI konfiguriert ist.

okteto context list

Dies führt zu folgender Ausgabe:

OutputName Namespace Builder Registry
https://okteto.okteto.example.com * okteto-admin tcp://buildkit.okteto.example.com:443 registry.okteto.example.com
vke-4b7aaaa6-78fa-4a19-9fb3-cf7b8c1ec678 default docker -

Schritt 7 – Erstellen Sie Ihr Okteto-Manifest

Um mit der Entwicklung einer Python-Anwendung zu beginnen, müssen Sie eine Okteto-Manifestdatei erstellen und die Konfiguration für Ihre Entwicklungsumgebung definieren.

Erstellen wir eine okteto.yaml-Datei für eine einfache Python-Anwendung.

nano okteto.yaml

Fügen Sie die folgende Konfiguration hinzu.

deploy:
- kubectl apply -f k8s.yaml
dev:
my-app:
command: bash
environment:
- FLASK_ENV=development
sync:
- .:/app
reverse:
- 9000:9000
volumes:
- /root/.cache/pip

In der obigen Datei:

• Bereitstellung: Dieser Abschnitt definiert die Bereitstellungskonfiguration. Wenn Sie `okteto up` oder `okteto deploy` ausführen, führt Okteto den Befehl `kubectl application -f k8s.yaml` aus, um die in der Datei `k8s.yaml` definierten Kubernetes-Ressourcen bereitzustellen. Dadurch können Sie Ihre Bereitstellungskonfiguration getrennt von Ihrer Entwicklungsumgebungskonfiguration festlegen.
• Befehl: bash: Gibt einen Befehl an, der beim Start der Entwicklungsumgebung ausgeführt werden soll.
• Umgebung: Gibt die Umgebungsvariablen an, die in der Entwicklungsumgebung gesetzt werden sollen. In diesem Fall wird FLASK_ENV auf „development“ gesetzt.
• SYNC: Gibt die Ordner an, die zwischen Ihrem lokalen Rechner und der Entwicklungsumgebung synchronisiert werden sollen. Synchronisiert das aktuelle Verzeichnis (.) mit /app innerhalb der Entwicklungsumgebung.
• Umgekehrt: Legt Portweiterleitungsregeln fest, um Ports aus der Entwicklungsumgebung auf Ihrem lokalen Rechner freizugeben. In diesem Fall wird Port 9000 von der Entwicklungsumgebung an Port 9000 auf Ihrem lokalen Rechner weitergeleitet.
• volumes: Gibt zusätzliche Volumes an, die in der Entwicklungsumgebung installiert werden sollen. In diesem Fall wird das Verzeichnis /root/.cache/pip, das zum Zwischenspeichern von Pip-Paketen verwendet werden kann, in der Entwicklungsumgebung installiert.

Stellen Sie nun Ihre Python-Anwendung mit dem folgenden Befehl im Kubernetes-Cluster bereit.

okteto deploy

Nach erfolgreicher Bereitstellung wird Ihnen die folgende Ausgabe angezeigt.

Outputdeployment.apps/my-app created
service/my-app created
ingress.networking.k8s.io/my-app created
i There are no available endpoints for 'Okteto'.
Follow this link to know more about how to create public endpoints for your application:
https://www.okteto.com/docs/cloud/ssl/
✓ Development environment 'Okteto' successfully deployed
i Run 'okteto up' to activate your development container

Kehren Sie anschließend zu Ihrem Webbrowser zurück und aktualisieren Sie das Okteto-Dashboard. Ihre bereitgestellte Anwendung wird nun angezeigt.

Sie können auch über die URL https://my-app-okteto-admin.okteto.example.com auf Ihre Python-Anwendung zugreifen.

Schritt 8 – Python-Anwendung direkt in Kubernetes entwickeln

In diesem Abschnitt verwenden Sie den Befehl `okteto up`, um eine Python-Anwendung direkt in Kubernetes bereitzustellen. Dieser Befehl synchronisiert Ihren lokalen Code mit der Entwicklungsumgebung. Sie können den Code mit Ihrer bevorzugten IDE oder Ihrem Texteditor auf Ihrem lokalen Rechner bearbeiten; die Änderungen werden automatisch mit der Entwicklungsumgebung in Kubernetes synchronisiert.

Starten wir die Entwicklungsumgebung mit Okteto:

okteto up

Dieser Befehl erstellt eine Entwicklungsumgebung basierend auf den in der Datei okteto.yaml angegebenen Einstellungen.

Output i Using okteto-admin @ okteto.okteto.example.com as context
i 'Okteto' was already deployed. To redeploy run 'okteto deploy' or 'okteto up --deploy'
i Build section is not defined in your okteto manifest
✓ Persistent volume successfully attached
✓ Images successfully pulled
✓ Files synchronized
Context: okteto.okteto.example.com
Namespace: okteto-admin
Name: my-app
Reverse: 9000 <- 9000
root@my-app-okteto-7767588c8d-ndzj7:/app#

Führen Sie als Nächstes Ihr Python-Programm aus:

python3 app.py

Sie sehen die folgende Ausgabe.

Output * Serving Flask app 'app'
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000
* Running on http://10.244.97.92:5000
Press CTRL+C to quit
* Restarting with stat
* Debugger is active!
* Debugger PIN: 126-620-675

Bearbeiten Sie nun Ihre Anwendungsdatei app.py:

nano app.py

Ändern Sie die folgende Zeile:

return "Hello, This is a simple Python App Deployed on Kubernetes"

Speichern und schließen Sie die Datei. Okteto erkennt Codeänderungen automatisch und wendet sie umgehend auf Kubernetes an.

Gehen Sie zurück zu Ihrem Webbrowser und laden Sie die Seite für Ihr Python-Programm neu. Ihr geändertes Programm wird Ihnen dann auf der folgenden Seite angezeigt.

Ergebnis

In diesem Tutorial haben Sie eine einfache Python-Anwendung erstellt und diese mithilfe von Okteto in einem Kubernetes-Cluster bereitgestellt. Dank der Möglichkeit von Okteto, lokale Codeänderungen in Echtzeit mit der Entwicklungsumgebung zu synchronisieren, sind schnelle Entwicklungsiterationen und sofortiges Feedback zu Codeänderungen möglich. Insgesamt ermöglicht Okteto Entwicklern, sich auf die Erstellung hochwertiger Python-Anwendungen zu konzentrieren, ohne sich um die Komplexität der Kubernetes-Infrastruktur kümmern zu müssen.