Microsserviços em TypeScript: arquitetura e prática

Introdução: Por que TypeScript em microsserviços?

A arquitetura de microsserviços tornou-se o padrão para construir aplicações escaláveis e tolerantes a falhas. No entanto, a escolha da linguagem de programação pode impactar significativamente a velocidade de desenvolvimento e a qualidade do código. TypeScript — um superconjunto estritamente tipado de JavaScript — oferece o equilíbrio ideal entre flexibilidade e confiabilidade. Graças à tipagem estática, interfaces e um sistema de módulos poderoso, o TypeScript permite identificar erros em tempo de compilação, e não em tempo de execução, o que é crucial para sistemas distribuídos.

Neste artigo, vamos explorar os princípios-chave da construção de microsserviços com TypeScript, analisar frameworks populares (NestJS, Fastify), configurar a comunicação entre serviços via RabbitMQ, bem como a conteinerização com Docker. Todos os exemplos de código serão apresentados em TypeScript para que você possa aplicá-los imediatamente em seus projetos.

1. Escolha do framework: NestJS vs Fastify

Para criar microsserviços em TypeScript, existem vários frameworks. Os dois mais populares são NestJS e Fastify. Vamos analisar suas características.

NestJS — "Angular para o backend"

NestJS oferece uma arquitetura modular, inspirada no Angular. Ele vem com uma camada de transporte pronta para microsserviços (TCP, Redis, RabbitMQ, Kafka). É a escolha ideal para projetos grandes, onde a estruturação e o suporte de uma equipe de desenvolvimento são importantes.

// Exemplo de microsserviço básico com NestJSimport { NestFactory } from '@nestjs/core';import { Transport, MicroserviceOptions } from '@nestjs/microservices';import { AppModule } from './app.module';

async function bootstrap() {  const app = await NestFactory.createMicroservice<MicroserviceOptions>(    AppModule,    {      transport: Transport.RMQ,      options: {        urls: ['amqp://localhost:5672'],        queue: 'orders_queue',        queueOptions: { durable: false },      },    },  );  await app.listen();}bootstrap();

Fastify — desempenho e simplicidade

Fastify é um framework HTTP ultrarrápido para Node.js. Ele não oferece suporte nativo a microsserviços, mas integra-se facilmente com RabbitMQ ou NATS através de pacotes separados. É adequado para casos onde o desempenho é crítico e a arquitetura já está definida.

// Exemplo de servidor com Fastify + TypeScriptimport fastify from 'fastify';

const server = fastify({ logger: true });

server.get('/health', async (request, reply) => {  return { status: 'OK', service: 'payment-service' };});

const start = async () => {  try {    await server.listen({ port: 3000 });  } catch (err) {    server.log.error(err);    process.exit(1);  }};start();

Conclusão: para iniciantes e projetos em equipe, escolha NestJS. Para sistemas de alta carga com arquitetura já bem definida, escolha Fastify.

2. Comunicação entre serviços: RabbitMQ e Redis

Na arquitetura de microsserviços, os serviços se comunicam entre si através de brokers de mensagens ou requisições HTTP diretas. Vamos analisar duas abordagens populares.

RabbitMQ — fila de mensagens confiável

RabbitMQ garante a transmissão assíncrona de mensagens com garantia de entrega. Em TypeScript, para trabalhar com RabbitMQ, frequentemente se usa a biblioteca amqplib ou os módulos integrados do NestJS.

// Publicando uma mensagem no RabbitMQ (TypeScript)import * as amqp from 'amqplib';

async function publishOrder(order: any) {  const connection = await amqp.connect('amqp://localhost');  const channel = await connection.createChannel();  const queue = 'orders';

  await channel.assertQueue(queue, { durable: true });  channel.sendToQueue(queue, Buffer.from(JSON.stringify(order)), {    persistent: true,  });

  console.log(`Order sent: ${order.id}`);  setTimeout(() => connection.close(), 500);