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

Prueba tu despliegue de Rust

Tabla de contenidos

Prerrequisitos

Resumen

En esta sección, aprenderás cómo utilizar 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 de forma local antes de realizar el despliegue.

Crea un archivo YAML de Kubernetes

En tu directorio docker-rust-postgres, crea un archivo llamado docker-rust-kubernetes.yaml. Abre el archivo en un IDE o editor de texto y añade el siguiente contenido. Reemplaza DOCKER_USERNAME/REPO_NAME con tu nombre de usuario de Docker y el nombre del repositorio que creaste en Configura CI/CD para tu aplicación Rust.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    service: server
  name: server
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      service: server
  strategy: {}
  template:
    metadata:
      labels:
        service: server
    spec:
      initContainers:
        - name: wait-for-db
          image: busybox:1.28
          command:
            [
              "sh",
              "-c",
              'until nc -zv db 5432; do echo "esperando a la db"; sleep 2; done;',
            ]
      containers:
        - image: DOCKER_USERNAME/REPO_NAME
          name: server
          imagePullPolicy: Always
          ports:
            - containerPort: 8000
              hostPort: 5000
              protocol: TCP
          env:
            - name: ADDRESS
              value: 0.0.0.0:8000
            - name: PG_DBNAME
              value: example
            - name: PG_HOST
              value: db
            - name: PG_PASSWORD
              value: mysecretpassword
            - name: PG_USER
              value: postgres
            - name: RUST_LOG
              value: debug
          resources: {}
      restartPolicy: Always
status: {}
---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    service: db
  name: db
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      service: db
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        service: db
    spec:
      containers:
        - env:
            - name: POSTGRES_DB
              value: example
            - name: POSTGRES_PASSWORD
              value: mysecretpassword
            - name: POSTGRES_USER
              value: postgres
          image: postgres:18
          name: db
          ports:
            - containerPort: 5432
              protocol: TCP
          resources: {}
      restartPolicy: Always
status: {}
---
apiVersion: v1
kind: Service
metadata:
  labels:
    service: server
  name: server
  namespace: default
spec:
  type: NodePort
  ports:
    - name: "5000"
      port: 5000
      targetPort: 8000
      nodePort: 30001
  selector:
    service: server
status:
  loadBalancer: {}
---
apiVersion: v1
kind: Service
metadata:
  labels:
    service: db
  name: db
  namespace: default
spec:
  ports:
    - name: "5432"
      port: 5432
      targetPort: 5432
  selector:
    service: db
status:
  loadBalancer: {}

En este archivo YAML de Kubernetes hay cuatro objetos, separados por ---. Además de un Service y un Deployment para la base de datos, los otros dos objetos son:

  • Un Deployment, 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 bajo template, tiene un solo contenedor. El contenedor se crea a partir de la imagen construida por GitHub Actions en Configura CI/CD para tu aplicación Rust.
  • Un servicio NodePort, que enrutará el tráfico desde el puerto 30001 en tu host hacia el puerto 5000 dentro de los pods a los que apunta, permitiéndote 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.

Despliega y comprueba tu aplicación

  1. En una terminal, navega a docker-rust-postgres y despliega tu aplicación en Kubernetes.

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

    Deberías ver una salida que se parezca a la siguiente, indicando que tus objetos de Kubernetes se crearon con éxito.

    deployment.apps/server created
deployment.apps/db created
service/server created
service/db created

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

    $ kubectl get deployments

    Tu despliegue debería aparecer en la lista de la siguiente manera:

    NAME                 READY   UP-TO-DATE   AVAILABLE   AGE
db       1/1     1            1           2m21s
server   1/1     1            1           2m21s

    Esto indica que todos los pods que solicitaste en tu YAML están en funcionamiento. 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
db           ClusterIP   10.105.167.81    <none>        5432/TCP         109s
kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP          9d
server       NodePort    10.101.235.213   <none>        5000:30001/TCP   109s

    Además del servicio kubernetes predeterminado, puedes ver tu servicio server, aceptando tráfico en el puerto 30001/TCP.

  3. En una terminal, haz curl al servicio.

    $ curl http://localhost:30001/users
[{"id":1,"login":"root"}]

  4. Ejecuta el siguiente comando para eliminar tu aplicación.

    $ kubectl delete -f docker-rust-kubernetes.yaml

Resumen

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

Información relacionada: