Gota

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.

Durante este artículo, usaremos un microservicio con una regla de negocio relacionada con el pedido, una base de datos en MongoDB. Te guiaremos a través de los pasos para crear el microservicio, los servicios de alojamiento en DigitalOcean y, a continuación, la configuración que necesitas para que esté disponible con el plan gratuito.

Lista de verificación y preparación del entorno local 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.
• Instale y/o actualice docker (para Windows, use WSL2).
• Inicializar contenedores MongoDB y RabbitMQ usando docker y agregue la cola ‘orderevents’ usando RabbitMQ.
• Instale y active la última versión de la Devprime CLI.
• Crea una carpeta para tus proyectos y establece permisos de lectura y escritura.
• Véase el artículo “Creación del primer microservicio” para explorar cómo empezar a trabajar con la plataforma Devprime.
• Abra una cuenta en la nube en DigitalOcean
  (Tu crédito de $200, ¡has 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!)

Creación de un microservicio para usar en el ejemplo

El primer paso es crear un nuevo microservicio para usarlo como plantilla para publicar en la nube. El nombre de este microservicio se establecerá en “ms-order”, y usaremos la base de datos MongoDB y el flujo RabbitMQ, como se muestra en el siguiente comando.

• Crea una carpeta llamada \do e introdúcela.
• Ejecute la CLI de Devprime para crear el primer microservicio:
  dp new ms-order --stream rabbitmq --state MongoDB
  
• Agregue una regla de negocio de ejemplo “Order” con el comportamiento de una clase raíz agregada y otra clase de entidad. Vaya a la carpeta \do\ms-order y escriba:
  dp marketplace order
• Habilite el acelerador de la CLI de Devprime para crear implementaciones del microservicio, como el repositorio, el servicio de aplicaciones, la exposición de API y la comunicación entre capas de aplicación:
  dp init

Una vez creado el nuevo microservicio, vaya a la carpeta del proyecto “ms-order” y podrá ver todas las implementaciones de Visual Studio Code, como se muestra en el artículo relacionado con creación del primer microservicio.

Para abrir en Visual Studio Code:
code .

En este momento no usaremos RabbitMQ y lo desactivaremos en la Configuración del adaptador de flujo a través del archivo de configuración en src\App\appsettings.json.

1. Vaya a la nueva carpeta ms-order y ábrala desde Visual Studio Code
   code src\App\appsettings.json
2. Localiza la tecla “DevPrime_Stream” y en la opción “Habilitar” pon “false”.
3. Cambie el controlador “OrderCreated” comentando la línea “Dp.Stream.Send(destination, eventName, eventData);” para que el flujo no envíe ningún evento.

Abrir el controlador desde Visual Studio Code
src\Core\Application\EventHandlers\Order\OrderCreatedEventHandler.cs

Ejecución del nuevo microservicio Order

Los pasos anteriores habilitan un microservicio listo para producción con las reglas de negocio obtenidas del marketplace de Devprime.

permiso chmod en Linux, macOS
Para ejecutar el archivo “.sh” en (Linux, macOS) debe agregar el permiso a continuación para que el script sea ejecutable.
chmod +x run.sh

Inicie el microservicio ejecutando uno de los siguientes scripts:
.\run.ps1 (Windows) ou ./run.sh (Linux, macOS)

El microservicio se puede ejecutar localmente en entornos Linux, macOS y Windows, como se muestra en el ejemplo siguiente:

Al acceder a la API de microservicios ms-order, ya tenemos implementada una “OpenAPI”.

Accediendo al archivo de configuración del microservicio

En el entorno local, puede editar, si es necesario, 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.

Para abrir en Visual Studio Code:
code src/App/appsettings.json

Creación de un nuevo Droplet y MongoDB en DigitalOcean

El siguiente paso es crear un nuevo Droplet utilizando la imagen “Ubuntu 23.10 x64” como base, eligiendo la configuración básica de 1 CPU y 512 MB de RAM. Una característica interesante de esta máquina virtual de DigitalOcean es la velocidad de aprovisionamiento, que ya está disponible en segundos.

Durante la creación, recuerde habilitar la opción “Agregar monitoreo y alertas de métricas mejoradas (gratis)” para permitir una mejor visualización de las métricas.

Tiene la opción de implementar servicios directamente en su Droplet, pero dado que DigitalOcean ofrece algunas otras funciones administradas y para los fines de esta demostración, crearemos una instancia de MongoDB.

A continuación puede ver el resumen del panel de control en DigitalOcean con los tres servicios creados (Droplet, MongoDB) y disponibles para su uso.

El siguiente paso es obtener las credenciales de MongoDB y las cadenas de conexión “db-mongodb-nyc1-demo” para agregarlas al archivo de configuración en el microservicio.

A continuación, localice el elemento DevPrime_State y, en conexión, agregue los datos de conexión de la base de datos db-mongo-nyc1-demo.

Abrir Configuración
code src\App\appsettings.json

 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"
    }
  ],

En este punto, puede volver a ejecutar la aplicación y hacer una publicación utilizando la API. Si las credenciales son correctas, ya está accediendo a la base de datos.

Instalación de .NET Runtime o SDK en Droplet en DigitalOcean

Una aplicación basada en la plataforma .NET puede ejecutarse en Linux, macOS y Windows. Tenemos la opción de instalar solo el Runtime o elegir el SDK cuando se quiera construir dentro del propio entorno de la máquina virtual (DROPLET).

En este artículo, vamos a tomar la opción Runtime. Para ello, basta con acceder al portal de DigitalOcean, en el terminal, y/o utilizar una herramienta SSH o Putty en Windows.

1
2

sudo apt-get update && \
  sudo apt-get install -y aspnetcore-runtime-8.0

Instalar el SDK de .NET o .NET Runtime en Ubuntu

Exportación de microservicios y publicación a DigitalOcean

Compilaremos el microservicio localmente y, a continuación, lo enviaremos mediante cualquier cliente FTP. Nos conectamos a FTP usando el protocolo SFTP en el puerto 22, usando el nombre de usuario “root” y la contraseña informada en la creación del Droplet.

Antes de publicar, cambiaremos el puerto predeterminado utilizado en el archivo de configuración. Para ello, busque el elemento “DevPrime_Web” y, en URL, mantenga solo el valor "url": "http://*:80".

Abra Configuración:
code src\App\appsettings.json

Ahora, vaya a la carpeta raíz del proyecto y ejecute el comando publish para que .NET exporte una versión publicable mediante .NET Runtime en la salida de la carpeta de salida en el parámetro -o.

Ejecute el comando:
dotnet publish .\src\App\App.csproj -c Release -o output

Introduce el droplet desde el terminal usando SSH y crea una carpeta en la raíz:
/devprime

Utilice FTP para enviar el contenido de la carpeta local ms-order/output a la carpeta de destino /devprime.

En el terminal, ejecute la aplicación dentro de la carpeta /devprime:
dotnet App.dll

Acceso al microservicio a través de la Internet pública

Cuando se usa un Droplet, la implementación deja todos los puertos abiertos. Dado que configuramos la URL “http://*:80” con el puerto 80 en el adaptador web, ahora puede acceder a ella directamente desde la IP de Droplet. Para usar SSL, debe configurar un dominio para la IP de Droplet y usar un Nginx con Let’s Encrypt, por ejemplo, para generar un certificado.

Acceda a su Droplet y obtenga la IP pública para acceder solo por HTTP, por ejemplo, http://127.0.0.1, donde 127.0.0.1 será su IP de Droplet. Al final de la prueba, detenga la aplicación para continuar con el siguiente paso.

Configuración del microservicio como servicio en Linux

Una característica importante al trabajar con la aplicación dentro de un entorno como Droplet/máquina virtual es configurar la aplicación como un servicio para asegurarse de que continúa ejecutándose incluso si se reinicia el entorno.

1. Abra nano para agregar el código del servicio devprime:
   sudo nano /etc/systemd/system/devprime.service

Agregue el contenido a continuación y comience a ahorrar.

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

[Unit]
Description=Order Microservice
After=network.target

[Service]
WorkingDirectory=/devprime
ExecStart=/usr/bin/dotnet /devprime/App.dll
Restart=always
# Define o tempo limite de inatividade (em segundos)
TimeoutStopSec=30
RestartSec=5

[Install]
WantedBy=multi-user.target

2. Reinicie el demonio:
   sudo systemctl daemon-reload

3. Habilite el nuevo servicio devprime:
   sudo systemctl enable devprime

4. Inicio del servicio. Llegados a este punto, puedes volver a acceder desde la web:
   sudo systemctl start devprime

5. Comprobación del estado:
   sudo systemctl status devprime

6. Opcional para reiniciar el servicio cuando sea necesario:
   sudo systemctl restart devprime

7. Seguimiento de registros de microservicios:
   sudo journalctl -f -u devprime

8. Opcional, si no tiene registros en el ítem 7:
   sudo systemctl restart systemd-journald

En este punto, puede ejecutar una cURL internamente y confirmar que el servicio se está ejecutando. Incluso puede reiniciar el Droplet y volver a probar la conectividad interna y externa validando que el servicio se inició por sí solo.
curl -X GET http://127.0.0.1:80

Agregar un certificado SSL usando Nginx

Para usar HTTPS, debe tener un dominio configurado y apuntar a su IP de Droplet. Este dominio se puede configurar dentro de DigitalOcean en MANAGE > Networking > Domains o externamente. En esta guía, usaremos un subdominio llamado “do.devprime.io”.

Es importante recordar que Nginx se ejecutará en los puertos 80/443. Debido a esto, moveremos nuestro microservicio al puerto 5000, ya que el acceso a él será realizado por Nginx internamente y ya no estará expuesto directamente.

1. Abra la configuración de su proyecto y cambie el elemento de URL a "url": "http://*:5000". Puede hacer esto en el proyecto original según los pasos anteriores y volver a publicar a través de FTP o editar el appsettings.json dentro del Droplet.
   nano appsettings.json

2. Reinicie el microservicio.
   sudo systemctl restart devprime

3. Instalación de Nginx en Droplet.
   sudo apt update && sudo apt install nginx

4. Comprobación del estado.
   sudo systemctl status nginx

5. Hacer de Nginx un servicio.
   sudo systemctl enable nginx

6. Instalación de Certbot y el plugin Nginx.
   sudo apt update && sudo apt install certbot
sudo apt install python3-certbot-nginx

7. Creación del certificado SSL Let’s Encrypt. No se ejecute antes de validar la propagación de su DNS a la IP de droplet. Recuerde modificar el nombre de dominio en los siguientes elementos.
   sudo certbot certonly --nginx -d do.devprime.io --email your-email@your-domain.com

8. Usa tu dominio en Nginx.
   sudo nano /etc/nginx/sites-available/do.devprime.io

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   server { listen 80; server_name do.devprime.io; location / { proxy_pass http://localhost:5000; # Porta interna da sua aplicação proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection keep-alive; proxy_set_header Host $host; proxy_cache_bypass $http_upgrade; } } server { listen 443 ssl; server_name do.devprime.io; ssl_certificate /etc/letsencrypt/live/do.devprime.io/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/do.devprime.io/privkey.pem; location / { proxy_pass http://localhost:5000; # Porta interna da sua aplicação proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection keep-alive; proxy_set_header Host $host; proxy_cache_bypass $http_upgrade; } }

9. Crea un enlace simbólico.
   sudo ln -s /etc/nginx/sites-available/do.devprime.io /etc/nginx/sites-enabled/

10. Valide la configuración de Nginx.
    sudo nginx -t

11. Reinicie Nginx.
    sudo systemctl restart nginx

12. Acceda a la URL pública del sitio nuevamente, pero usando https o use el comando
    a continuación para verificar los detalles de la conexión, recordando cambiar la URL. El retorno del registro muestra el uso de Let’s Encrypt SSL.
    curl -v https://do.devprime.io

* processing: https://do.devprime.tech
* Connected to do.devprime.io (x.x.x.x) port 443
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384
* ALPN: server accepted http/1.1
* Server certificate:
*  subject: CN=do.devprime.tech
*  start date: Apr 10 15:28:12 2024 GMT
*  expire date: Jul  9 15:28:11 2024 GMT
*  subjectAltName: host "do.devprime.io" matched cert's "do.devprime.io"
*  issuer: C=US; O=Let's Encrypt; CN=R3
*  SSL certificate verify ok.
* using HTTP/1.1
> GET / HTTP/1.1
> Host: do.devprime.io
> User-Agent: curl/8.2.1
< HTTP/1.1 200 OK
< Server: nginx/1.24.0 (Ubuntu)
< Connection: keep-alive
<div style='text-align:center;padding:10px;margin:10px;color:#512da8'>
    <h1>Welcome to DevPrime! </h1>
    <p>Microservice ms-order : 57f36e89-2b14-490f-81b2-a46a814830bf</p>
    <p><a href='/swagger/index.html'>Go to OpenApi</a></p>

12. Edite el crontab y habilite la renovación automática del certificado SSL Let’s Encrypt.
    crontab -e

    1	0 0 * * * /usr/bin/certbot renew --quiet

13. Listado del crontab activo.

    1 2	crontab -l sudo ls /etc/cron.d/

14. Habilitación del cortafuegos.
    En este ejemplo, puede habilitar el firewall mediante el firewall sin complicaciones (UFW) disponible en Linux, liberando los puertos 80/443/22 siguiendo los pasos enumerados.

    1 2 3 4 5 6 7 8 9 10 11

    # Habilitar ufw allow http ufw allow https ufw allow ssh ufw enable # Status ufw status verbose # Desligar ufw disable

Reflexiones finales

Durante este artículo, aprendió a implementar un microservicio desarrollado con la tecnología de plataforma Devprime en un Droplet de Linux DigitalOcean. Mostramos un tutorial básico que básicamente consiste en instalar el entorno de ejecución de .NET y copiar el proyecto compilado. Las otras configuraciones son características adicionales de Linux para una mejor experiencia al ejecutar la aplicación.

En un entorno productivo, se recomienda encarecidamente utilizar un almacén para las credenciales y una estrategia de DevOps sólida para orquestar todas las publicaciones de forma automática.

Para obtener más información:

• Implementación de un microservicio Devprime en DigitalOcean Kubernetes (DOKS)