Ako nasadiť aplikáciu Python na Kubernetes pomocou Okteto

Zavedenie

Okteto je vývojová platforma slúžiaca na zefektívnenie procesu vývoja aplikácií Kubernetes. Umožňuje vývojárom vytvárať a testovať svoje aplikácie priamo v klastroch Kubernetes bez nastavovania zložitých lokálnych vývojových prostredí. Okteto umožňuje živé aktualizácie aplikácií bežiacich v klastroch Kubernetes, čo umožňuje vývojárom vidieť zmeny kódu v reálnom čase bez toho, aby museli prebudovať alebo znovu nasadiť svoje aplikácie.

V tomto návode vytvoríte aplikáciu v jazyku Python a nasadíte ju na Kubernetes pomocou Okteto.

Predpoklady

Pred začatím tohto kurzu budete potrebovať nasledovné:

  • Klaster Kubernetes 1.28. V tomto kurze bude nastavenie používať klaster DigitalOcean Kubernetes s najmenej 3 uzlami (každý 4 procesory a 16 GB)
  • Kubectl nainštalovaný a nakonfigurovaný na komunikáciu s vaším klastrom.
  • Konto Docker Hub.
  • Docker bežiaci na vašom lokálnom počítači.
  • Na používanie Okteto je povinná licencia. Zaregistrujte sa na bezplatnú 30-dňovú skúšobnú verziu Okteto a získajte licenčný kľúč.
  • Správca balíkov Helm je nainštalovaný na lokálnom počítači. Ak to chcete urobiť, dokončite krok 1 v návode Ako nainštalovať softvér na klastre Kubernetes pomocou kurzu Správca balíkov Helm 3.
  • Plne registrovaný názov domény smeroval na Load Balancer, ktorý používa Nginx Ingress. Budete musieť vytvoriť záznam A s názvom * a IP adresou nástroja Load Balancer.

Krok 1 – Vytvorenie aplikácie v jazyku Python

Najprv sa musíte uistiť, že je vo vašom systéme Ubuntu nainštalovaný Python. Môžete to skontrolovať otvorením terminálu a zadaním:

python3 --version

Ak je nainštalovaný Python, tento príkaz zobrazí verziu Pythonu. Ak nie, môžete ho nainštalovať pomocou nasledujúceho príkazu:

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

Ďalej vytvorte adresár na uloženie kódu aplikácie a ďalších konfigurácií.

mkdir my-app

Potom prejdite do adresára aplikácie a vytvorte virtuálne prostredie na izoláciu závislostí projektu.

cd my-app
python3 -m venv python-env

Ďalej aktivujte virtuálne prostredie pomocou nasledujúceho príkazu.

source python-env/bin/activate

Ďalej vytvorte nový súbor jazyka Python pre svoju aplikáciu. Vytvorte napríklad jednoduchý app.py súbor:

nano app.py

Pridajte nasledujúci kód:

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

Ďalej nainštalujte webový rámec Flask.

pip install flask

Teraz spustite aplikáciu Python pomocou nasledujúceho príkazu.

python3 app.py

Zobrazí sa nasledujúci výstup.

 * 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

Teraz, keď je aplikácia Flask spustená lokálne a môžete ju overiť pomocou curl:

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

Z aplikácie Flask by ste mali dostať nasledujúcu odpoveď.

Hello, This is a simple Python App!

Po dokončení práce na projekte môžete virtuálne prostredie deaktivovať spustením:

deactivate

V tomto bode ste vytvorili aplikáciu v jazyku Python a otestovali ste ju lokálne.

Krok 2 - Aplikácia Dockerize Python

Dockerizácia aplikácie v jazyku Python zahŕňa vytvorenie obrazu Dockeru, ktorý obsahuje prostredie jazyka Python a závislosti potrebné na spustenie aplikácie.

Najprv vytvorte súbor s názvom Dockerfile v koreňovom adresári aplikácie v jazyku Python.

nano Dockerfile

Pridajte nasledujúci obsah:

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

V tomto súbore Dockerfile:

  • FROM python:3.8-slim: Určuje základný obrázok, ktorý sa má použiť. Používate oficiálny obrázok jazyka Python s nainštalovaným jazykom Python 3.8.
  • WORKDIR /app: Nastaví pracovný adresár v kontajneri na /app.
  • ADD . /app: Skopíruje obsah aktuálneho adresára do adresára /app kontajnera.
  • RUN pip install flask: Nainštaluje framework Flask.
  • EXPOSE 5000: Vystavuje port 5000, aby sa umožnili prichádzajúce pripojenia.
  • CMD ["python3", "app.py"]: Určuje príkaz, ktorý sa má spustiť pri spustení kontajnera. V tomto prípade beží app.py.

Teraz spustite nasledujúci príkaz na zostavenie obrazu na základe pokynov v súbore Dockerfile.

docker build -t my-app .

Po vytvorení obrazu Dockeru môžete aplikáciu spustiť v kontajneri pomocou vytvoreného obrazu:

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

Tento príkaz spustí kontajner z obrázka mojej aplikácie a priradí port kontajnera k hostiteľskému portu 5000.

Spustený kontajner aplikácií môžete overiť pomocou príkazu docker ps.

docker ps

Výstup bude:

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

Otvorte a web prehliadač alebo použite curl na prístup k aplikácii pomocou URL http://your-server-ip:5000. Mala by sa zobraziť správa Dobrý deň, toto je jednoduchá aplikácia Python! označujúca, že vaša aplikácia v jazyku Python je spustená v kontajneri Docker.

Doteraz ste úspešne dockerizovali svoju aplikáciu v jazyku Python.

Krok 3 – Presunutie obrazu Python Docker do databázy Registry DockerHub

Najprv musíte mať účet DockerHub. Ak ho nemáte, môžete si ho vytvoriť na webovej lokalite DockerHub.

Pomocou príkazu docker login sa prihláste do Docker Hubu. Zobrazí sa výzva na zadanie používateľského mena a hesla zariadenia Docker Hub.

docker login

Výstupom tohto príkazu bude:

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

Pred odoslaním obrázka do Docker Hub ho musíte označiť aj používateľským menom Docker Hub a požadovaným názvom úložiska.

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

Teraz môžete presunúť obraz Dockeru do Docker Hubu pomocou príkazu docker push.

docker push yourusername/my-app:latest

Po odoslaní obrázka môžete overiť, či je k dispozícii na Docker Hub tak, že ho vyhľadáte pomocou rozhrania Docker Hub CLI.

docker search yourusername/my-app

Obrázok Dockeru aplikácie Python je teraz k dispozícii na Docker Hub a môžu ho stiahnuť ostatní alebo nasadiť do rôznych prostredí.

Krok 4 – Vytvorenie manifestov Kubernetes na nasadenie aplikácie Python

Teraz budete musieť vytvoriť súbor manifestov Kubernetes pomocou Okteto na definovanie prostriedkov nasadenia, služby a príjmu údajov pre aplikáciu s názvom my-app.

nano k8s.yaml

Pridajte do súboru nasledujúcu konfiguráciu.

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

Vyššie uvedený súbor nasadí aplikáciu s názvom my-app pomocou Okteto, sprístupní ju interne prostredníctvom služby ClusterIP na porte 5000 a nastaví prostriedok Ingress na smerovanie prevádzky HTTP do aplikácie. Anotácie špecifické pre Okteto sa používajú na povolenie určitých funkcií poskytovaných Oktetom, ako je napríklad automatické generovanie názvov hostiteľov.

Krok 5 - Nainštalujte Okteto pomocou aplikácie Helm

Najprv je potrebné pridať úložisko Okteto Helm do svojho klienta Helm.

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

Po pridaní úložiska Okteto Helm by ste mali aktualizovať svoje úložiská Helm, aby ste sa uistili, že máte najnovšie informácie o dostupných grafoch:

helm repo update

Ďalej vytvorte config.yaml pre Okteto.

nano config.yaml

Pridajte svoj licenčný kľúč Okteto, subdoménu a ďalšiu konfiguráciu, ako je uvedené nižšie:

license: INSERTYOURKEYHERE
subdomain: okteto.example.com

buildkit:
  persistence:
    enabled: true

registry:
  storage:
    filesystem:
      persistence:
        enabled: true

nota:\nNahraďte licenčný kľúč platným licenčným kľúčom Okteto a okteto.example.com názvom svojej domény.

Teraz nainštalujte najnovšiu verziu Okteto pomocou konfiguračného súboru config.yaml.

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

