Recherche de site Web

Comment déployer une application Python sur Kubernetes avec Okteto

Introduction

Okteto est une plateforme de développement utilisée pour rationaliser le processus de développement des applications Kubernetes. Elle permet aux développeurs de créer et de tester leurs applications directement dans des clusters Kubernetes sans avoir à configurer des environnements de développement locaux complexes. Okteto permet des mises à jour en direct des applications s'exécutant dans des clusters Kubernetes, permettant aux développeurs de voir leurs modifications de code reflétées en temps réel sans avoir besoin de reconstruire ou de redéployer leurs applications.

Dans ce tutoriel, vous allez créer une application Python et la déployer sur Kubernetes en utilisant Okteto.

Conditions préalables

Avant de commencer ce tutoriel, vous aurez besoin des éléments suivants :

  • Un cluster Kubernetes 1.28. Dans ce tutoriel, la configuration utilisera un cluster Kubernetes de DigitalOcean avec au moins 3 nœuds (4 CPUs et 16 Go chacun)
  • kubectl installé et configuré pour communiquer avec votre cluster.
  • Un compte Docker Hub.
  • Docker s'exécutant sur votre machine locale.
  • Une licence est obligatoire pour utiliser Okteto. Inscrivez-vous pour un essai gratuit de 30 jours d'Okteto pour obtenir une clé de licence.
  • Le gestionnaire de paquets Helm est installé sur votre machine locale. Pour ce faire, suivez l'étape 1 du tutoriel Comment installer des logiciels sur des clusters Kubernetes avec le gestionnaire de paquets Helm 3.
  • Un nom de domaine entièrement enregistré pointé vers le Load Balancer utilisé par Nginx Ingress. Vous devrez créer un enregistrement A avec le nom * et l'adresse IP du Load Balancer.

Étape 1 - Créer une application Python

Tout d'abord, vous devez vous assurer que Python est installé sur votre système Ubuntu. Vous pouvez vérifier cela en ouvrant un terminal et en tapant :

python3 --version

Si Python est installé, cette commande affichera la version de Python. Sinon, vous pouvez l'installer en utilisant la commande suivante :

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

Ensuite, créez un répertoire pour stocker votre code d'application et d'autres configurations.

mkdir my-app

Ensuite, naviguez jusqu'au répertoire de votre application et créez un environnement virtuel pour isoler les dépendances de votre projet.

cd my-app
python3 -m venv python-env

Ensuite, activez l'environnement virtuel en utilisant la commande suivante.

source python-env/bin/activate

Ensuite, créez un nouveau fichier Python pour votre application. Par exemple, créez un simple fichier app.py :

nano app.py

Ajoutez le code suivant :

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')

Ensuite, installez le framework web Flask.

pip install flask

Maintenant, exécutez votre application Python en utilisant la commande suivante.

python3 app.py

Vous verrez la sortie suivante.

 * 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

Maintenant que l'application Flask fonctionne localement, et que vous pouvez la vérifier en utilisant curl :

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

Vous devriez recevoir la réponse suivante de l'application Flask.

Hello, This is a simple Python App!

Lorsque vous avez terminé de travailler sur votre projet, vous pouvez désactiver l'environnement virtuel en exécutant :

deactivate

À ce stade, vous avez créé une application Python et l'avez testée localement.

Étape 2 - Conteneuriser l'application Python

Dockeriser une application Python implique de créer une image Docker qui contient l'environnement Python et les dépendances nécessaires pour exécuter l'application.

Tout d'abord, créez un fichier nommé Dockerfile dans le répertoire principal de votre application Python.

nano Dockerfile

Ajoutez le contenu suivant :

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"]

Dans ce Dockerfile :

  • FROM python:3.8-slim : Spécifie l'image de base à utiliser. Vous utilisez une image Python officielle avec Python 3.8 installé.
  • WORKDIR /app : Définit le répertoire de travail dans le conteneur à /app.
  • ADD . /app : Copie le contenu du répertoire actuel dans le répertoire /app du conteneur.
  • RUN pip install flask : Installe le cadre Flask.
  • EXPOSE 5000: Expose le port 5000 pour autoriser les connexions entrantes.
  • CMD ["python3", "app.py"]: Spécifie la commande à exécuter lorsque le conteneur démarre. Dans ce cas, il exécute app.py.

Maintenant, exécutez la commande suivante pour construire l'image en fonction des instructions de votre Dockerfile.

docker build -t my-app .

Après avoir construit l'image Docker, vous pouvez exécuter votre application dans un conteneur en utilisant l'image construite :

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

Cette commande exécute un conteneur à partir de l'image my-app et mappe le port du conteneur à un port hôte 5000.

Vous pouvez vérifier votre conteneur d'application en cours d'exécution en utilisant la commande docker ps.

docker ps

La sortie sera :

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

Ouvrez un navigateur web ou utilisez curl pour accéder à l'application en utilisant l'URL http://votre-ip-serveur:5000. Vous devriez voir le message Bonjour, ceci est une application Python simple ! indiquant que votre application Python fonctionne à l'intérieur du conteneur Docker.

Jusqu'à présent, vous avez réussi à dockeriser votre application Python.

Étape 3 - Pousser l'image Docker Python vers le registre DockerHub

Tout d'abord, vous devez avoir un compte DockerHub. Si vous n'en avez pas, vous pouvez le créer sur le site Web de DockerHub.

Utilisez la commande docker login pour vous connecter à Docker Hub. Vous serez invité à entrer votre nom d'utilisateur et votre mot de passe Docker Hub.

docker login

La sortie de cette commande sera :

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

Avant de pousser l'image vers Docker Hub, vous devez également l'étiqueter avec votre nom d'utilisateur Docker Hub et le nom du dépôt souhaité.

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

Vous pouvez maintenant pousser votre image Docker sur Docker Hub en utilisant la commande docker push.

docker push yourusername/my-app:latest

Après avoir poussé l'image, vous pouvez vérifier qu'elle est disponible sur Docker Hub en la recherchant à l'aide de la CLI de Docker Hub.

docker search yourusername/my-app

Votre image Docker de l'application Python est maintenant disponible sur Docker Hub et peut être récupérée par d'autres ou déployée dans divers environnements.

Étape 4 - Créer des manifestes Kubernetes pour déployer une application Python

Maintenant, vous devrez créer un fichier de manifeste Kubernetes en utilisant Okteto pour définir les ressources de déploiement, de service et d'ingress pour une application appelée my-app.

nano k8s.yaml

Ajoutez la configuration suivante au fichier.

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

Le fichier ci-dessus déploie une application nommée my-app en utilisant Okteto, l'expose en interne via un service ClusterIP sur le port 5000, et met en place une ressource Ingress pour acheminer le trafic HTTP vers l'application. Des annotations spécifiques à Okteto sont utilisées pour activer certaines fonctionnalités fournies par Okteto, telles que la génération automatique de noms d'hôte.

Étape 5 - Installer Okteto en utilisant Helm

Tout d'abord, vous devez ajouter le dépôt Helm d'Okteto à votre client Helm.

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

Une fois que vous avez ajouté le dépôt Helm d'Okteto, vous devez mettre à jour vos dépôts Helm pour vous assurer que vous avez les dernières informations sur les graphiques disponibles :

helm repo update

Ensuite, créez un config.yaml pour Okteto.

nano config.yaml

Ajoutez votre clé de licence Okteto, sous-domaine et autres configurations comme indiqué ci-dessous :

license: INSERTYOURKEYHERE
subdomain: okteto.example.com

buildkit:
  persistence:
    enabled: true

registry:
  storage:
    filesystem:
      persistence:
        enabled: true

Remarque : Remplacez la clé de licence par votre clé de licence Okteto valide et okteto.example.com par le nom de votre domaine.

Maintenant, installez la dernière version d'Okteto en utilisant le fichier de configuration config.yaml.

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

