Cómo implementar una aplicación Python en Kubernetes con Okteto

Introducción

Okteto es una plataforma de desarrollo que simplifica el proceso de desarrollo de aplicaciones de Kubernetes. Permite a los desarrolladores crear y probar sus aplicaciones directamente en clústeres de Kubernetes sin necesidad de configurar entornos de desarrollo locales complejos. Okteto permite actualizaciones en tiempo real de las aplicaciones que se ejecutan en clústeres de Kubernetes, lo que permite a los desarrolladores ver los cambios en su código en tiempo real sin tener que recompilar ni volver a implementar sus aplicaciones.

En este tutorial, creará una aplicación Python y la implementará en Kubernetes usando Okteto.

Requisitos previos

• Un clúster de Kubernetes 1.28
• kubectl está instalado y configurado para comunicarse con su clúster.
• Una cuenta de Docker Hub
• Docker se está ejecutando en su máquina local.
• Se requiere una licencia para usar Okteto. Para obtener una clave de licencia, regístrese para una prueba gratuita de 30 días de Okteto.
• El administrador de paquetes Helm está instalado en su máquina local.
• Un nombre de dominio completamente registrado que apunta al balanceador de carga utilizado por Nginx Ingress. Debe crear un registro A con el nombre * y la IP del balanceador de carga.

Paso 1: Crear un programa Python

Primero, debes asegurarte de que Python esté instalado en tu sistema Ubuntu. Puedes comprobarlo abriendo una terminal y escribiendo:

python3 --version

Si Python está instalado, este comando mostrará la versión de Python. De lo contrario, puede instalarlo con el siguiente comando:

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

Luego, cree un directorio para almacenar el código de la aplicación y otras configuraciones.

mkdir my-app

A continuación, vaya al directorio de su aplicación y cree un entorno virtual para aislar las dependencias de su proyecto.

cd my-app
python3 -m venv python-env

Luego active el entorno virtual utilizando el siguiente comando.

source python-env/bin/activate

A continuación, cree un nuevo archivo Python para su aplicación. Por ejemplo, cree un archivo app.py simple:

nano app.py

Añade el siguiente código:

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

A continuación, instale el marco web Flask.

pip install flask

Ahora ejecute su programa Python usando el siguiente comando.

python3 app.py

Verá el siguiente resultado.

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

Ahora que la aplicación Flask se está ejecutando localmente, puedes verificarla usando curl:

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

Debería obtener la siguiente respuesta de la aplicación Flask.

OutputHello, This is a simple Python App!

Una vez que haya terminado de trabajar en su proyecto, puede desactivar el entorno virtual ejecutando lo siguiente:

deactivate

En este punto, has creado un programa Python y lo has probado localmente.

Paso 2: Dockerizar la aplicación Python

Dockerizar una aplicación Python implica crear una imagen de Docker que contiene el entorno de Python y las dependencias necesarias para ejecutar la aplicación.

Primero, cree un archivo llamado Dockerfile en el directorio raíz de su aplicación Python.

nano Dockerfile

Añade el siguiente contenido:

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

En este Dockerfile:

• FROM python:3.8-slim: Especifica la imagen base que se usará. Estás usando una imagen oficial de Python con Python 3.8 instalado.
• WORKDIR /app: establece el directorio de trabajo dentro del contenedor en /app.
• Agregar . /app: copia el contenido del directorio actual a la carpeta /app del contenedor.
• EJECUTAR pip install flask: instala el marco Flask.
• EXPOSE 5000: expone el puerto 5000 para permitir conexiones entrantes.
• CMD [“python3″, “app.py”]: Especifica un comando que se ejecutará al iniciar el contenedor. En este caso, ejecuta la aplicación app.py.

Ahora ejecute el siguiente comando para construir la imagen según las instrucciones de su Dockerfile.

docker build -t my-app .

Después de crear la imagen de Docker, puede ejecutar su aplicación en un contenedor usando la imagen creada:

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

