Compartir comentarios
Las respuestas se generan en base a la documentación.

Probar tu despliegue de Python

Tabla de contenidos

Requisitos previos

Descripción general

En esta sección, aprenderás a usar Docker Desktop para desplegar tu aplicación en un entorno Kubernetes con todas las funciones en tu máquina de desarrollo. Esto te permite probar y depurar tus cargas de trabajo en Kubernetes localmente antes de realizar el despliegue.

Crear un archivo YAML de Kubernetes

En tu directorio python-docker-dev-example, crea un archivo llamado docker-postgres-kubernetes.yaml. Abre el archivo en un IDE o editor de texto y agrega el siguiente contenido.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:18
          ports:
            - containerPort: 5432
          env:
            - name: POSTGRES_DB
              value: example
            - name: POSTGRES_USER
              value: postgres
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: postgres-secret
                  key: POSTGRES_PASSWORD
          volumeMounts:
            - name: postgres-data
              mountPath: /var/lib/postgresql
      volumes:
        - name: postgres-data
          persistentVolumeClaim:
            claimName: postgres-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: postgres
  namespace: default
spec:
  ports:
    - port: 5432
  selector:
    app: postgres
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
  namespace: default
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: v1
kind: Secret
metadata:
  name: postgres-secret
  namespace: default
type: Opaque
data:
  POSTGRES_PASSWORD: cG9zdGdyZXNfcGFzc3dvcmQ= # Contraseña codificada en Base64 (por ejemplo, 'postgres_password')

En tu directorio python-docker-dev-example, crea un archivo llamado docker-python-kubernetes.yaml. Reemplaza DOCKER_USERNAME/REPO_NAME con tu usuario de Docker y el nombre del repositorio que creaste en Configurar CI/CD para tu aplicación Python.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: docker-python-demo
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      service: fastapi
  template:
    metadata:
      labels:
        service: fastapi
    spec:
      containers:
        - name: fastapi-service
          image: DOCKER_USERNAME/REPO_NAME
          imagePullPolicy: Always
          env:
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: postgres-secret
                  key: POSTGRES_PASSWORD
            - name: POSTGRES_USER
              value: postgres
            - name: POSTGRES_DB
              value: example
            - name: POSTGRES_SERVER
              value: postgres
            - name: POSTGRES_PORT
              value: "5432"
          ports:
            - containerPort: 8001
---
apiVersion: v1
kind: Service
metadata:
  name: service-entrypoint
  namespace: default
spec:
  type: NodePort
  selector:
    service: fastapi
  ports:
    - port: 8001
      targetPort: 8001
      nodePort: 30001

En estos archivos YAML de Kubernetes, hay varios objetos, separados por ---:

  • Un Deployment (Despliegue), que describe un grupo escalable de pods idénticos. En este caso, obtendrás solo una réplica o copia de tu pod. Ese pod, que se describe en template, tiene un solo contenedor dentro. El contenedor se crea a partir de la imagen compilada por GitHub Actions en Configurar CI/CD para tu aplicación Python.
  • Un Service (Servicio), que definirá cómo se mapean los puertos en los contenedores.
  • Un PersistentVolumeClaim (Reclamación de Volumen Persistente), para definir un almacenamiento que será persistente a través de los reinicios para la base de datos.
  • Un Secret (Secreto), que mantiene la contraseña de la base de datos como un ejemplo utilizando el recurso secreto de Kubernetes.
  • Un servicio NodePort, que enrutará el tráfico desde el puerto 30001 en tu host al puerto 8001 dentro de los pods a los que se dirige, lo que te permite acceder a tu aplicación desde la red.

Para obtener más información sobre los objetos de Kubernetes, consulta la documentación de Kubernetes.

Note

Desplegar y comprobar tu aplicación

  1. En una terminal, navega a python-docker-dev-example y despliega tu base de datos en Kubernetes.

    $ kubectl apply -f docker-postgres-kubernetes.yaml

    Deberías ver una salida similar a la siguiente, que indica que tus objetos de Kubernetes se crearon correctamente.

    deployment.apps/postgres created
service/postgres created
persistentvolumeclaim/postgres-pvc created
secret/postgres-secret created

    Ahora, despliega tu aplicación Python.

    $ kubectl apply -f docker-python-kubernetes.yaml

    Deberías ver una salida similar a la siguiente, que indica que tus objetos de Kubernetes se crearon correctamente.

    deployment.apps/docker-python-demo created
service/service-entrypoint created

  2. Asegúrate de que todo haya funcionado listando tus despliegues.

    $ kubectl get deployments

    Tu despliegue debería aparecer de la siguiente manera:

    NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
docker-python-demo   1/1     1            1           48s
postgres             1/1     1            1           2m39s

    Esto indica que todos los pods que solicitaste en tu YAML están listos y en ejecución. Realiza la misma comprobación para tus servicios.

    $ kubectl get services

    Deberías obtener una salida como la siguiente.

    NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
kubernetes           ClusterIP   10.43.0.1      <none>        443/TCP          13h
postgres             ClusterIP   10.43.209.25   <none>        5432/TCP         3m10s
service-entrypoint   NodePort    10.43.67.120   <none>        8001:30001/TCP   79s

    Además del servicio predeterminado kubernetes, puedes ver tu servicio service-entrypoint, que acepta tráfico en el puerto 30001/TCP, y el ClusterIP interno postgres con el puerto 5432 abierto para aceptar conexiones desde tu aplicación Python.

  3. En una terminal, realiza un curl al servicio. Ten en cuenta que en este ejemplo no se desplegó una base de datos.

    $ curl http://localhost:30001/
Hello, Docker!!!

  4. Ejecuta los siguientes comandos para eliminar tu aplicación.

    $ kubectl delete -f docker-python-kubernetes.yaml
$ kubectl delete -f docker-postgres-kubernetes.yaml

Resumen

En esta sección, aprendiste a usar Docker Desktop para desplegar tu aplicación en un entorno Kubernetes con todas las funciones en tu máquina de desarrollo.

Información relacionada: