Do Zero ao Build: Guia Passo a Passo

Instalando e configurando o Lino CLI

O primeiro passo para começar a trabalhar com o Lino CLI é instalar a ferramenta em seu ambiente de desenvolvimento. Ela é distribuída como uma dotnet global tool, o que significa que estará disponível para qualquer projeto .NET no seu computador.

Passo 1: Instalação

Para instalar (ou atualizar) o Lino CLI, execute o seguinte comando no terminal:

dotnet tool install --global Tolitech.Lino

Observações importantes:

• Se já houver uma versão instalada, você pode usar dotnet tool update --global Tolitech.Lino para atualizar.
• Verifique se o diretório de ferramentas globais do .NET está no PATH do sistema para que o comando lino funcione corretamente.

Passo 2: Configurar idioma

Após a instalação, é recomendado configurar o idioma (ou cultura) que o CLI irá utilizar em mensagens, prompts e logs:

lino preferences culture set

Você será solicitado a escolher entre os idiomas disponíveis. Essa configuração garante que todas as instruções e prompts apareçam de forma consistente no idioma desejado.

Passo 3: Autenticação e registro

Para acessar todos os recursos do Lino, incluindo templates avançados, publicação de imagens Docker e integrações com serviços externos, é necessário estar autenticado.

- Caso ainda não possua cadastro, registre-se com o comando:

lino user register

- Caso já tenha cadastro, faça login com:

lino auth login

O que acontece: o CLI armazena um token de autenticação localmente, permitindo que você execute comandos que requerem acesso a recursos protegidos sem precisar se logar a cada uso.

Passo 4: Verificação

Para confirmar que a instalação e autenticação foram realizadas com sucesso, execute:

lino --version

Se o comando retornar a versão instalada, você está pronto para começar a utilizar o Lino CLI em seus projetos.

Criando o projeto MyApp

Neste passo, vamos criar a estrutura inicial do projeto utilizando o Lino CLI. Este projeto servirá como base para demonstrar a criação de serviços, módulos, front-end e toda a integração de eventos.

Passo 1: Executando o comando de criação

Para criar um novo projeto, execute o comando abaixo no terminal:

lino project new

O CLI irá guiá-lo passo a passo, solicitando informações como:

• Nome do projeto: usaremos MyApp, mas você pode escolher qualquer nome que desejar;
• Recursos adicionais: analisadores de código, cache distribuído, suporte a eventos assíncronos, etc.

Passo 2: Configurando recursos essenciais

Para este projeto, recomendamos habilitar os seguintes recursos desde o início:

• Analisadores de código: para garantir que o código esteja seguindo boas práticas e padrões consistentes, prevenindo erros comuns de implementação;
• Cache distribuído: melhora a performance da aplicação em cenários com múltiplos serviços, evitando consultas desnecessárias ao banco de dados;
• Comunicação assíncrona: habilita o uso de eventos e filas para integração entre serviços, garantindo escalabilidade e desacoplamento.

É importante habilitar todas essas opções neste projeto, pois criaremos múltiplos serviços que irão se comunicar através de eventos de integração. Isso permitirá que você compreenda como estruturar sistemas modulares e distribuídos usando o Lino.

Passo 3: Estrutura gerada

Após a execução do comando e configuração dos recursos, o CLI irá gerar a estrutura inicial do projeto. Ela incluirá:

• Pastas de serviços e módulos;
• Templates para front-end (se aplicável);
• Configurações iniciais de cache, eventos e integrações;
• Arquivos de solução (.slnx) e projeto (.csproj) prontos para compilação.

Agora seu projeto MyApp está pronto para receber os serviços, módulos, entidades e front-end que configuraremos nos próximos passos.

Adicionando o frontend

Agora vamos criar a interface do sistema, o frontend, que será utilizado como Backoffice. Este frontend não será uma aplicação pública, mas sim uma ferramenta interna para que administradores e gestores possam gerenciar produtos, categorias, estoques, vendas e outras informações do sistema.

Passo 1: Executando o comando de criação

Para adicionar um novo frontend ao projeto, utilize o seguinte comando no terminal:

lino webapp new

O CLI irá solicitar algumas informações durante o processo, como:

• Nome da aplicação web: usaremos Backoffice para este exemplo;

Passo 2: Estrutura gerada

Ao final do processo, o CLI irá gerar a estrutura inicial do frontend dentro da pasta WebApps/Backoffice. A estrutura padrão inclui:

• Pastas para páginas, componentes e serviços da aplicação;
• Clientes HTTP para consumir APIs dos serviços do projeto;
• Templates iniciais;
• Arquivos de configuração para integração com autenticação, autorização e eventos do sistema.

Observações importantes

• O frontend será automaticamente integrado aos serviços e módulos selecionados, permitindo que dados de produtos, categorias e vendas sejam consumidos diretamente via APIs geradas pelo Lino.
• Você pode criar múltiplos frontends, por exemplo, um para administradores (Backoffice) e outro público (Site), seguindo o mesmo processo.

Com o frontend criado, estamos prontos para avançar para a criação dos serviços e módulos que irão fornecer os dados e regras de negócio para esta aplicação.

Criando serviços e módulos

Nesta etapa, vamos construir os serviços e módulos que irão compor a aplicação. O objetivo é criar uma arquitetura modular e escalável, permitindo que diferentes áreas do sistema, como produtos, categorias, estoque, vendas e mídia, evoluam de forma independente, mantendo coesão e facilitando a manutenção.

Passo 1: Definindo os serviços

Inicialmente, criaremos os seguintes serviços, cada um com responsabilidades bem definidas:

• Catalog (modular) – responsável por gerenciar produtos, categorias e preços;
• Sales – responsável pelo processamento de vendas e pedidos;
• Stock – responsável pelo gerenciamento de estoques e movimentações;
• Security – responsável por autenticação, autorização e gerenciamento de usuários.

Para criar um novo serviço, execute o comando:

lino service new

Durante a execução do comando, o CLI irá solicitar:

• Nome do serviço: por exemplo, Catalog;
• Banco de dados: escolha a tecnologia que se adequa melhor ao seu projeto (SQL Server, PostgreSQL, etc.);

Passo 2: Criando módulos dentro de serviços

Nem todos os serviços precisam ser modulares. No nosso projeto, apenas o serviço Catalog terá módulos, para separar responsabilidades como merchandising e precificação.

Definimos para o serviço Catalog os seguintes módulos:

• Merchandising – gerenciamento de produtos e categorias;
• Pricing – gerenciamento de preços, promoções e histórico de alterações.

Para criar um módulo, execute o comando:

lino module new

Você pode criar quantos módulos desejar dentro do serviço modular Catalog. Além disso, dependendo da complexidade, alguns módulos poderiam se tornar serviços independentes futuramente. A separação apresentada aqui é apenas didática e serve como exemplo de organização modular.

Estrutura final do projeto

Após a criação dos serviços e módulos, sua solução deverá ter uma estrutura semelhante à seguinte:

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/

Explicação da estrutura:

• Services/: contém todos os serviços do sistema, cada um isolado com sua própria lógica de negócio, infraestrutura e hospedagem;
• Modules/: pastas dentro de serviços modulares, permitindo organizar funcionalidades específicas e manter código coeso;
• WebApps/: frontends associados ao sistema, já integrados aos serviços;
• Shared/: bibliotecas e recursos compartilhados entre serviços e frontends;
• tests/: testes unitários e de integração organizados por serviço e módulo.

Com essa estrutura modular, cada equipe ou desenvolvedor pode trabalhar de forma independente em diferentes partes do sistema, facilitando escalabilidade, manutenção e testes.

Adicionando autenticação e autorização

A autenticação e autorização são elementos essenciais de qualquer sistema moderno. No Lino CLI, adicioná-las ao seu projeto é simples e rápido.

Passo 1: Executando o comando de autenticação

Para adicionar os recursos de autenticação e autorização, utilize o comando:

lino features auth add

O CLI irá guiá-lo pelas seguintes etapas:

• Escolha do serviço ou módulo: você precisa indicar onde os artefatos de autenticação serão instalados. No nosso projeto de exemplo, utilizamos o serviço Security, que centraliza toda a lógica de segurança do sistema;
• Configurações adicionais: criação de tabelas de usuários, papéis, permissões e configuração de políticas de acesso.

Passo 2: Estrutura gerada

Após a execução do comando, o serviço Security conterá arquivos e pastas como:

• Entities: classes de usuários, papéis e permissões;
• Infrastructure: configurações do banco de dados e migrations para criar tabelas;
• Application: serviços de autenticação, gerenciamento de usuários e validação de credenciais;
• API/Host: endpoints para login, logout, cadastro e gerenciamento de papéis.

Com isso, sua aplicação terá autenticação robusta e controle de acesso granular, pronta para suportar múltiplos usuários e diferentes níveis de permissões.

Adicionando Background Jobs

Em sistemas distribuídos e modulares, como o que estamos construindo com o Lino CLI, nem todos os serviços se comunicam diretamente entre si. Para garantir consistência e confiabilidade na troca de informações, utilizamos eventos de integração. Porém, para processar esses eventos de forma eficiente e assíncrona, precisamos de Background Jobs.

O Lino utiliza o padrão Outbox Pattern para garantir que todas as mensagens geradas pelos serviços sejam registradas de forma confiável antes de serem enviadas. Com isso, conseguimos:

• Evitar a perda de eventos em caso de falhas ou reinicializações do serviço;
• Garantir que a mesma mensagem seja enviada apenas uma vez;
• Permitir o reprocessamento de mensagens em caso de falha na entrega;
• Separar o processamento de eventos da lógica principal da aplicação, melhorando performance e escalabilidade.

Passo 1: Executando o comando

Para adicionar suporte a Background Jobs no seu projeto, execute o comando:

lino features background-job add

O CLI irá solicitar que você selecione o serviço onde o Background Job será instalado. Geralmente, você escolherá o serviço que centraliza a produção de eventos, como Catalog ou Sales.

Passo 2: Configurando a execução

Durante a configuração, você poderá definir:

• Intervalo de verificação: determina com que frequência o Background Job irá verificar a tabela Outbox para novas mensagens. Um intervalo muito curto pode aumentar o uso de recursos, enquanto um intervalo longo pode atrasar a entrega de eventos;
• Lote de registros processados por vez: controla quantos eventos serão lidos e enviados por execução. Lotes maiores podem aumentar a performance, mas exigem mais memória e processamento;
• Política de retries: em caso de falha no envio de mensagens, você poderá configurar quantas vezes o job tentará reenviar.

Esses parâmetros dependem do tamanho do seu sistema, da capacidade da máquina e do volume esperado de eventos.

Passo 3: Estrutura gerada

Após a configuração, o projeto terá um Background Job pronto para processar mensagens das tabelas Outbox em cada serviço.

Com isso, você garante que todos os eventos de integração sejam processados de forma confiável e eficiente, permitindo que múltiplos serviços e módulos se comuniquem de forma assíncrona, sem impactar a performance do sistema principal.

Criando entidades e enumerações

Nesta seção, vamos detalhar o design das entidades, enumerações e objetos de valor da aplicação, mostrando em quais serviços e módulos cada item será criado.

1. Criando a entidade Category

Para criar a entidade, utilize o comando:

lino entity new

A entidade será criada no serviço Catalog e no módulo Merchandising com a seguinte estrutura:

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

2. Criando a entidade Product

Em seguida, criamos a entidade Product no mesmo serviço e módulo, incluindo objetos de valor e enumerações:

┌────┬────┬───────────────┬─────────────┬────────┬──────────┬────────────────┐
│ 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 Criando o Value Object ProductDimension

Este Value Object representa as dimensões do produto:

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

2.2 Criando a Enum ProductStatus

Esta enum define o status do produto:

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

3. Adicionando novas propriedades

Com a evolução do projeto, podemos editar entidades existentes para adicionar novas propriedades. Por exemplo, adicionaremos uma lista de imagens à entidade Product:

lino entity edit

Criando a propriedade Images do tipo List<ProductImage>, geraremos a seguinte estrutura:

┌────┬────┬───────────────┬────────────────────┬────────┬──────────┬────────────────┐
│ 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 Criando a entidade ProductImage

Esta entidade pertence ao agregado Product e possui a seguinte estrutura:

┌────┬────┬───────────────┬────────────────┬────────┬──────────┬────────────────┐
│ 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. Criando entidades para outros serviços

No serviço Sales, criamos a entidade ProductSnapshot, que será alimentada pelos eventos de integração. Como o Id original da entidade Product vem do serviço Catalog, ele não pode ser auto-incremental aqui.

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

Observação: apenas os campos essenciais foram replicados no ProductSnapshot para o serviço Sales. Entidades complementares, como Customer, Order e StockItem, não serão detalhadas aqui para simplificar a documentação.

Criando eventos e seus manipuladores

Recapitulando, no tópico anterior criamos no serviço modular Catalog.Merchandising as entidades Product, Category e ProductImage, enquanto no serviço Sales criamos a entidade ProductSnapshot.

Agora, vamos criar eventos de domínio e eventos de integração. O objetivo é que, ao criar ou atualizar produtos no serviço Catalog, essas alterações sejam replicadas para os serviços consumidores, como Sales e Stock.

1. Criando eventos de domínio

O primeiro passo é criar os eventos de domínio ProductCreated e ProductUpdated com o comando:

lino event new

Durante a criação, podemos associar o evento a um manipulador e, simultaneamente, configurar o disparo de um evento de integração. Isso centraliza a criação de todo o fluxo necessário.

┌──────────────────────────────────────────────────────┬────────────────────────────────┐
│ 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                 │
└──────────────────────────────────────────────────────┴────────────────────────────────┘

Da mesma forma, criamos o 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                   │
└──────────────────────────────────────────────────────┴────────────────────────────────┘

Com isso, temos:

• Eventos de domínio criados (ProductCreated e ProductUpdated);
• Manipuladores de eventos de domínio correspondentes;
• Eventos de integração registrados na Outbox automaticamente pelo manipulador de eventos de domínio.

2. Criando manipuladores de eventos de integração

O próximo passo é definir quais serviços irão consumir os eventos de integração. Para isso, usamos:

lino event-handler new

O fluxo de criação envolve:

• Selecionar o serviço, módulo e entidade que conterá o manipulador;
• Selecionar o evento de integração que será consumido e de qual serviço/módulo/entidade ele virá.

Por exemplo, no serviço Sales criamos os manipuladores para ProductCreated e ProductUpdated que irão consumir os eventos disparados pelo 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    │
└────────────────────────────────────────────┴───────────────────┘

Com isso, temos dois manipuladores de eventos de integração no serviço Sales, consumindo apenas os campos necessários dos eventos de integração do Catalog.Merchandising. Isso garante que as tabelas replicadas mantenham apenas os dados essenciais, otimizando armazenamento e desempenho.

Gerando páginas web, APIs, Commands e Queries

Uma das grandes vantagens do Lino CLI é permitir a criação integrada de páginas web, APIs, Commands e Queries de forma automatizada, simplificando todo o fluxo de desenvolvimento. Para iniciar, basta executar o comando:

lino page new

Durante o processo, você irá:

• Selecionar o serviço, módulo e entidade que deseja expor;
• Escolher os campos que farão parte da listagem;
• Gerar automaticamente páginas de listagem (grid paginado) e formulário de criação/edição;
• Gerar classes de HttpClient para consumo pelo frontend;
• Criar todas as APIs REST necessárias (POST, PUT, PATCH, DELETE e GET);
• Criar Commands e Queries, com seus respectivos Handlers, que vão até o banco de dados garantindo o fluxo completo de CRUD.

Com esse comando, você obtém uma aplicação funcional sem precisar escrever manualmente a camada de interface, APIs e lógica de negócio, mantendo o padrão e a consistência entre serviços.

Para este projeto, podemos gerar as páginas integradas para as seguintes entidades:

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

Após gerar as páginas, APIs e Commands/Queries, a aplicação estará pronta para interagir de forma completa entre frontend e backend, com validações, rotas e persistência já configuradas automaticamente pelo Lino CLI.

Criando migrações de bancos de dados

Agora que todas as entidades foram criadas, é hora de gerar as migrações para que os bancos de dados sejam criados ou atualizados conforme o modelo definido. O Lino CLI automatiza esse processo, integrando-se ao Entity Framework e criando scripts prontos para execução.

Para criar uma nova migração, execute o comando:

lino database migrations new

Durante a execução, você precisará:

• Selecionar o serviço e módulo que receberão a migração;
• Informar uma descrição para a migração, por exemplo, "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 │
└───────────────────────────────────────────┴───────────────────┘

Ao confirmar, o Lino CLI irá gerar:

• Uma nova migração de banco de dados na versão atual do serviço;
• Um script SQL correspondente, localizado na camada Infrastructure.Persistence, no caminho /scripts/<version>/<nome do arquivo>;
• O registro da versão da migração no histórico do serviço, garantindo rastreabilidade e consistência.

Boas práticas:

• Crie novas migrações sempre que houver alterações no modelo de dados (novas entidades, propriedades ou alterações de relacionamento);
• Revise os scripts SQL gerados antes de aplicar em produção;
• Mantenha o controle de versão da base de dados alinhado com a versão da aplicação, evitando conflitos e problemas de sincronização.

Seguindo esse fluxo, você garante que o banco de dados esteja sempre atualizado e consistente com o modelo de domínio definido no Lino CLI, reduzindo erros e simplificando a manutenção.

Gerando imagens Docker

Após concluir a geração do código para uma versão específica, realizar testes e implementar todas as regras de negócio necessárias, você pode gerar imagens Docker dos serviços e aplicações web do seu projeto para posterior publicação em um registro de contêineres.

O Lino CLI simplifica esse processo com o comando:

lino build

Ao executar, você verá uma lista de todos os serviços e aplicações web disponíveis no projeto, juntamente com suas versões atuais:

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|

Você pode selecionar um ou mais serviços e aplicações web para gerar imagens simultaneamente. Basta marcar os itens desejados.

Em seguida, será solicitado escolher como deseja atualizar a versão das imagens geradas. As opções disponíveis são:

• Manter a versão atual – não altera a versão existente;
• Patch – incrementa a versão de patch (ex.: 0.1.0 → 0.1.1);
• Minor – incrementa a versão menor (ex.: 0.1.0 → 0.2.0);
• Major – incrementa a versão principal (ex.: 0.1.0 → 1.0.0).

Após selecionar os serviços e definir o incremento de versão, o Lino CLI realiza:

• Build do código de cada serviço e aplicação web;
• Geração da imagem Docker correspondente;
• Aplicação da tag com a versão definida;
• Disponibilização das imagens para publicação em seu registro de contêineres.

Ao final do processo, considerando que todos os serviços e aplicações web foram selecionados, as imagens geradas terão a seguinte estrutura:

• 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

Observação: Esse processo garante consistência entre o código e a versão das imagens Docker, facilitando o deploy e a manutenção de múltiplos ambientes, além de permitir que cada serviço seja isolado em contêineres independentes.

Criando versões na aplicação

Incrementar novas versões aos serviços ou aplicações web é um processo simples e centralizado no Lino CLI. Basta executar o comando:

lino version bump

Assim como na geração de imagens Docker, ao executar esse comando você verá uma lista completa de todos os serviços e aplicações web do seu projeto. Apenas os itens que você selecionar terão sua versão incrementada, enquanto os demais permanecerão inalterados.

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|

Após selecionar os itens desejados, você será solicitado a escolher o tipo de incremento de versão. As opções disponíveis são:

• Patch – pequenas correções sem impacto funcional;
• Minor – adição de novas funcionalidades compatíveis com versões anteriores;
• Major – alterações que podem quebrar compatibilidade com versões anteriores.

É importante destacar que as versões dos serviços e aplicações web têm impacto direto em:

• As tags das imagens Docker;
• As pastas utilizadas para armazenar scripts gerados pelas migrações de banco de dados;
• O controle de releases e histórico do projeto.

Com isso, concluímos o guia passo a passo de todos os comandos essenciais para a construção de um projeto web utilizando o Lino CLI, desde a instalação, criação de serviços, entidades, eventos e páginas, até a geração de imagens Docker e versionamento.

Não deixe de acompanhar nosso canal no YouTube para acompanhar tutoriais detalhados, demonstrações práticas e dicas de uso da ferramenta, desde operações simples até recursos avançados.