Dividir una aplicación monolítica en microservicios

con Amazon Elastic Container Service, Docker y Amazon EC2

Incluir el monolito en contenedores

Módulo cuatro: Implementar microservicios

En este módulo, implementará su aplicación node.js como un conjunto de servicios interconectados detrás de un balanceador de carga de aplicaciones (ALB). Luego, utilizará el ALB para trasladar sin interrupciones el tráfico del monolito a los microservicios. Empezar a crear

Información general acerca de la arquitectura

Este es el proceso que seguirá para implementar los microservicios y trasladar el tráfico de la aplicación de manera segura desde el monolito.

Cambiar el tráfico
Esta es la configuración inicial. La aplicación node.js monolítica se ejecuta en un contenedor de Amazon ECS.
Iniciar los microservicios
Si utiliza las tres imágenes de contenedor que creó y envió a Amazon ECR en el módulo anterior, activará tres microservicios en su clúster de Amazon ECS existente.
Configurar los grupos de destino
Como en el módulo 2, agregará un grupo de destino para cada servicio y actualizará las reglas del ALB para conectar los microservicios nuevos.
Desactivar el monolito
Si cambia una regla en el ALB, comenzará a dirigir el tráfico hacia los microservicios en ejecución. Después de verificar el redireccionamiento del tráfico, desactive el monolito.

Tiempo de realización: 30 minutos

Servicios utilizados:

Instrucciones para la implementación

Siga las instrucciones paso a paso que se presentan a continuación para implementar los microservicios. Haga clic en cada uno de los números de los pasos para ampliar la sección.

Paso 1. Escriba las definiciones de las tareas de sus servicios
Implementará tres servicios nuevos en el clúster que lanzó en el módulo 2. Como en el módulo 2, escribirá definiciones de tareas para cada servicio.

⚐ NOTA: Es posible agregar múltiples contenedores a una sola definición de tarea. Esto significa que puede ejecutar los tres microservicios como contenedores diferentes desde un solo servicio. Sin embargo, este enfoque sigue siendo monolítico, ya que cada contenedor tendría que ampliarse de forma lineal con el servicio. Su objetivo es tener tres servicios independientes. Cada servicio requiere que su propia definición de tarea ejecute un contenedor con la imagen correspondiente a ese servicio.

Puede crear estas definiciones de tareas en la consola de Amazon ECS, o bien, puede acelerar el proceso y escribirlas como JSON. Para escribir la definición de tarea como un archivo JSON, siga estos pasos:
1. En la consola de Amazon Container Services, vaya a Amazon ECS y seleccione Definiciones de tareas.
2. En la página Definiciones de tareas, seleccione el botón Crear una definición de tarea nueva.
3. En la página Seleccionar compatibilidad con tipo de lanzamiento, seleccione la opción EC2 y, luego, Paso siguiente.
4. En la página “Configurar definiciones de tareas y contenedores”, desplácese hacia la sección Volúmenes y seleccione el botón Configurar mediante JSON.
5. Copie y pegue el siguiente fragmento de código en el campo JSON, para reemplazar el código existente.
  Recuerde reemplazar los marcadores de posición [nombre-servicio], [ID-cuenta], [región] y [etiqueta].
⚐ Nota: Los siguientes parámetros se utilizan en la definición de tareas:
- Nombre = [nombre-servicio: publicaciones, subprocesos y usuarios]
- Imagen = [URL de la imagen del repositorio de Amazon ECR]:latest
- CPU = 256
- Memoria = 256
- Puerto del contenedor = 3000
- Puerto del host = 0
```
{
    "containerDefinitions": [
        {
            "name": "[service-name]",
            "image": "[account-id].dkr.ecr.[region].amazonaws.com/[service-name]:[tag]",
            "memoryReservation": "256",
            "cpu": "256",
            "essential": true,
            "portMappings": [
                {
                    "hostPort": "0",
                    "containerPort": "3000",
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "volumes": [],
    "networkMode": "bridge",
    "placementConstraints": [],
    "family": "[service-name]"
}
```
♻ Repita los pasos a fin de crear una definición de tarea para cada servicio:
- publicaciones
- subprocesos
- usuarios
Paso 2. Configure el balanceador de carga de aplicaciones: grupos de destino
Como en el módulo 2, configure un grupo de destino para cada servicio (publicaciones, subprocesos y usuarios). Un grupo de destino permite que el tráfico llegue correctamente a un servicio determinado. Configurará los grupos de destino con la CLI de AWS. Sin embargo, antes de continuar, asegúrese de tener el nombre de VPC correcto que se usa para este tutorial:
- Vaya a la sección del balanceador de carga de la consola de EC2.
- Seleccione la casilla junto a la demostración, seleccione la pestaña Descripción y localice el atributo VPC (en este formato: vpc-xxxxxxxxxxxxxxxxx).
  ⚐ Nota: Cuando configure los grupos de destino, necesitará el atributo VPC.
