Kubernetes (DOKS)

Introducción

La plataforma Devprime acelera la productividad de los desarrolladores de software al ofrecer un diseño completo de arquitectura de software, componentes con comportamientos inteligentes, aceleradores para la implementación de código y actualizaciones con nuevas funciones.

En este artículo, discutiremos el uso del servicio Kubernetes (DOKS) de DigitalOcean, una plataforma en la nube que ofrece varias funciones para que los desarrolladores de software las utilicen en sus aplicaciones.

Utilizaremos dos microservicios con una regla de negocio relacionada con los pedidos y otra con los pagos utilizando la base de datos MongoDB gestionada por DigitalOcean. Demostraremos los pasos para crear el microservicio, los servicios en la nube en DigitalOcean como Kubernetes (DOKS), Container Registry, MongoDB e implementar RabbitMQ directamente en Kubernetes, luego las configuraciones iniciales necesarias.

Lista de verificación y preparación del entorno inicial

• Abra una cuenta en Devprime Platform y compre una licencia Developer/Enterprise).
• Instale una versión actualizada de .NET (Linux, macOS y Windows).
• Instalar y/o actualizar Visual Studio Code y/o Visual Studio 2023 Community / Professional / Enterprise.
• Instalar o actualizar docker (Linux, macOS y Windows) (para Windows, use WSL2).
• Inicialice los [contenedores de MongoDB y RabbitMQ en docker] localmente. /../../quick-start/docker/) y agregar cola ‘orderevents’ y ‘paymentevents’ en RabbitMQ.
• Instale y active la última versión de la Devprime CLI.
• Crea una carpeta local para tus proyectos y establece permisos de lectura y escritura.
• Véase el artículo “Creación del primer microservicio” para explorar la introducción a la plataforma Devprime.
• Abra una cuenta en la nube en DigitalOcean (Su crédito de $200, ¡ha sido invitado a DigitalOcean! Regístrese y obtenga un crédito de $200 por 60 días para probar nuestros productos. ¡Gaste $ 25 después de que expire su crédito y quien lo haya recomendado obtendrá $ 25 en crédito!).

Empezar

En este artículo, usaremos un proyecto con dos Microservicios usando comunicación asincrónica, siendo el primer Order y el segundo Payment que puedes elegir crear desde cero o usando el ejemplo en GitHub.

a) Ejecute un clon del proyecto en GitHub:
git clone https://github.com/devprime/devprime-microservices-order-payment.git

b) Acceda a la carpeta clonada y verifique la carpeta de inicio con los elementos Pedido y Pago. Cada carpeta de este tiene un microservicio desarrollado con la plataforma Devprime y listo para usar.
cd devprime-microservices-order-payment
git remote remove origin

c) Ejecute el comando dp stack para aplicar update y su licencia de Devprime:
dp stack

d) Ejecute cada microservicio en una pestaña de terminal para realizar pruebas localmente utilizando los archivos .\run.ps1 en Windows o run.sh en Linux y macOS. Aplique el permiso chmod en Linux, macOS.
chmod +x run.sh

Para iniciar el microservicio, ejecute uno de los siguientes scripts:
.\run.ps1 (Windows) o ./run.sh (Linux, macOS)

• /ms-orden
• /ms-pago

Con los microservicios en ejecución, publique en la API de microservicio de pedidos y realice un seguimiento del procesamiento en el microservicio de pago, como se describe en el artículo sobre comunicación asincrónica entre microservicios.

Creación de un clúster de Kubernetes (DOKS), Container Registry y MongoDB en DigitalOcean

Accede a tu portal en DigitalOcean y en el menú de Kubernetes, ingresa a la opción Create Cluster para iniciar el procedimiento de creación y en el plan de nodos elige el tamaño adecuado para tu escenario, define el número de instancias y continúa con el proceso. Realice el mismo procedimiento con Container Registry y en Base de datos con MongoDB mediante la creación de los servicios iniciales para su uso en este artículo.

La siguiente imagen muestra una vista de los primeros servicios creados: MongoDB y Kubernetes.

Después de crear el clúster de MongoDB, es imprescindible acceder al elemento Connection String y copiarlo para utilizarlo en la configuración en los microservicios (pedido/pago). Copie toda la cadena de conexión y asegúrese de que tenga el nombre de usuario y la contraseña.

El clúster de Kubernetes se ha denominado “do-k8s-nyc1-demo” para su uso en este artículo. En el elemento de mercado, tiene algunas características interesantes para la implementación en el clúster mediante aplicaciones de 1 clic, como NGINX Ingress Controller, Cert-Manager, OpenEBS NFS Provisioner, Kubernetes Monitoring Stack.

Para publicar contenedores en Kubernetes, usaremos el Container Registry que en este tipo se denomina “dp-registry-nyc3”. Copie la url presentada en este punto, ya que la usaremos más adelante al crear la imagen del contenedor.

Ahora debe dar un paso importante al vincular su clúster de Kubernetes con Container Registry para facilitar el acceso a los contenedores dentro del clúster. En el portal de tu Kubernetes Router, ve a Configuración y luego ingresa a la opción “Integración de DigitalOcean Container Registry” y selecciona el Registro de Contenedores.

Instalación de herramientas para su uso en Kubernetes

Usaremos algunas herramientas para la integración con Kubernetes como kubectl, que es la CLI de Kubernetes, Helm, herramienta para instalar paquetes en Kubernetes, herramienta K9S para visualizar el clúster, Stern, herramienta para ver logs en Kubernetes, doctl, la herramienta de línea de comandos de DigitalOcean y docker.

Después de instalar la CLI de doctl, es esencial seguir los procedimientos de configuración de doctl para habilitar el acceso en DigitalOcean y habilitar operaciones como la obtención de credenciales de Container Registry y Kubernetes.

Obtener acceso a Kubernetes

Las credenciales de acceso al clúster de Kubernetes se pueden obtener a través del portal o mediante la CLI doctl, como haremos durante este artículo.

• La obtención de las credenciales de acceso al clúster al confirmar se guardará en el entorno local “.kube/config”. Copie este comando directamente desde el portal con el GUID del clúster.
  doctl kubernetes cluster kubeconfig save a61716c9-c207-4c23-b789-399a811ef050

• Enumeración de todos los pods del clúster
  kubectl get pods --all-namespaces

• Uso de k9s para ver el clúster
  k9s

En la imagen, enumeramos todos los contenedores activos implementados cuando se creó el clúster. En los siguientes pasos, comenzaremos a crear el contenedor de pedidos y pagos.

Creación de imágenes de docker y publicación en Container Registry

Un paso importante en el panorama de Kubernetes es construir la imagen de docker de nuestros microservicios para que podamos publicarlos dentro del entorno del clúster de Kubernetes.

Autenticación de docker en Container Registry
doctl registry login

Creación de la imagen de microservicio de pedido en docker

• Introduzca el primero del microservicio de pedido y ejecute
  /ms-order
docker build -t ms-order .

• Crea una etiqueta para esta imagen
  docker tag ms-order registry.digitalocean.com/dp-registry-nyc3/ms-order:latest

• Empujar a docker
  docker push registry.digitalocean.com/dp-registry-nyc3/ms-order:latest

Creación de la imagen del microservicio de pago en docker

• Ingrese a la segunda carpeta del microservicio de pago y ejecute
  /ms-payment
docker build -t ms-payment .

• Crea una etiqueta para esta imagen
  docker tag ms-payment registry.digitalocean.com/dp-registry-nyc3/ms-payment:latest

• Empujar a docker
  docker push registry.digitalocean.com/dp-registry-nyc3/ms-payment:latest

Al final de este procedimiento push en las imágenes de pedido y pago, será posible verificarlas en el portal de Container Registry y estarán listas
para su uso en Kubernetes.

Implementación de RabbitMQ en Kubernetes

La plataforma Devprime permite la conectividad a varios servicios Stream con RabbitMQ, Kafka y otros y en este proyecto usaremos helm para desplegar RabbitMQ en el clúster. Dependiendo del escenario de su proyecto, puede optar por utilizar el servicio gestionado de Kafka que ofrece Digital Ocean u otra alternativa para la comunicación entre microservicios.

Implementación de RabbitMQ mediante Helm. Cambie el nombre de usuario y la contraseña a su discreción.
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
helm install rabbitmq bitnami/rabbitmq --set auth.username=admin --set auth.password=MQ@passX6DP