Po nainštalovaní Okteto získate nasledujúci výstup.

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`

nota:\nPamätajte na osobné prístupové tokeny 88f8cc11 z vyššie uvedeného výstupu. Budete ho potrebovať na overenie Okteto.

Počkajte chvíľu a potom načítajte IP adresu, ktorú DigitalOcean dynamicky pridelil NGINX Ingress, ktorý ste práve nainštalovali a nakonfigurovali ako súčasť Okteto:

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

Zobrazí sa nasledujúci výstup.

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

Musíte vziať adresu EXTERNAL-IP a pridať ju do svojho DNS pre doménu, ktorú ste sa rozhodli použiť. To sa vykoná vytvorením záznamu A s názvom *.

Teraz otvorte webový prehliadač a prejdite na svoju inštanciu Okteto na https://okteto.okteto.example.com/login#token=88f8cc11.

Krok 6 - Nainštalujte a nakonfigurujte Okteto CLI

Okteto CLI je open-source nástroj príkazového riadka, ktorý vám umožňuje vyvíjať vaše aplikácie priamo na Kubernetes.

Okteto CLI môžete nainštalovať na Linux a macOS pomocou curl. Otvorte terminál a spustite nasledujúci príkaz:

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

Po dokončení inštalácie môžete spustením nasledujúceho príkazu overiť, či je Okteto CLI nainštalované správne:

okteto version

Tento príkaz zobrazí verziu Okteto CLI nainštalovanú vo vašom systéme.

okteto version 2.25.2

Ďalej budete musieť použiť svoje osobné prístupové tokeny na overenie pomocou Okteto CLI.

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

Jeho výstup bude:

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

Ďalej spustite nasledujúci príkaz a overte, či je vaše Okteto CLI nakonfigurované.

okteto context list

To dáva nasledujúci výstup:

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                                  -

Krok 7 - Vytvorte si Okteto Manifest

Ak chcete začať vyvíjať aplikáciu Python, budete musieť vytvoriť súbor manifestu Okteto a definovať konfiguráciu pre vaše vývojové prostredie.

Vytvorme súbor okteto.yaml pre jednoduchú aplikáciu v jazyku Python.

nano okteto.yaml

Pridajte nasledujúcu konfiguráciu.

deploy:
  - kubectl apply -f k8s.yaml

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

Vo vyššie uvedenom súbore

  • nasadenie: Táto časť definuje konfiguráciu nasadenia. Keď spustíte okteto up alebo okteto deploy, Okteto spustí príkaz kubectl apply -f k8s.yaml na nasadenie prostriedkov Kubernetes definovaných v súbore k8s.yaml. To vám umožní špecifikovať konfiguráciu nasadenia oddelene od konfigurácie vývojového prostredia.
  • command: bash: Určuje príkaz, ktorý sa spustí pri spustení vývojového prostredia.
  • environment: Určuje premenné prostredia, ktoré sa majú nastaviť vo vývojovom prostredí. V tomto prípade nastavuje FLASK_ENV vývoja.
  • sync: Určuje priečinky na synchronizáciu medzi lokálnym počítačom a vývojovým prostredím. Synchronizuje aktuálny adresár (.)s /app vo vývojovom prostredí.
  • reverse: Určuje pravidlá presmerovania portov na vystavenie portov z vývojového prostredia do lokálneho počítača. V tomto prípade presmeruje port 9000 z vývojového prostredia na port 9000 na lokálnom počítači.
  • volumes: Určuje ďalšie zväzky, ktoré sa majú pripojiť do vývojového prostredia. V tomto prípade pripojí adresár /root/.cache/pip, ktorý sa môže použiť na ukladanie balíkov pip do vyrovnávacej pamäte, do vývojového prostredia.

Teraz nasaďte aplikáciu v jazyku Python do klastra Kubernetes pomocou nasledujúceho príkazu.

okteto deploy

Po úspešnom nasadení sa zobrazí nasledujúci výstup.

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

Ďalej sa vráťte do webového prehliadača a obnovte dashboard Okteto. Zobrazí sa vaša nasadená aplikácia:

K aplikácii v jazyku Python môžete pristupovať aj pomocou adresy URL https://my-app-okteto-admin.okteto.example.com.

Krok 8 - Vývoj aplikácie Python priamo v Kubernetes

V tejto časti použijete príkaz okteto up na nasadenie aplikácie v jazyku Python priamo na Kubernetes. Tento príkaz synchronizuje váš lokálny kód s vývojovým prostredím. Kód môžete upraviť pomocou preferovaného integrovaného vývojového prostredia alebo textového editora na lokálnom počítači a zmeny sa automaticky synchronizujú s vývojovým prostredím v Kubernetes.

Začnime vývojové prostredie pomocou Okteto:

okteto up

Tento príkaz vytvorí vývojové prostredie na základe konfigurácií zadaných v súbore 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#

Ďalej spustite aplikáciu Python:

python3 app.py

Zobrazí sa nasledujúci výstup.

 * 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

Teraz upravte súbor prihlášky app.py:

nano app.py

Upravte nasledujúci riadok:

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

Uložte a zatvorte súbor. Okteto automaticky zistí zmeny kódu a okamžite ich použije na Kubernetes.

Vráťte sa do webového prehliadača a znova načítajte stránku pre aplikáciu v jazyku Python. Upravenú aplikáciu uvidíte na nasledujúcej obrazovke.

Záver

V tomto kurze ste vytvorili základnú aplikáciu v jazyku Python a nasadili ste ju do klastra Kubernetes pomocou Okteto. Schopnosť Okteto synchronizovať lokálne zmeny kódu s vývojovým prostredím v reálnom čase umožňuje rýchle vývojové iterácie a okamžitú spätnú väzbu o zmenách kódu. Celkovo Okteto umožňuje vývojárom zamerať sa na vytváranie vysokokvalitných aplikácií v jazyku Python bez obáv zo zložitosti infraštruktúry Kubernetes.

Autor si vybral FreeBSD Foundation na získanie daru v rámci programu Write for DOnations.

Súvisiace články: