De cero a la build: guía paso a paso

Instalación y configuración de Lino CLI

El primer paso para comenzar a trabajar con Lino CLI es instalar la herramienta en su entorno de desarrollo. Se distribuye como una herramienta global de dotnet, lo que significa que estará disponible para cualquier proyecto .NET en su computadora.

Paso 1: Instalación

Para instalar (o actualizar) Lino CLI, ejecute el siguiente comando en la terminal:

dotnet tool install --global Tolitech.Lino

Notas importantes:

• Si ya hay una versión instalada, puede usar dotnet tool update --global Tolitech.Lino para actualizarla.
• Asegúrese de que el directorio de herramientas globales de .NET esté en el PATH del sistema para que el comando lino funcione correctamente.

Paso 2: Configurar idioma

Después de la instalación, se recomienda configurar el idioma (o cultura) que el CLI utilizará en mensajes, avisos y registros:

lino preferences culture set

Se le pedirá que elija entre los idiomas disponibles. Esta configuración garantiza que todas las instrucciones y avisos aparezcan de manera consistente en el idioma deseado.

Paso 3: Autenticación y registro

Para acceder a todas las funciones de Lino, incluidos templates avanzados, publicación de imágenes Docker e integración con servicios externos, es necesario autenticarse.

- Si aún no tiene una cuenta, regístrese con el comando:

lino user register

- Si ya tiene una cuenta, inicie sesión con:

lino auth login

Qué sucede: el CLI almacena un token de autenticación localmente, lo que le permite ejecutar comandos que requieren acceso a recursos protegidos sin tener que iniciar sesión cada vez.

Paso 4: Verificación

Para confirmar que la instalación y autenticación se realizaron correctamente, ejecute:

lino --version

Si el comando devuelve la versión instalada, está listo para comenzar a usar Lino CLI en sus proyectos.

Creando el proyecto MyApp

En este paso, vamos a crear la estructura inicial del proyecto utilizando Lino CLI. Este proyecto servirá como base para demostrar la creación de servicios, módulos, front-end y la integración de eventos.

Paso 1: Ejecutar el comando de creación

Para crear un nuevo proyecto, ejecute el siguiente comando en la terminal:

lino project new

El CLI lo guiará paso a paso, solicitando información como:

• Nombre del proyecto: usaremos MyApp, pero puede elegir cualquier nombre que desee;
• Funciones adicionales: analizadores de código, caché distribuido, soporte para eventos asincrónicos, etc.

Paso 2: Configuración de funciones esenciales

Para este proyecto, recomendamos habilitar desde el inicio las siguientes funciones:

• Analizadores de código: para asegurar que el código siga buenas prácticas y estándares consistentes, evitando errores comunes de implementación;
• Caché distribuido: mejora el rendimiento de la aplicación en escenarios con múltiples servicios, evitando consultas innecesarias a la base de datos;
• Comunicación asincrónica: habilita el uso de eventos y colas para la integración entre servicios, garantizando escalabilidad y desacoplamiento.

Es importante habilitar todas estas opciones en este proyecto, ya que crearemos múltiples servicios que se comunicarán mediante eventos de integración. Esto le permitirá comprender cómo estructurar sistemas modulares y distribuidos utilizando Lino.

Paso 3: Estructura generada

Tras ejecutar el comando y configurar las funciones, el CLI generará la estructura inicial del proyecto. Esta incluirá:

• Carpetas para servicios y módulos;
• Plantillas para front-end (si aplica);
• Configuraciones iniciales de caché, eventos e integraciones;
• Archivos de solución (.slnx) y proyecto (.csproj) listos para compilar.

Ahora su proyecto MyApp está listo para recibir los servicios, módulos, entidades y front-end que configuraremos en los siguientes pasos.

Agregando el frontend

Ahora vamos a crear la interfaz del sistema, el frontend, que se utilizará como Backoffice. Este frontend no será una aplicación pública, sino una herramienta interna para que administradores y gestores puedan gestionar productos, categorías, inventarios, ventas y otra información del sistema.

Paso 1: Ejecutando el comando de creación

Para agregar un nuevo frontend al proyecto, utiliza el siguiente comando en la terminal:

lino webapp new

El CLI solicitará alguna información durante el proceso, como:

• Nombre de la aplicación web: usaremos Backoffice para este ejemplo;

Paso 2: Estructura generada

Al finalizar el proceso, el CLI generará la estructura inicial del frontend dentro de la carpeta WebApps/Backoffice. La estructura predeterminada incluye:

• Carpetas para páginas, componentes y servicios de la aplicación;
• Clientes HTTP para consumir APIs de los servicios del proyecto;
• Plantillas iniciales;
• Archivos de configuración para la integración con autenticación, autorización y eventos del sistema.

Notas importantes

• El frontend se integrará automáticamente con los servicios y módulos seleccionados, permitiendo que los datos de productos, categorías y ventas se consuman directamente a través de las APIs generadas por Lino.
• Puedes crear múltiples frontends, por ejemplo, uno para administradores (Backoffice) y otro público (Sitio), siguiendo el mismo proceso.

Con el frontend creado, estamos listos para avanzar hacia la creación de los servicios y módulos que proporcionarán los datos y las reglas de negocio para esta aplicación.

Creación de servicios y módulos

En esta etapa, construiremos los servicios y módulos que compondrán la aplicación. El objetivo es crear una arquitectura modular y escalable, permitiendo que diferentes áreas del sistema, como productos, categorías, inventario, ventas y medios, evolucionen de manera independiente, manteniendo la cohesión y facilitando el mantenimiento.

Paso 1: Definición de los servicios

Inicialmente, crearemos los siguientes servicios, cada uno con responsabilidades bien definidas:

• Catalog (modular) – responsable de la gestión de productos, categorías y precios;
• Sales – responsable del procesamiento de ventas y pedidos;
• Stock – responsable de la gestión de inventarios y movimientos;
• Security – responsable de la autenticación, autorización y gestión de usuarios.

Para crear un nuevo servicio, ejecute el comando:

lino service new

Durante la ejecución del comando, el CLI solicitará:

• Nombre del servicio: por ejemplo, Catalog;
• Base de datos: elija la tecnología más adecuada para su proyecto (SQL Server, PostgreSQL, etc.);

Paso 2: Creación de módulos dentro de los servicios

No todos los servicios necesitan ser modulares. En nuestro proyecto, solo el servicio Catalog tendrá módulos, para separar responsabilidades como merchandising y pricing.

Para el servicio Catalog, hemos definido los siguientes módulos:

• Merchandising – gestión de productos y categorías;
• Pricing – gestión de precios, promociones e historial de cambios.

Para crear un módulo, ejecute el comando:

lino module new

Puede crear tantos módulos como desee dentro del servicio modular Catalog. Además, dependiendo de la complejidad, algunos módulos podrían convertirse en servicios independientes en el futuro. La separación presentada aquí es solo con fines educativos y sirve como ejemplo de organización modular.

Estructura final del proyecto

Después de crear los servicios y módulos, su solución debería tener una estructura similar a la siguiente:

MyApp/
└── src/
    ├── Aspire/
    ├── Integrations/
    ├── Services/
    │   ├── Catalog/
    │   │   ├── Modules/
    │   │   │   ├── Merchandising/
    │   │   │   └── Pricing/
    │   │   ├── MyApp.Catalog.Host
    │   │   └── MyApp.Catalog.Infrastructure
    │   ├── Sales/
    │   ├── Security/
    │   ├── Shared/
    │   └── Stock/
    └── WebApps/
        ├── Backoffice/
        │   ├── Services/
        │   │   ├── Catalog/
        │   │   ├── Sales/
        │   │   ├── Security/
        │   │   └── Stock/
        │   ├── MyApp.WebApp.Backoffice
        │   └── MyApp.WebApp.Backoffice.Client
        └── Shared/
            └── MyApp.WebApp.Shared
└── tests/
    └── Services/
        ├── Catalog/
        │   ├── Merchandising/
        │   └── Pricing/
        ├── Sales/
        ├── Security/
        ├── Shared/
        └── Stock/

Explicación de la estructura:

• Services/: contiene todos los servicios del sistema, cada uno aislado con su propia lógica de negocio, infraestructura y hosting;
• Modules/: carpetas dentro de los servicios modulares, permitiendo organizar funcionalidades específicas y mantener código cohesionado;
• WebApps/: frontends asociados al sistema, ya integrados con los servicios;
• Shared/: bibliotecas y recursos compartidos entre servicios y frontends;
• tests/: pruebas unitarias y de integración organizadas por servicio y módulo.

Con esta estructura modular, cada equipo o desarrollador puede trabajar de manera independiente en diferentes partes del sistema, facilitando la escalabilidad, el mantenimiento y las pruebas.

Agregar autenticación y autorización

La autenticación y la autorización son elementos esenciales de cualquier sistema moderno. En Lino CLI, agregarlas a tu proyecto es simple y rápido.

Paso 1: Ejecutar el comando de autenticación

Para agregar las funcionalidades de autenticación y autorización, utiliza el comando:

lino features auth add

El CLI te guiará a través de los siguientes pasos:

• Elegir el servicio o módulo: debes indicar dónde se instalarán los artefactos de autenticación. En nuestro proyecto de ejemplo, utilizamos el servicio Security, que centraliza toda la lógica de seguridad del sistema;
• Configuraciones adicionales: creación de tablas de usuarios, roles y permisos, y configuración de políticas de acceso.

Paso 2: Estructura generada

Después de ejecutar el comando, el servicio Security contendrá archivos y carpetas como:

• Entities: clases de usuarios, roles y permisos;
• Infrastructure: configuraciones de base de datos y migraciones para crear tablas;
• Application: servicios de autenticación, gestión de usuarios y validación de credenciales;
• API/Host: endpoints para inicio de sesión, cierre de sesión, registro y gestión de roles.

Con esta configuración, tu aplicación tendrá una autenticación robusta y un control de acceso granular, lista para soportar múltiples usuarios y diferentes niveles de permisos.

Agregando Background Jobs

En sistemas distribuidos y modulares, como el que estamos construyendo con el Lino CLI, no todos los servicios se comunican directamente entre sí. Para garantizar la consistencia y confiabilidad en el intercambio de información, utilizamos eventos de integración. Sin embargo, para procesar estos eventos de manera eficiente y asíncrona, necesitamos Background Jobs.

Lino utiliza el Outbox Pattern para garantizar que todos los mensajes generados por los servicios se registren de manera confiable antes de ser enviados. Con esto podemos:

• Evitar la pérdida de eventos en caso de fallos o reinicios del servicio;
• Garantizar que el mismo mensaje se envíe solo una vez;
• Permitir el reprocesamiento de mensajes en caso de fallo en la entrega;
• Separar el procesamiento de eventos de la lógica principal de la aplicación, mejorando el rendimiento y la escalabilidad.

Paso 1: Ejecutando el comando

Para agregar soporte de Background Jobs a tu proyecto, ejecuta el comando:

lino features background-job add

El CLI te pedirá seleccionar el servicio donde se instalará el Background Job. Normalmente, elegirás el servicio que centraliza la producción de eventos, como Catalog o Sales.

Paso 2: Configurando la ejecución

Durante la configuración, podrás definir:

• Intervalo de verificación: determina con qué frecuencia el Background Job revisará la tabla Outbox en busca de nuevos mensajes. Un intervalo muy corto puede aumentar el uso de recursos, mientras que uno largo puede retrasar la entrega de eventos;
• Lote de registros procesados por vez: controla cuántos eventos se leerán y enviarán por ejecución. Lotes más grandes pueden aumentar el rendimiento, pero requieren más memoria y procesamiento;
• Política de reintentos: en caso de fallo en la entrega de mensajes, puedes configurar cuántas veces el job intentará reenviar.

Estos parámetros dependen del tamaño de tu sistema, la capacidad de la máquina y el volumen esperado de eventos.

Paso 3: Estructura generada

Después de la configuración, el proyecto contará con un Background Job listo para procesar mensajes de las tablas Outbox en cada servicio.

Esto garantiza que todos los eventos de integración se procesen de manera confiable y eficiente, permitiendo que múltiples servicios y módulos se comuniquen de forma asíncrona sin afectar el rendimiento del sistema principal.

Creación de entidades y enumeraciones

En esta sección, detallamos el diseño de las entidades, enumeraciones y objetos de valor de la aplicación, mostrando en qué servicios y módulos se creará cada elemento.

1. Creación de la entidad Category

Para crear la entidad, use el comando:

lino entity new

La entidad se creará en el servicio Catalog y en el módulo Merchandising con la siguiente estructura:

┌────┬────┬───────────────┬────────┬────────┬──────────┬────────────────┐
│ PK │ FK │ Property name │ Type   │ Length │ Required │ Auto-increment │
├────┼────┼───────────────┼────────┼────────┼──────────┼────────────────┤
│ x  │    │ Id            │ Guid   │        │    x     │       x        │
├────┼────┼───────────────┼────────┼────────┼──────────┼────────────────┤
│    │    │ Name          │ string │   50   │    x     │                │
└────┴────┴───────────────┴────────┴────────┴──────────┴────────────────┘

2. Creación de la entidad Product

A continuación, creamos la entidad Product en el mismo servicio y módulo, incluyendo objetos de valor y enumeraciones:

┌────┬────┬───────────────┬─────────────┬────────┬──────────┬────────────────┐
│ PK │ FK │ Property name │ Type        │ Length │ Required │ Auto-increment │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│ x  │    │ Id            │ Guid        │        │    x     │       x        │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │    │ Name          │ string      │  100   │    x     │                │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │    │ Description   │ string      │  500   │    x     │                │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │    │ Price         │ decimal     │        │    x     │                │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │ x  │ CategoryId    │ Category    │        │    x     │                │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │    │ Dimensions    │ ValueObject │        │          │                │
├────┼────┼───────────────┼─────────────┼────────┼──────────┼────────────────┤
│    │    │ Status        │ Enum        │        │    x     │                │
└────┴────┴───────────────┴─────────────┴────────┴──────────┴────────────────┘

2.1 Creación del Value Object ProductDimension

Este Value Object representa las dimensiones del producto:

┌───────────────┬─────────┬────────┬──────────┐
│ Property name │ Type    │ Length │ Required │
├───────────────┼─────────┼────────┼──────────┤
│ Width         │ decimal │        │    x     │
├───────────────┼─────────┼────────┼──────────┤
│ Height        │ decimal │        │    x     │
├───────────────┼─────────┼────────┼──────────┤
│ Depth         │ decimal │        │    x     │
└───────────────┴─────────┴────────┴──────────┘

2.2 Creación del Enum ProductStatus

Este Enum define el estado del producto:

┌───────┬──────────────┬──────────────┐
│ Value │ Name         │ Display Name │
├───────┼──────────────┼──────────────┤
│ 1     │ Active       │ Active       │
├───────┼──────────────┼──────────────┤
│ 2     │ Inactive     │ Inactive     │
├───────┼──────────────┼──────────────┤
│ 3     │ Discontinued │ Discontinued │
└───────┴──────────────┴──────────────┘

3. Añadiendo nuevas propiedades

A medida que evoluciona el proyecto, podemos editar entidades existentes para añadir nuevas propiedades. Por ejemplo, añadiremos una lista de imágenes a la entidad Product:

lino entity edit

Al crear la propiedad Images del tipo List<ProductImage>, se generará la siguiente estructura:

┌────┬────┬───────────────┬────────────────────┬────────┬──────────┬────────────────┐
│ PK │ FK │ Property name │ Type               │ Length │ Required │ Auto-increment │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│ x  │    │ Id            │ Guid               │        │    x     │       x        │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │    │ Name          │ string             │  100   │    x     │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │    │ Description   │ string             │  500   │    x     │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │    │ Price         │ decimal            │        │    x     │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │ x  │ CategoryId    │ EntityId           │        │    x     │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │    │ Dimensions    │ ValueObject        │        │          │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │    │ Status        │ Enum               │        │    x     │                │
├────┼────┼───────────────┼────────────────────┼────────┼──────────┼────────────────┤
│    │ x  │ Images        │ List<ProductImage> │        │          │                │
└────┴────┴───────────────┴────────────────────┴────────┴──────────┴────────────────┘

3.1 Creación de la entidad ProductImage

Esta entidad pertenece al agregado Product y tiene la siguiente estructura:

┌────┬────┬───────────────┬────────────────┬────────┬──────────┬────────────────┐
│ PK │ FK │ Property name │ Type           │ Length │ Required │ Auto-increment │
├────┼────┼───────────────┼────────────────┼────────┼──────────┼────────────────┤
│ x  │    │ Id            │ Guid           │        │    x     │       x        │
├────┼────┼───────────────┼────────────────┼────────┼──────────┼────────────────┤
│    │ x  │ ProductId     │ EntityId       │        │    x     │                │
├────┼────┼───────────────┼────────────────┼────────┼──────────┼────────────────┤
│    │    │ UploadDate    │ DateTimeOffset │        │    x     │                │
├────┼────┼───────────────┼────────────────┼────────┼──────────┼────────────────┤
│    │    │ Image         │ File           │        │    x     │                │
└────┴────┴───────────────┴────────────────┴────────┴──────────┴────────────────┘

4. Creación de entidades para otros servicios

En el servicio Sales, creamos la entidad ProductSnapshot, que se alimentará mediante eventos de integración. Como el Id original de la entidad Product proviene del servicio Catalog, no puede ser autoincrementable aquí.

┌────┬────┬───────────────┬─────────┬────────┬──────────┬────────────────┐
│ PK │ FK │ Property name │ Type    │ Length │ Required │ Auto-increment │
├────┼────┼───────────────┼─────────┼────────┼──────────┼────────────────┤
│ x  │    │ Id            │ Guid    │        │    x     │                │
├────┼────┼───────────────┼─────────┼────────┼──────────┼────────────────┤
│    │    │ Name          │ string  │  100   │    x     │                │
├────┼────┼───────────────┼─────────┼────────┼──────────┼────────────────┤
│    │    │ Price         │ decimal │        │    x     │                │
└────┴────┴───────────────┴─────────┴────────┴──────────┴────────────────┘

Observación: solo se replicaron los campos esenciales en ProductSnapshot para el servicio Sales. Las entidades complementarias, como Customer, Order y StockItem, no se detallan aquí para simplificar la documentación.

Creando eventos y sus manejadores

Para recapitular, en el tema anterior creamos en el servicio modular Catalog.Merchandising las entidades Product, Category y ProductImage, mientras que en el servicio Sales creamos la entidad ProductSnapshot.

Ahora vamos a crear eventos de dominio y eventos de integración. El objetivo es que, al crear o actualizar productos en el servicio Catalog, estos cambios se repliquen a los servicios consumidores como Sales y Stock.

1. Creando eventos de dominio

El primer paso es crear los eventos de dominio ProductCreated y ProductUpdated con el comando:

lino event new

Durante la creación, podemos asociar el evento a un manejador y, al mismo tiempo, configurar el disparo de un evento de integración. Esto centraliza la creación de todo el flujo necesario.

┌──────────────────────────────────────────────────────┬────────────────────────────────┐
│ Question                                             │ Answer                         │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a service:                                    │ Catalog                        │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a module:                                     │ Merchandising                  │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a entity:                                     │ Product                        │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select the event type:                               │ Domain Event                   │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Enter the name of the event:                         │ ProductCreated                 │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Do you want to create an associated event handler?   │ Yes                            │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Trigger a integration event?                         │ Yes                            │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Choose the integration event to be triggered:        │ (Create new integration event) │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Enter the name of the event:                         │ ProductCreated                 │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Which model will be used for this integration event? │ Creation model                 │
└──────────────────────────────────────────────────────┴────────────────────────────────┘

De la misma manera, creamos el evento ProductUpdated:

┌──────────────────────────────────────────────────────┬────────────────────────────────┐
│ Question                                             │ Answer                         │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a service:                                    │ Catalog                        │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a module:                                     │ Merchandising                  │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select a entity:                                     │ Product                        │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Select the event type:                               │ Domain Event                   │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Enter the name of the event:                         │ ProductUpdated                 │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Do you want to create an associated event handler?   │ Yes                            │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Trigger a integration event?                         │ Yes                            │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Choose the integration event to be triggered:        │ (Create new integration event) │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Enter the name of the event:                         │ ProductUpdated                 │
├──────────────────────────────────────────────────────┼────────────────────────────────┤
│ Which model will be used for this integration event? │ Update model                   │
└──────────────────────────────────────────────────────┴────────────────────────────────┘

Con esto, tenemos:

• Eventos de dominio creados (ProductCreated y ProductUpdated);
• Manejadores de eventos de dominio correspondientes;
• Eventos de integración registrados automáticamente en la Outbox por el manejador de eventos de dominio.

2. Creando manejadores de eventos de integración

El siguiente paso es definir qué servicios consumirán los eventos de integración. Para esto, usamos:

lino event-handler new

El flujo de creación incluye:

• Seleccionar el servicio, módulo y entidad que contendrá el manejador;
• Seleccionar el evento de integración que se consumirá y de qué servicio/módulo/entidad proviene.

Por ejemplo, en el servicio Sales creamos los manejadores para ProductCreated y ProductUpdated que consumirán los eventos disparados por Catalog.Merchandising.Product:

┌────────────────────────────────────────────┬───────────────────┐
│ Question                                   │ Answer            │
├────────────────────────────────────────────┼───────────────────┤
│ Select a service:                          │ Sales             │
├────────────────────────────────────────────┼───────────────────┤
│ Select a entity:                           │ ProductSnapshot   │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event type:                     │ Integration Event │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's service to be consumed: │ Catalog           │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's module to be consumed:  │ Merchandising     │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's entity to be consumed:  │ Product           │
├────────────────────────────────────────────┼───────────────────┤
│ Choose the event to be consumed:           │ ProductCreated    │
├────────────────────────────────────────────┼───────────────────┤
│ Enter the name of the event handler:       │ ProductCreated    │
└────────────────────────────────────────────┴───────────────────┘

┌────────────────────────────────────────────┬───────────────────┐
│ Question                                   │ Answer            │
├────────────────────────────────────────────┼───────────────────┤
│ Select a service:                          │ Sales             │
├────────────────────────────────────────────┼───────────────────┤
│ Select a entity:                           │ ProductSnapshot   │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event type:                     │ Integration Event │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's service to be consumed: │ Catalog           │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's module to be consumed:  │ Merchandising     │
├────────────────────────────────────────────┼───────────────────┤
│ Select the event's entity to be consumed:  │ Product           │
├────────────────────────────────────────────┼───────────────────┤
│ Choose the event to be consumed:           │ ProductUpdated    │
├────────────────────────────────────────────┼───────────────────┤
│ Enter the name of the event handler:       │ ProductUpdated    │
└────────────────────────────────────────────┴───────────────────┘