Este comando ejecuta un contenedor desde la imagen my-app y asigna el puerto del contenedor al puerto de host 5000.

Puede verificar el contenedor de su aplicación en ejecución utilizando el comando docker ps.

docker ps

La salida será:

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

Abra un navegador web o use curl para acceder a la aplicación mediante la URL http://your-server-ip:5000. Debería ver el mensaje "Hola, ¡esta es una aplicación Python simple!", que indica que su aplicación Python se ejecuta dentro de un contenedor Docker.

Ahora has acoplado con éxito tu aplicación Python a Docker.

Paso 3: Insertar la imagen de Python Docker en el registro de DockerHub

Primero, necesitas una cuenta de DockerHub. Si no tienes una, puedes crearla en el sitio web de DockerHub.

Para iniciar sesión en Docker Hub, usa el comando docker login. Se te pedirá que ingreses tu nombre de usuario y contraseña de Docker Hub.

docker login

La salida de este comando será la siguiente:

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

Antes de enviar la imagen a Docker Hub, también debes etiquetarla con tu nombre de usuario de Docker Hub y el nombre del repositorio deseado.

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

Ahora puedes enviar tu imagen Docker a Docker Hub usando el comando docker push.

docker push yourusername/my-app:latest

Después de enviar la imagen, puede verificar que esté disponible en Docker Hub buscándola mediante la CLI de Docker Hub.

docker search yourusername/my-app

Su imagen Docker de la aplicación Python ahora está disponible en Docker Hub y otros pueden extraerla o implementarla en diferentes entornos.

Paso 4: Crear manifiestos de Kubernetes para implementar la aplicación Python

Ahora necesita crear un archivo de manifiesto de Kubernetes usando Okteto para definir los recursos de implementación, servicio y entrada para una aplicación llamada my-app.

nano k8s.yaml

Añade la siguiente configuración al archivo.

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

El archivo anterior implementa una aplicación llamada my-app que usa Okteto, la expone internamente mediante un servicio ClusterIP en el puerto 5000 y configura un recurso Ingress para dirigir el tráfico HTTP a la aplicación. Las anotaciones específicas de Okteto se utilizan para habilitar algunas funciones que ofrece, como la generación automática de nombres de host.

Paso 5 – Instalar Okteto usando Helm

Primero, debe agregar el repositorio Okteto Helm a su cliente Helm.

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

Una vez que haya agregado el repositorio Helm de Okteto, deberá actualizar sus repositorios Helm para asegurarse de tener la información más reciente sobre los gráficos disponibles:

helm repo update

Luego crea un config.yaml para Okteto.

nano config.yaml

Agregue la clave de licencia de Okteto, el subdominio y otras configuraciones como se muestra a continuación:

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

Ahora, instale la última versión de Okteto usando el archivo de configuración config.yaml.

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

