Website-Suche

Wie man eine Python-Anwendung mit Okteto auf Kubernetes bereitstellt

Einführung

Okteto ist eine Entwicklungsplattform, die verwendet wird, um den Entwicklungsprozess für Kubernetes-Anwendungen zu optimieren. Es ermöglicht Entwicklern, ihre Anwendungen direkt in Kubernetes-Clustern zu erstellen und zu testen, ohne komplexe lokale Entwicklungsumgebungen einrichten zu müssen. Okteto ermöglicht Live-Updates für Anwendungen, die in Kubernetes-Clustern ausgeführt werden, sodass Entwickler ihre Codeänderungen in Echtzeit sehen können, ohne ihre Anwendungen neu erstellen oder erneut bereitstellen zu müssen.

In diesem Tutorial erstellen Sie eine Python-Anwendung und setzen sie mit Okteto auf Kubernetes ein.

Voraussetzungen

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie Folgendes:

  • Ein Kubernetes 1.28-Cluster. In diesem Tutorial wird das Setup einen DigitalOcean Kubernetes-Cluster mit mindestens 3 Knoten (4CPUs und 16GB RAM jeweils) verwenden.
  • kubectl installiert und konfiguriert, um mit Ihrem Cluster zu kommunizieren.
  • Ein Docker Hub-Konto.
  • Docker läuft auf deinem lokalen Rechner.
  • Eine Lizenz ist erforderlich, um Okteto zu nutzen. Melden Sie sich für die kostenlose 30-tägige Testversion von Okteto an, um einen Lizenzschlüssel zu erhalten.
  • Der Helm-Paketmanager ist auf Ihrem lokalen Computer installiert. Um dies zu tun, schließen Sie Schritt 1 des Tutorials "So installieren Sie Software auf Kubernetes-Clustern mit dem Helm 3-Paketmanager" ab.
  • Ein vollständig registrierter Domainname, der auf den Lastenausgleichsserver zeigt, der vom Nginx Ingress verwendet wird. Sie müssen einen A-Eintrag mit dem Namen * und der IP-Adresse des Lastenausgleichsservers erstellen.

Schritt 1 - Erstellen Sie eine Python-Anwendung

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

python3 --version

Wenn Python installiert ist, wird dieser Befehl die Version von Python anzeigen. Wenn nicht, können Sie es mit folgendem Befehl installieren:

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

Als nächstes erstellen Sie ein Verzeichnis, um Ihren Anwendungscode und andere Konfigurationen zu speichern.

mkdir my-app

Navigieren Sie als Nächstes zu Ihrem Anwendungsverzeichnis und erstellen Sie eine virtuelle Umgebung, um Ihre Projektabhängigkeiten zu isolieren.

cd my-app
python3 -m venv python-env

Aktivieren Sie als Nächstes die virtuelle Umgebung mit dem folgenden Befehl.

source python-env/bin/activate

Als nächstes erstellen Sie eine neue Python-Datei für Ihre Anwendung. Zum Beispiel erstellen Sie eine einfache app.py Datei:

nano app.py

Fügen Sie den 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')

Als Nächstes installieren Sie das Flask-Webframework.

pip install flask

Jetzt führen Sie Ihre Python-Anwendung mit dem folgenden Befehl aus.

python3 app.py

Sie werden die folgende Ausgabe sehen.

 * 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

Jetzt, da die Flask-Anwendung lokal läuft und Sie sie mit curl überprüfen können:

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

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

Hello, This is a simple Python App!

Wenn Sie mit Ihrer Arbeit an Ihrem Projekt fertig sind, können Sie die virtuelle Umgebung deaktivieren, indem Sie eingeben:

deactivate

An diesem Punkt haben Sie eine Python-Anwendung erstellt und sie lokal getestet.

Schritt 2 - Dockerisiere Python-Anwendung

Das Dockerisieren einer Python-Anwendung beinhaltet das Erstellen eines Docker-Images, das die Python-Umgebung und die erforderlichen Abhängigkeiten zum Ausführen der Anwendung enthält.

Zuerst erstellen Sie eine Datei mit dem Namen Dockerfile im Stammverzeichnis Ihrer Python-Anwendung.

nano Dockerfile

Fügen Sie den 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 diesem Dockerfile:

  • FROM python:3.8-slim: Gibt das Basis-Image an, das verwendet werden soll. Sie verwenden ein offizielles Python-Image mit Python 3.8 installiert.
  • Setzt das Arbeitsverzeichnis im Container auf /app.
  • ADD . /app: Kopiert den Inhalt des aktuellen Verzeichnisses in das Verzeichnis /app des Containers.
  • RUN pip install flask: Installiert das Flask-Framework.
  • EXPOSE 5000: Öffnet den Port 5000, um eingehende Verbindungen zu ermöglichen.
  • CMD ["python3", "app.py"]: Gibt den Befehl an, der beim Starten des Containers ausgeführt werden soll. In diesem Fall wird app.py ausgeführt.

Führen Sie jetzt den folgenden Befehl aus, um das Image basierend auf 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 my-app Image und mappt den Containerport auf einen Hostport 5000.

Sie können Ihren laufenden Anwendungscontainer mit dem Befehl docker ps überprüfen.

docker ps

Die Ausgabe wird sein:

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 die Anwendung über die URL http://your-server-ip:5000 zuzugreifen. Sie sollten die Nachricht Hallo, das ist eine einfache Python-App! sehen, die anzeigt, dass Ihre Python-Anwendung im Docker-Container läuft.

Bis jetzt hast du deine Python-Anwendung erfolgreich in Docker verpackt.

Schritt 3 - Python Docker-Image in das DockerHub-Register hochladen

Zuerst müssen Sie ein DockerHub-Konto haben. Wenn Sie noch keins haben, können Sie es auf der DockerHub-Website erstellen.

Verwenden Sie den Befehl docker login, um sich bei Docker Hub anzumelden. Ihnen wird aufgefordert, Ihren Docker Hub-Benutzernamen und Ihr Passwort einzugeben.

docker login

Die Ausgabe dieses Befehls wird sein:

Login 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: username@gmail.com
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 du das Bild zu Docker Hub hochlädst, musst du es auch mit deinem Docker Hub-Benutzernamen und dem gewünschten Repository-Namen taggen.

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

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

docker push yourusername/my-app:latest

Nachdem Sie das Image gepusht haben, können Sie überprüfen, ob es auf Docker Hub verfügbar ist, indem Sie es mit der Docker Hub CLI suchen.

docker search yourusername/my-app

Ihr Python-App-Docker-Image ist jetzt auf Docker Hub verfügbar und kann von anderen abgerufen oder in verschiedenen Umgebungen bereitgestellt werden.

Schritt 4 - Erstellen Sie Kubernetes-Manifestdateien zur Bereitstellung der Python-Anwendung

Jetzt müssen Sie eine Kubernetes-Manifestdatei mit Okteto erstellen, um die Bereitstellung, den Dienst und die Ingress-Ressourcen für eine Anwendung namens my-app zu definieren.

nano k8s.yaml

Fügen Sie die folgende Konfiguration zur Datei 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 deployt 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 den HTTP-Verkehr zur Anwendung zu leiten. Okteto-spezifische Annotationen werden verwendet, um bestimmte von Okteto bereitgestellte Funktionen zu aktivieren, wie z.B. die automatische Hostnamen-Generierung.

Schritt 5 - Okteto mit Helm installieren

Zuerst 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, sollten Sie Ihre Helm-Repositories aktualisieren, um sicherzustellen, dass Sie die neuesten Informationen über verfügbare Charts haben:

helm repo update

Als Nächstes erstellen Sie eine config.yaml für Okteto.

nano config.yaml

Fügen Sie Ihren Okteto-Lizenzschlüssel, die Subdomain und andere Konfigurationen wie unten gezeigt hinzu:

license: INSERTYOURKEYHERE
subdomain: okteto.example.com

buildkit:
  persistence:
    enabled: true

registry:
  storage:
    filesystem:
      persistence:
        enabled: true

Hinweis: Ersetzen Sie den Lizenzschlüssel durch Ihren gültigen Okteto-Lizenzschlüssel und okteto.example.com durch Ihren Domainnamen.

Installieren Sie jetzt die neueste Version von Okteto mit der config.yaml Konfigurationsdatei.

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

Sobald das Okteto installiert ist, erhalten Sie die folgende Ausgabe.

NAME: 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`

Hinweis: Merken Sie sich die persönlichen Zugriffstokens 88f8cc11 aus dem obigen Ergebnis. Sie benötigen es, um sich bei Okteto zu authentifizieren.

Warten Sie einige Zeit und holen Sie dann die IP-Adresse ab, die DigitalOcean dynamisch dem NGINX Ingress zugewiesen hat, den Sie gerade installiert und konfiguriert haben, als Teil von Okteto:

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

Sie werden die folgende Ausgabe sehen.

NAME                              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 EXTERNAL-IP-Adresse nehmen und sie zu Ihrem DNS für die Domain hinzufügen, die Sie verwenden möchten. Dies geschieht, indem Sie einen A-Eintrag mit dem Namen * erstellen.

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

Schritt 6 - Installieren und Konfigurieren der Okteto-CLI

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

Sie können die Okteto CLI unter Linux und macOS mit curl installieren. Öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

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

Sobald die Installation abgeschlossen ist, können Sie überprüfen, ob das Okteto-CLI korrekt installiert ist, indem Sie den folgenden Befehl ausführen:

okteto version

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

okteto version 2.25.2

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

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

Seine Ausgabe wird sein:

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

Führen Sie als Nächstes den folgenden Befehl aus, um zu überprüfen, ob Ihr Okteto-CLI konfiguriert ist.

okteto context list

Das gibt folgende Ausgabe:

Name                                      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 der Python-Anwendung zu beginnen, müssen Sie eine Okteto-Manifestdatei erstellen und die Konfiguration für Ihre Entwicklungsumgebung festlegen.

Lass uns eine okteto.yaml Datei für eine einfache Python-Anwendung erstellen.

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,

  • deploy: Dieser Abschnitt definiert die Bereitstellungskonfiguration. Wenn Sie okteto up oder okteto deploy ausführen, führt Okteto den Befehl kubectl apply -f k8s.yaml aus, um die in der Datei k8s.yaml definierten Kubernetes-Ressourcen bereitzustellen. Dies ermöglicht es Ihnen, Ihre Bereitstellungskonfiguration getrennt von Ihrer Entwicklungsumgebungskonfiguration festzulegen.
  • command: bash: Gibt den Befehl an, der ausgeführt werden soll, wenn die Entwicklungsumgebung startet.
  • Umgebung: Legt Umgebungsvariablen fest, die in der Entwicklungsumgebung gesetzt werden sollen. In diesem Fall wird FLASK_ENV auf Entwicklung gesetzt.
  • sync: Gibt die Ordner an, die zwischen Ihrem lokalen Computer und der Entwicklungsumgebung synchronisiert werden sollen. Es synchronisiert das aktuelle Verzeichnis (.) mit /app innerhalb der Entwicklungsumgebung.
  • reverse: Legt Portweiterleitungsregeln fest, um Ports von der Entwicklungsumgebung auf Ihren lokalen Computer weiterzuleiten. In diesem Fall leitet es Port 9000 von der Entwicklungsumgebung auf Port 9000 auf Ihrem lokalen Computer weiter.
  • volumes: Gibt zusätzliche Volumes an, die in die Entwicklungsumgebung eingebunden werden sollen. In diesem Fall wird das Verzeichnis /root/.cache/pip, das möglicherweise verwendet wird, um pip-Pakete zwischenzuspeichern, in die Entwicklungsumgebung eingebunden.

Jetzt deployen Sie Ihre Python-Anwendung mit dem folgenden Befehl in den Kubernetes-Cluster.

okteto deploy

Nach erfolgreicher Bereitstellung sehen Sie die folgende Ausgabe.

deployment.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

Als nächstes gehen Sie zurück zu Ihrem Webbrowser und aktualisieren das Okteto-Dashboard. Sie werden Ihre bereitgestellte Anwendung sehen:

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

Schritt 8 - Entwickeln Sie die Python-Anwendung direkt auf Kubernetes

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

Lass uns die Entwicklungsumgebung mit Okteto starten:

okteto up

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

 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#

Als nächstes führen Sie Ihre Python-Anwendung aus:

python3 app.py

Sie werden die folgende Ausgabe sehen.

 * 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 jetzt Ihre app.py Anwendungsdatei:

nano app.py

Ändern Sie die folgende Zeile:

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

Speichern Sie die Datei und schließen Sie sie. Okteto wird die Codeänderungen automatisch erkennen und sie sofort auf Kubernetes anwenden.

Gehen Sie zurück zu Ihrem Webbrowser und laden Sie die Seite für Ihre Python-Anwendung neu. Sie werden Ihre modifizierte Anwendung auf dem folgenden Bildschirm sehen.

Schlussfolgerung

In diesem Tutorial haben Sie eine grundlegende Python-Anwendung erstellt und sie im Kubernetes-Cluster mit Okteto bereitgestellt. Die Fähigkeit von Okteto, lokale Codeänderungen in Echtzeit mit der Entwicklungsumgebung zu synchronisieren, ermöglicht schnelle Entwicklungsiterationen und sofortiges Feedback zu Codeänderungen. Insgesamt befähigt Okteto Entwickler dazu, sich auf den Bau hochwertiger Python-Anwendungen zu konzentrieren, ohne sich um die Komplexität der Kubernetes-Infrastruktur kümmern zu müssen.

Der Autor wählte die FreeBSD Foundation, um eine Spende im Rahmen des Write for DOnations-Programms zu erhalten.