De este modo, tenemos dos manejadores de eventos de integración en el servicio Sales, consumiendo solo los campos necesarios de los eventos de integración del Catalog.Merchandising. Esto asegura que las tablas replicadas contengan únicamente los datos esenciales, optimizando almacenamiento y rendimiento.

Generación de páginas web, APIs, Commands y Queries

Una de las grandes ventajas de Lino CLI es permitir la creación integrada de páginas web, APIs, Commands y Queries de forma automatizada, simplificando todo el flujo de desarrollo. Para comenzar, simplemente ejecute el comando:

lino page new

Durante el proceso, usted:

• Seleccionará el servicio, módulo y entidad que desea exponer;
• Elegirá los campos que formarán parte del listado;
• Generará automáticamente páginas de listado (rejilla paginada) y formularios de creación/edición;
• Generará clases HttpClient para consumo en el frontend;
• Creará todas las APIs REST necesarias (POST, PUT, PATCH, DELETE y GET);
• Creará Commands y Queries con sus respectivos Handlers, que interactúan con la base de datos garantizando el flujo completo de CRUD.

Con este comando, obtiene una aplicación funcional sin necesidad de escribir manualmente la capa de interfaz, APIs y lógica de negocio, manteniendo el estándar y la consistencia entre servicios.

Para este proyecto, podemos generar las páginas integradas para las siguientes entidades:

• Catalog.Merchandising.Category
• Catalog.Merchandising.Product
• Sales.ProductSnapshot

Tras generar las páginas, APIs y Commands/Queries, la aplicación estará lista para interactuar de forma completa entre frontend y backend, con validaciones, rutas y persistencia ya configuradas automáticamente por Lino CLI.

Creación de migraciones de bases de datos

Ahora que todas las entidades han sido creadas, es hora de generar las migraciones para que las bases de datos se creen o actualicen según el modelo definido. Lino CLI automatiza este proceso, integrándose con Entity Framework y creando scripts listos para ejecutar.

Para crear una nueva migración, ejecute el comando:

lino database migrations new

Durante la ejecución, deberá:

• Seleccionar el servicio y módulo que recibirán la migración;
• Proporcionar una descripción para la migración, por ejemplo, "Initial migration".

┌───────────────────────────────────────────┬───────────────────┐
│ Question                                  │ Answer            │
├───────────────────────────────────────────┼───────────────────┤
│ Select a service:                         │ Catalog           │
├───────────────────────────────────────────┼───────────────────┤
│ Select a module:                          │ Merchandising     │
├───────────────────────────────────────────┼───────────────────┤
│ Current version of the service:           │ 0.1.0             │
├───────────────────────────────────────────┼───────────────────┤
│ Provide a description for this migration: │ Initial migration │
└───────────────────────────────────────────┴───────────────────┘

Al confirmar, Lino CLI generará:

• Una nueva migración de base de datos para la versión actual del servicio;
• Un script SQL correspondiente, ubicado en la capa Infrastructure.Persistence, en la ruta /scripts/<version>/<nombre del archivo>;
• El registro de la versión de la migración en el historial del servicio, asegurando trazabilidad y consistencia.

Buenas prácticas:

• Crear nuevas migraciones siempre que haya cambios en el modelo de datos (nuevas entidades, propiedades o cambios en relaciones);
• Revisar los scripts SQL generados antes de aplicarlos en producción;
• Mantener el control de versiones de la base de datos alineado con la versión de la aplicación, evitando conflictos y problemas de sincronización.

Siguiendo este flujo, se garantiza que la base de datos esté siempre actualizada y consistente con el modelo de dominio definido en Lino CLI, reduciendo errores y simplificando el mantenimiento.

Generación de imágenes Docker

Después de completar la generación del código para una versión específica, realizar pruebas e implementar todas las reglas de negocio necesarias, puede generar imágenes Docker de los servicios y aplicaciones web de su proyecto para su posterior publicación en un registro de contenedores.