Después de instalar Okteto, obtendrá el siguiente resultado.

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`

Espere un momento y luego asigne la dirección IP que DigitalOcean asignó dinámicamente al NGINX Ingress que acaba de instalar y configurar como parte de Okteto:

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

Verá el siguiente resultado.

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

Debes tomar la dirección IP EXTERNA y agregarla a tu DNS para el dominio que hayas elegido. Esto se hace creando un registro A llamado *.

Ahora, abra su navegador web y acceda a su instancia de Okteto en https://okteto.okteto.example.com/login#token=88f8cc11.

Paso 6: Instalar y configurar Okteto CLI

Okteto CLI es una herramienta de línea de comandos de código abierto que le permite desarrollar sus aplicaciones directamente en Kubernetes.

Puedes instalar Okteto CLI en Linux y macOS usando curl. Abre tu terminal y ejecuta el siguiente comando:

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

Una vez completada la instalación, puede verificar que Okteto CLI esté instalado correctamente ejecutando el siguiente comando:

okteto version

Este comando muestra la versión de Okteto CLI instalada en su sistema.

Outputokteto version 2.25.2

A continuación, deberá utilizar sus códigos de acceso personales para autenticarse con la CLI de Okteto.

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

Su salida será:

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

Luego, ejecute el siguiente comando para asegurarse de que su CLI de Okteto esté configurado.

okteto context list

Esto da el siguiente resultado:

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 -

Paso 7 – Crea tu manifiesto Okteto

Para comenzar a desarrollar una aplicación Python, debe crear un archivo de manifiesto Okteto y definir la configuración para su entorno de desarrollo.

Creemos un archivo okteto.yaml para una aplicación Python simple.

nano okteto.yaml

Añade la siguiente configuración.

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

En el archivo anterior:

• Implementar: Esta sección define la configuración de implementación. Al ejecutar okteto up u okteto deploy, Okteto ejecuta el comando kubectl application -f k8s.yaml para implementar los recursos de Kubernetes definidos en el archivo k8s.yaml. Esto permite especificar la configuración de implementación independientemente de la configuración del entorno de desarrollo.
• comando: bash: especifica un comando que se ejecutará cuando se inicie el entorno de desarrollo.
• Entorno: Especifica las variables de entorno que se configurarán en el entorno de desarrollo. En este caso, FLASK_ENV se configura como desarrollo.
• SYNC: Especifica las carpetas que se sincronizarán entre el equipo local y el entorno de desarrollo. Sincroniza el directorio actual (.) con /app dentro del entorno de desarrollo.
• Invertir: Especifica reglas de reenvío de puertos para exponer los puertos del entorno de desarrollo a su equipo local. En este caso, reenvía el puerto 9000 del entorno de desarrollo al puerto 9000 de su equipo local.
• volúmenes: Especifica volúmenes adicionales para instalar en el entorno de desarrollo. En este caso, instala el directorio /root/.cache/pip, que puede usarse para almacenar en caché los paquetes pip, en el entorno de desarrollo.

Ahora implemente su aplicación Python en el clúster de Kubernetes usando el siguiente comando.

okteto deploy

Después de una implementación exitosa, verá el siguiente resultado.

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

Luego, vuelve a tu navegador web y actualiza el panel de Okteto. Verás tu aplicación implementada:

También puede acceder a su aplicación Python utilizando la URL https://my-app-okteto-admin.okteto.example.com.

Paso 8: Desarrollar la aplicación Python directamente en Kubernetes

En esta sección, usará el comando okteto up para implementar una aplicación Python directamente en Kubernetes. Este comando sincronizará su código local con el entorno de desarrollo. Puede modificar el código con su IDE o editor de texto preferido en su equipo local, y los cambios se sincronizarán automáticamente con el entorno de desarrollo en Kubernetes.

Comencemos el entorno de desarrollo usando Okteto:

okteto up

Este comando crea un entorno de desarrollo basado en la configuración especificada en el archivo okteto.yaml.

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#

A continuación, ejecute su programa Python:

python3 app.py

Verá el siguiente resultado.

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

Ahora, edite su archivo de aplicación app.py:

nano app.py

Modifique la siguiente línea:

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

Guarde y cierre el archivo. Okteto detectará automáticamente los cambios en el código y los aplicará inmediatamente a Kubernetes.

Regresa a tu navegador web y recarga la página de tu programa Python. Verás tu programa modificado en la página siguiente.

Resultado

En este tutorial, creaste una aplicación básica de Python y la implementaste en un clúster de Kubernetes con Okteto. La capacidad de Okteto para sincronizar los cambios de código local con el entorno de desarrollo en tiempo real permite iteraciones de desarrollo rápidas y retroalimentación inmediata sobre los cambios de código. En resumen, Okteto permite a los desarrolladores centrarse en crear aplicaciones Python de alta calidad sin preocuparse por las complejidades de la infraestructura de Kubernetes.