El proceso de implementación de RabbitMQ tarda un tiempo en completarse y puede seguir a través de K9S. Después de la instalación, puede asignar los puertos de RabbitMQ en el entorno local al que se va a acceder. Antes de realizar la asignación, es fundamental detener el contenedor local de RabbiMQ para evitar conflictos de puertos TCP.

Puertos RabbitMQ

• Puerto AMQP de RabbitMQ:
  kubectl port-forward --namespace default svc/rabbitmq 5672:5672
• Interfaz de gestión web de RabbitMQ:
  kubectl port-forward --namespace default svc/rabbitmq 15672:15672

Configuración de la configuración inicial de RabbitMQ
Asigne el puerto 15672 y acceda al portal administrativo de RabbitMQ desde la http://localhost:15672 de url para configurar las colas ‘orderevents’ y ‘paymentevents’ en RabbitMQ y enlace al intercambio según la documentación de RabbitMQ en Devprime con el fin de habilitar este artículo.

Análisis de credenciales de MongoDB y RabbitMQ en entornos de microservicios locales

En el entorno local, puede editar la configuración y las credenciales de la aplicación en el archivo src/App/appsettings.json, como los datos de acceso de MongoDB y RabbitMQ utilizados en el proyecto y otros elementos disponibles en la documentación de configuración de Devprime.

Para abrir la configuración de cada microservicio, escriba la carpeta relacionada
/ms-order
/ms-payment

Abrir desde Visual Studio Code u otro editor
code src/App/appsettings.json

Visualice en la clave de RabbitMQ y MongoDB las credenciales utilizadas en el entorno local y se pueden modificar en cualquier momento.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

  "DevPrime_Stream": [
    {
      "Alias": "Stream1",
      "Enable": "true",
      "Default": "true",
      "StreamType": "RabbitMQ",
      "HostName": "Localhost",
      "User": "guest",
      "Password": "guest",
      "Port": "5672",
      "Exchange": "devprime",
      "ExchangeType": "direct",
      "Retry": "3",
      "Fallback": "State1",
      "Threads": "30",
      "Buffer": "1",
      "Subscribe": []
    }
  ],

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

  "DevPrime_State": [
    {
      "enable": "true",
      "alias": "State1",
      "type": "db",
      "dbtype": "mongodb",
      "connection": "mongodb://mongoadmin:LltF8Nx*yo@localhost:27017",
      "timeout": "5",
      "retry": "2",
      "dbname": "ms-order",
      "isssl": "true",
      "durationofbreak": "45"
    }
  ],

Configuración de credenciales de MongoDB y RabbitMQ en Kubernetes

En nuestro contexto, crearemos un archivo de desarrollo para cada microservicio y usaremos Devprime CLI para construir el archivo inicial deployment.yml y service.yml ejecutando el comando en la carpeta de cada microservicio y luego realizaremos la configuración con las credenciales que usaremos en los microservicios de orden y pago dentro del clúster de Kubernetes.

Vaya a cada carpeta de microservicio y ejecute “dp export kubernetes”
/ms-order
/ms-payment
dp export kubernetes

El resultado será similar al siguiente extracto con dos archivos creados con la configuración inicial necesaria para que podamos publicar
en Kubernetes.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

 ____             ____       _
|  _ \  _____   _|  _ \ _ __(_)_ __ ___   ___
| | | |/ _ \ \ / / |_)| '__| | '_ ` _ \ / _ \
| |_| |  __/\ V /|  __/| |  | | | | | | |  __/
|____/ \___| \_/ |_|   |_|  |_|_| |_| |_|\___|
  Empower developers. Accelerate productivity
==============================================
Welcome to the DevPrime CLI v8.0.8

Export configurations kubernetes

.devprime/kubernetes/deployment.yml' created
.devprime/kubernetes/service.yml' created

Ahora es el momento de editar el archivo “deployment.yml” y localizar
El elemento “imagen” en la carpeta de pedidos y en la carpeta de pagos.

Abra la carpeta en Visual Studio Code u otro editor
code .devprime

Archivo: deployment.yml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

apiVersion : apps/v1
kind: Deployment
metadata:
  name: ms-order
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ms-order
  template:
    metadata:
      labels:
        app: ms-order
    spec:
      containers:
        - name: ms-order 
          image: ms-order:latest

Realice el procedimiento para cada microservicio (pedido/pago) y cambie la imagen del elemento a la ruta de acceso de la imagen en Container Registry. La url
del Container Registry es el mismo que utiliza el comando docker push.

Archivo: order/deployment.yaml

1
2
3

      containers:
        - name: ms-order 
          image: registry.digitalocean.com/dp-registry-nyc3/ms-order:latest

Archivo: payment/deployment.yaml

1
2
3

      containers:
        - name: ms-order 
          image: registry.digitalocean.com/dp-registry-nyc3/ms-payment:latest

Ahora es el momento de configurar las credenciales de producción de RabbitMQ y RabbitMQ en cada microservicio.
MongoDB proporcionado por DigitalOcean y tratado al principio del archivo donde hablamos de la cadena de conexión.

Archivo:deployment.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

         env:
           - name: devprime_stream1
             value: "alias=Stream1|||enable=true|||default=true|||streamtype=RabbitMQ
        |||hostname=rabbitmq.default.svc|||user=admin|||password=guest|||port=5672|||
             exchange=devprime|||exchangetype=direct|||retry=3|||fallback=State1|||
             threads=30|||buffer=1"
           - name: devprime_state1
             value: "enable=true|||alias=State1|||type=db|||dbtype=mongodb|||
             connection=mongodb.default.svc|||timeout=5|||retry=2|||
             dbname=ms-order|||isssl=true|||durationofbreak=45"

En el punto devprime_stream1 cambie el usuario a “admin” y la contraseña a “MQ@passX6DP”.
en el elemento devprime_state1 cambie la conexión a la cadena de conexión de MongoDB en DigitalOean.

A continuación se puede ver un ejemplo después de los cambios que se deben realizar en los archivos de despliegue de microservicios (pedido/pago). Realice el cambio directamente en cada archivo para evitar modificar otros parámetros en esta demostración, ya que las claves tienen ligeras diferencias entre los microservicios.

Archivo:deployment.yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

         env:
           - name: devprime_stream1
             value: "alias=Stream1|||enable=true|||default=true|||streamtype=RabbitMQ|||
             hostname=rabbitmq.default.svc|||user=admin|||password=MQ@passX6DP|||
             port=5672|||exchange=devprime|||exchangetype=direct|||retry=3
             |||fallback=State1|||threads=30|||buffer=1"
           - name: devprime_state1
             value: "enable=true|||alias=State1|||type=db|||dbtype=mongodb|||
             connection=mongodb+srv://user:password@
             do-mongodb-nyc1-demo-29a3fecf.mongo.ondigitalocean.com/admin?
             tls=true&authSource=admin&replicaSet=do-mongodb-nyc1-demo|||timeout=5|||
             retry=2|||dbname=ms-order|||isssl=true|||durationofbreak=45"
           - name: Devprime_Custom

Implementación de microservicios en Kubernetes

Ahora ha llegado el momento más esperado, donde publicaremos efectivamente los microservicios (pedido y pago) dentro del cluster de Kubernetes y para ello utilizaremos los archivos deployment.yml y service.yml de cada microservicio.

Ingrese a cada carpeta y ejecute los siguientes comandos:

• Para el microservicio de pedido

  • Vaya a la carpeta de Kubernetes del servicio de pedidos:
    ms-order/.devprime/kubernetes
  • Aplicar la implementación y el servicio:
    kubectl apply -f deployment.yml
kubectl apply -f service.yml

• Para el microservicio de ayment

  • Vaya a la carpeta de Kubernetes del servicio de pago:
    ms-payment/.devprime/kubernetes
  • Aplicar la implementación y el servicio:
    kubectl apply -f deployment.yml
kubectl apply -f service.yml

Ahora que hemos terminado de implementar los dos microservicios, podemos verlo directamente en el clúster mediante la herramienta k9s o kubectl.

Realización de una prueba en el microservicio

Abra una pestaña de terminal y ejecute el comando port-forward para asignar el microservicio de pedido en el puerto local 8080 y permitirle realizar la primera prueba accediendo a la plataforma directamente en el clúster.

• Ejecute el comando para el pedido
  kubectl port-forward --namespace default svc/ms-order 8080:80

• Vaya a la URL y PUBLIQUE el microservicio de pedido para procesar y emitir un evento en la cola de RabbitMQ y propagarlo al microservicio de pago
  http://localhost:8080

Asignación de una dirección IP pública al microservicio de pedido

Abra el archivo ms-order/.devprime/kubernetes/service.yml con Visual Studio Code y cambie “ClusterIP” a “LoadBalancer”:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

apiVersion: v1
kind: Service
metadata:  
  name: ms-order
spec:
  selector:    
    app: ms-order
  type: LoadBalancer
  ports:  
  - name: http
    port: 80
    targetPort: 80

Eliminación del servicio ms-order:
kubectl delete svc ms-order

Volver a crear el servicio ms-order:
kubectl apply -f service.yml

Ahora consulte la actualización hasta que reciba una dirección IP pública en el microservicio de orden:
kubectl get svc ms-order -w

NAME       TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
ms-order   LoadBalancer   10.245.38.41   157.x.x.x   80:31256/TCP   2m32s

Visualización de registros en Kubernetes

Los microservicios basados en la plataforma Devprime proporcionan un enfoque de [observabilidad automática de registros distribuidos]. /../../features/observability/) que pueden ser visualizados por kubectl, k9s, stern e indexados en herramientas como SEQ, Elastic Search y muchas otras para rastrear el comportamiento de las aplicaciones en el entorno de producción.

En este ejemplo, usaremos la herramienta stern para ver el registro de cada implementación:

• Abra una pestaña para el microservicio “order” en el terminal y ejecute:
  stern ms-order
• Abra una pestaña para el microservicio de “pago” en el terminal y ejecute:
  stern ms-payment
• Ahora, use la asignación de puerto o IP pública y publique en el microservicio ‘order’ para verificar un resultado. En el siguiente registro, verás un resumen del “pedido” como ejemplo.

[INF][ms-order][Web]["http://*:80"][Host]["Production"][Parameters]["Environment"][RID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8][TID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8]
[INF][ms-order][Stream][Type "RabbitMQ"][Alias "Stream1"]["Enable"][RID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8][TID 30c1c7a9-7799-43e6-a1b2-5d4007b3edb8]
[INF][ms-order][Web]["HTTP"][Order][POST /v1/order][Origin "http://localhost/swagger/index.html"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][OrderService][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][ProcessEvent]["CreateOrder"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][EventHandler]["CreateOrderEventHandler"][Event]["CreateOrder"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][State][Type "MongoDB"][Alias "State1"][Initialize][OrderRepository][Add][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][State][Type "MongoDB"][Alias "State1"][Complete][OrderRepository][Add][Duration 1192.1472ms][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Domain][Order][ProcessEvent]["OrderCreated"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Application][EventHandler]["OrderCreatedEventHandler"][Event]["OrderCreated"][RID c1461cc3-7000-473d-a62c-915867954ced][TID c1461cc3-7000-473d-a62c-915867954ced]
[INF][ms-order][Stream][Type "RabbitMQ"][Alias "Stream1"][Out][Event]["OrderCreated"]["Delivered"]["orderevents"]
["{\""Payload\":{\"ID\":\"ca9983\",\"CustomerName\":\"Ramon Duraes\",\"CustomerTaxID\":\"AC875512\",\"Total\":1200}}"]

Reflexiones finales

Durante este artículo, demostramos la publicación de dos microservicios (pedido y pago) desarrollados utilizando la tecnología de la plataforma Devprime en el Kubernetes Cluster (DOKS) de DigitalOcean, en conjunto con los servicios administrados de Container Registry y MongoDB y RabbitMQ que desplegamos en el clúster usando Helm. También siguió cómo acceder al servicio mediante una dirección IP interna y una dirección IP externa y ver los registros.

En un entorno productivo, es imprescindible añadir un nginx ingress, un dominio de internet y Let’s Encrypt para generar un certificado SSL, utilizar un servicio DevOps para automatizar la publicación, bóveda digital para credenciales, protección de acceso con un API Gateway, proveedor de identidad y Web Application Firewall.

Más información

• Implementación de un microservicio Devprime en un droplet de DigitalOcean