Lino CLI simplifica este proceso con el comando:

lino build

Al ejecutarlo, verá una lista de todos los servicios y aplicaciones web disponibles en el proyecto, junto con sus versiones actuales:

Select the services or web applications you want to include in the build:

> [ ] Services
    [ ] Catalog |0.1.0|
    [ ] Sales |0.1.0|
    [ ] Security |0.1.0|
    [ ] Stock |0.1.0|
  [ ] Web applications
    [ ] Backoffice |0.1.0|

Puede seleccionar uno o varios servicios y aplicaciones web para generar imágenes simultáneamente. Simplemente marque los elementos deseados.

A continuación, se le pedirá que elija cómo desea actualizar la versión de las imágenes generadas. Las opciones disponibles son:

• Mantener la versión actual – no cambia la versión existente;
• Patch – incrementa la versión patch (ej.: 0.1.0 → 0.1.1);
• Minor – incrementa la versión menor (ej.: 0.1.0 → 0.2.0);
• Major – incrementa la versión principal (ej.: 0.1.0 → 1.0.0).

Después de seleccionar los servicios y definir el incremento de versión, Lino CLI realiza:

• Build del código de cada servicio y aplicación web;
• Generación de la imagen Docker correspondiente;
• Aplicación de la etiqueta con la versión definida;
• Disponibilidad de las imágenes para publicación en su registro de contenedores.

Al final del proceso, considerando que todos los servicios y aplicaciones web fueron seleccionados, las imágenes generadas tendrán la siguiente estructura:

• my-app/services/catalog-host - tag: 0.1.0
• my-app/services/sales-api - tag: 0.1.0
• my-app/services/security-api - tag: 0.1.0
• my-app/services/stock-api - tag: 0.1.0
• my-app/webapps/backoffice - tag: 0.1.0

Observación: Este proceso garantiza consistencia entre el código y la versión de las imágenes Docker, facilitando el despliegue y mantenimiento de múltiples entornos, además de permitir que cada servicio esté aislado en contenedores independientes.

Creación de versiones en la aplicación

Incrementar nuevas versiones para los servicios o aplicaciones web es un proceso sencillo y centralizado en Lino CLI. Simplemente ejecute el comando:

lino version bump

Al igual que con la generación de imágenes Docker, al ejecutar este comando verá una lista completa de todos los servicios y aplicaciones web de su proyecto. Solo los elementos que seleccione tendrán su versión incrementada, mientras que los demás permanecerán sin cambios.

Select the services or web applications that will have version changes:

> [ ] Services
    [ ] Catalog |0.1.0|
    [ ] Sales |0.1.0|
    [ ] Security |0.1.0|
    [ ] Stock |0.1.0|
  [ ] Web applications
    [ ] Backoffice |0.1.0|

Después de seleccionar los elementos deseados, se le pedirá que elija el tipo de incremento de versión. Las opciones disponibles son:

• Patch – pequeñas correcciones sin impacto funcional;
• Minor – adición de nuevas funcionalidades compatibles con versiones anteriores;
• Major – cambios que pueden romper la compatibilidad con versiones anteriores.

Es importante destacar que las versiones de los servicios y aplicaciones web tienen un impacto directo en:

• Las etiquetas de las imágenes Docker;
• Las carpetas utilizadas para almacenar scripts generados por las migraciones de la base de datos;
• El control de releases y el historial del proyecto.

Con esto, concluimos la guía paso a paso de todos los comandos esenciales para la construcción de un proyecto web utilizando Lino CLI, desde la instalación, creación de servicios, entidades, eventos y páginas, hasta la generación de imágenes Docker y el versionado.

No olvide seguir nuestro canal de YouTube para tutoriales detallados, demostraciones prácticas y consejos sobre el uso de la herramienta, desde operaciones simples hasta funciones avanzadas.