Une fois qu'Okteto est installé, vous obtiendrez la sortie suivante.

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`

Remarque : N'oubliez pas les jetons d'accès personnel 88f8cc11 provenant de la sortie ci-dessus. Vous en aurez besoin pour authentifier Okteto.

Attendez un certain temps, puis récupérez l'adresse IP que DigitalOcean a attribuée dynamiquement à l'Ingress NGINX que vous venez d'installer et de configurer dans le cadre d'Okteto :

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

Vous verrez la sortie suivante.

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

Vous devez prendre l'adresse EXTERNAL-IP et l'ajouter à votre DNS pour le domaine que vous avez choisi d'utiliser. Cela se fait en créant un enregistrement A avec le nom *.

Maintenant, ouvrez votre navigateur web et accédez à votre instance Okteto à l'adresse https://okteto.okteto.example.com/login#token=88f8cc11.

Étape 6 - Installer et configurer l'Okteto CLI

L'Okteto CLI est un outil en ligne de commande open-source qui vous permet de développer vos applications directement sur Kubernetes.

Vous pouvez installer le CLI Okteto sur Linux et macOS en utilisant curl. Ouvrez votre terminal et exécutez la commande suivante :

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

Une fois l'installation terminée, vous pouvez vérifier que le CLI Okteto est installé correctement en exécutant la commande suivante :

okteto version

Cette commande affichera la version de l'interface de ligne de commande Okteto installée sur votre système.

okteto version 2.25.2

Ensuite, vous devrez utiliser vos jetons d'accès personnels pour vous authentifier avec l'outil en ligne de commande Okteto.

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

Sa sortie sera :

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

Ensuite, exécutez la commande suivante pour vérifier que votre CLI Okteto est configurée.

okteto context list

Cela donne le résultat suivant :

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                                  -

Étape 7 - Créez votre manifeste Okteto

Pour commencer à développer l'application Python, vous devrez créer un fichier manifeste Okteto et définir la configuration de votre environnement de développement.

Créons un fichier okteto.yaml pour une simple application Python.

nano okteto.yaml

Ajoutez la configuration suivante.

deploy:
  - kubectl apply -f k8s.yaml

dev:
  my-app:
    command: bash
    environment:
      - FLASK_ENV=development
    sync:
      - .:/app
    reverse:
      - 9000:9000
    volumes:
      - /root/.cache/pip

Dans le fichier ci-dessus,

  • déployer: Cette section définit la configuration de déploiement. Lorsque vous exécutez okteto up ou okteto deploy, Okteto exécutera la commande kubectl apply -f k8s.yaml pour déployer les ressources Kubernetes définies dans le fichier k8s.yaml. Cela vous permet de spécifier votre configuration de déploiement séparément de votre configuration d'environnement de développement.
  • commande: bash: Spécifie la commande à exécuter lorsque l'environnement de développement démarre.
  • L'environnement : Spécifie les variables d'environnement à définir dans l'environnement de développement. Dans ce cas, il définit FLASK_ENV sur développement.
  • sync : Spécifie les dossiers à synchroniser entre votre machine locale et l'environnement de développement. Il synchronise le répertoire courant (.) avec /app à l'intérieur de l'environnement de développement.
  • reverse : Spécifie des règles de redirection de ports pour exposer des ports de l'environnement de développement à votre machine locale. Dans ce cas, il redirige le port 9000 de l'environnement de développement vers le port 9000 de votre machine locale.
  • volumes : Spécifie des volumes supplémentaires à monter dans l'environnement de développement. Dans ce cas, il monte le répertoire /root/.cache/pip, qui pourrait être utilisé pour mettre en cache les paquets pip, dans l'environnement de développement.

Maintenant, déployez votre application Python sur le cluster Kubernetes en utilisant la commande suivante.

okteto deploy

Après le déploiement réussi, vous verrez la sortie suivante.

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

Ensuite, retournez à votre navigateur web et rafraîchissez le tableau de bord Okteto. Vous verrez votre application déployée :

Vous pouvez également accéder à votre application Python en utilisant l'URL https://my-app-okteto-admin.okteto.example.com.

Étape 8 - Développer une application Python directement sur Kubernetes

Dans cette section, vous utiliserez la commande okteto up pour déployer une application Python directement sur Kubernetes. Cette commande synchronisera votre code local avec l'environnement de développement. Vous pouvez modifier le code en utilisant votre IDE ou éditeur de texte préféré sur votre machine locale, et les modifications seront automatiquement synchronisées avec l'environnement de développement dans Kubernetes.

Commençons l'environnement de développement en utilisant Okteto :

okteto up

Cette commande créera un environnement de développement basé sur les configurations spécifiées dans le fichier okteto.yaml.

 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#

Ensuite, exécutez votre application Python :

python3 app.py

Vous verrez la sortie suivante.

 * 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

Maintenant, modifiez votre fichier d'application app.py :

nano app.py

Modifiez la ligne suivante :

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

Enregistrez et fermez le fichier. Okteto détectera automatiquement les modifications du code et les appliquera instantanément à Kubernetes.

Retournez à votre navigateur web et rechargez la page de votre application Python. Vous verrez votre application modifiée à l'écran suivant.

Conclusion

Dans ce tutoriel, vous avez créé une application Python de base et l'avez déployée sur le cluster Kubernetes en utilisant Okteto. La capacité d'Okteto à synchroniser les modifications de code local avec l'environnement de développement en temps réel permet des itérations de développement rapides et un retour immédiat sur les modifications de code. Dans l'ensemble, Okteto permet aux développeurs de se concentrer sur la création d'applications Python de haute qualité sans se soucier des complexités de l'infrastructure Kubernetes.

L'auteur a choisi la FreeBSD Foundation pour recevoir un don dans le cadre du programme Write for DOnations.