Configurar los grupos de destino

En su terminal, escriba el siguiente comando para crear un grupo de destino para cada servicio (publicaciones, subprocesos y usuarios). Además, creará un grupo de destino (cancelar-tráfico) para evitar que el tráfico llegue al monolito una vez que los microservicios se estén ejecutando por completo. Recuerde reemplazar los siguientes marcadores de posición: [región], [nombre-servicio] y [atributo-vpc].

Nombres de los servicios: publicaciones, subprocesos, usuarios y cancelar-tráfico
```
aws elbv2 create-target-group --region [region] --name [service-name] --protocol HTTP --port 80 --vpc-id [vpc-attribute] --healthy-threshold-count 2 --unhealthy-threshold-count 2 --health-check-timeout-seconds 5 --health-check-interval-seconds 6
```
Paso 3. Configure las reglas del agente de escucha
El agente de escucha verifica las solicitudes entrantes de conexión al ALB para dirigir el tráfico de forma adecuada.

En este momento, los cuatro servicios (el monolito y los tres microservicios) se ejecutan con el mismo balanceador de carga. Para pasar del monolito a los microservicios, comenzará a dirigir el tráfico hacia los microservicios y dejará de dirigirlo hacia el monolito.

Acceda a las reglas del agente de escucha
- Vaya a la sección del balanceador de carga de la consola de EC2.
- Localice el balanceador de carga denominado demostración y seleccione la casilla junto a él para ver sus detalles.
- Seleccione la pestaña Agentes de escucha.
Actualice las reglas del agente de escucha

Esta pestaña debería mostrar un solo agente de escucha. Realice los siguientes pasos para editar las reglas del agente de escucha:
- En la columna Reglas, seleccione Ver/editar reglas.
- En la página Reglas, seleccione el botón con el signo más (+).
  La página muestra la opción para Ingresar regla.
- Use la siguiente plantilla de reglas para ingresar las reglas necesarias, las cuales incluyen una para mantener el tráfico hacia el monolito y una para cada microservicio:
  
  SI Ruta = /api/[nombre-servicio]* ENTONCES Reenviar a [nombre-servicio]
  Por ejemplo: SI Ruta = /api/publicaciones* ENTONCES Reenviar a publicaciones
  
  Ingrese las reglas en el siguiente orden:
  
  api: /api* reenvía a api
  
  usuarios: /api/usuarios* reenvía a usuarios
  
  subprocesos: /api/subprocesos* reenvía a subprocesos
  
  publicaciones: /api/publicaciones* reenvía a publicaciones
- Seleccione Guardar.
- Seleccione la flecha de retroceso en la esquina superior izquierda de la página para volver a la consola del balanceador de carga.
Paso 4. Implemente los microservicios
Implemente los tres microservicios (publicaciones, subprocesos y usuarios) en su clúster. Repita los siguientes pasos para cada uno de los tres microservicios:
- Vaya a la consola de Amazon ECS y seleccione Clústeres en la barra del menú izquierdo.
- Seleccione el clúster BreakTheMonolith-Demo, además de la pestaña Servicios y, luego, Crear.
- En la página de Configurar servicio, edite los siguientes parámetros (y mantenga los valores predeterminados para los parámetros que no aparecen a continuación):
  
  Para el Tipo de lanzamiento, seleccione EC2.
  
  Para la Definición de tarea, seleccione el botón Escribir un valor a fin de seleccionar automáticamente el valor de revisión más alto.
  Por ejemplo: api:1
  
  Para el Nombre del servicio, escriba un nombre de servicio (publicaciones, subprocesos o usuarios).
  
  Para el Número de tareas, escriba 1.
- Seleccione Paso siguiente.
- En la página Configurar red y la sección Balanceador de carga, haga lo siguiente:
  
  Para el Tipo de balanceador de carga, seleccione Balanceador de carga de aplicaciones.
  
  Para el Rol de servicio IAM, seleccione BreakTheMonolith-Demo-ECSServiceRole.
  
  Para el Nombre del balanceador de carga, verifique que la opción demostración esté seleccionada.
  
  En la sección Contenedor para el balanceo de carga, seleccione el botón Agregar al balanceador de carga y realice las siguientes modificaciones:
  
  Para el Puerto de agente de escucha de producción, establezca 80:HTTP.
  
  Para el Nombre del grupo de destino, seleccione el grupo que corresponda: (publicaciones, subprocesos o usuarios).
- Seleccione Paso siguiente.
- En la página Configurar Auto Scaling, seleccione Paso siguiente.
- En la página Revisar, seleccione Crear servicio.
- Seleccione Ver servicio.
El inicio de todos los servicios solo debería tomar unos segundos. Antes de continuar, verifique que todos los servicios y las tareas estén en ejecución y en actividad.
Paso 5. Transfiera el tráfico a los microservicios
Los microservicios ya se están ejecutando, pero todo el tráfico sigue dirigiéndose al servicio monolito. Para redirigir el tráfico hacia los microservicios, siga los siguientes pasos a fin de actualizar las reglas del agente de escucha:
- Vaya a la sección Balanceadores de carga de la consola de EC2.
- Seleccione la casilla junto a la demostración para ver los detalles del balanceador de carga.
- Seleccione la pestaña Agentes de escucha.
  En la lista, debería haber un solo agente de escucha.
- En la columna Reglas, seleccione Ver/editar reglas.
- En la página Reglas, seleccione el botón con el signo menos (-) en el menú superior.
- Seleccione la casilla de verificación junto a la primera regla para eliminarla (/api* reenvía a api).
- Seleccione Eliminar.
- Actualice la regla predeterminada para el reenvío a cancelar-tráfico:
  
  Seleccione el botón de edición (lápiz) en el menú superior.
  
  Seleccione el icono de edición (lápiz) junto a la regla predeterminada (HTTP 80: acción predeterminada).
  
  Seleccione el icono de edición (lápiz) en la columna ENTONCES para editar Reenviar a.
  
  En el campo Grupo de destino, seleccione cancelar-tráfico.
  
  Seleccione el botón Actualizar.
Consulte la siguiente captura de pantalla para ver un ejemplo de las reglas actualizadas.
Deshabilitar el monolito: como ahora el tráfico fluye hacia los microservicios, puede deshabilitar el servicio monolito.
- Regrese al clúster de Amazon ECS BreakTheMonolith-Demo-ECSCluster.
- En la pestaña Servicios, seleccione la casilla junto a api, además de Actualizar.
- En la página Configurar servicio, localice Número de tareas y escriba 0.
- Seleccione Pasar a la revisión.
- Seleccione Actualizar servicio.
Amazon ECS vaciará las conexiones de los contenedores que el servicio ha implementado en el clúster y, luego, detendrá los contenedores. Si actualiza las listas de implementaciones o tareas después de aproximadamente 30 segundos, verá que el número de tareas se reduce a 0. El servicio continúa activo, de manera que si, por algún motivo, necesitara retroceder, solo tiene que actualizarlo para implementar más tareas.
Si lo desea, puede eliminar el servicio de api. En la pestaña Servicios, seleccione la casilla junto a api, seleccione Eliminar y, luego, confirme la eliminación.

Ha transferido su node.js de monolito a microservicio sin tiempo de inactividad.
Paso 6. Valide su implementación
Encuentre la URL de su servicio: es la misma URL que utilizó en el módulo 2 de este tutorial.
- Vaya a la sección Balanceadores de carga de la consola de EC2.
- Seleccione la casilla junto a la demostración para ver los detalles del balanceador de carga.
- En la pestaña Descripción, localice el nombre de DNS y seleccione el icono para copiar al final de la URL.
- Pegue el nombre de DNS en una nueva pestaña o ventana del navegador.
Debería ver un mensaje con el enunciado de “Está listo para recibir solicitudes”.

Consulte los valores para cada microservicio: su ALB dirige el tráfico en función de la URL de solicitud. Para ver cada servicio, simplemente agregue el nombre del servicio al final del nombre de DNS:
- http://[DNS name]/api/users
- http://[DNS name]/api/threads
- http://[DNS name]/api/posts
⚐ NOTA: Estas URL se comportan exactamente del mismo modo que cuando se implementa el monolito. Esto es muy importante porque cualquier API o consumidor que espere conectarse a esta aplicación no se verá afectado por los cambios que haya realizado. Pasar de monolitos a microservicios no requirió cambios en otras partes de la infraestructura.

También puede usar herramientas, como Postman, para probar las API.