DEV Community: TiagoMabango

When to Migrate to Microservices: A Journey from 1 to 1 Million Users

TiagoMabango — Tue, 29 Apr 2025 11:00:09 +0000

Introduction

Deciding when to move from a monolithic architecture to microservices is one of the most critical choices in a software project. Many assume microservices are the answer from day one, but reality tells a different story. There are ideal moments for this shift, driven by technical growth, user base expansion, and business complexity.

In this article, we’ll walk through an evolutionary scenario—starting with just 1 user and scaling up to 1 million—to explore:

Recommended architecture for each growth phase
Technology choices
Infrastructure options (cloud or physical servers)
Technical and financial analysis at each stage

Phase 1: 1 to 100 Users

Architecture: Simple Monolith

Recommended Tech Stack:

Backend: Node.js, Django, Laravel, or ASP.NET Core
Database: PostgreSQL or MySQL
Frontend: React, Vue, or Angular

Infrastructure:

Local physical server or low-cost cloud (e.g., DigitalOcean, AWS Lightsail)

Technical Analysis:

Low complexity, fast development
Minimal deployment requirements
Easy to debug and maintain

Financial Analysis:

Hosting costs start at $5/month
Prioritize feature delivery over scalability

Decision:

Microservices are unnecessary at this stage
Focus on speed, feedback, and cost-efficiency

Phase 2: 100 to 10,000 Users

Architecture: Modular Monolith

Recommended Tech Stack:

Clear separation of backend layers (services, repositories, controllers)
Frontend begins to decouple (SPA architecture)

Infrastructure:

Scalable cloud VMs (AWS EC2 t3.medium, Azure B2s, etc.)
Use of CDNs and managed databases

Technical Analysis:

More business logic = more moving parts
Deploys become riskier due to module dependencies
Scaling the entire app for one bottleneck becomes inefficient

Financial Analysis:

Infrastructure costs range from $100 to $500/month
Still cheaper to scale the monolith than to split into services

Decision:

Evaluate monolith limits
Start pre-modularizing for future service extraction

Phase 3: 10,000 to 100,000 Users

Architecture: Hybrid (Monolith + External Services)

Recommended Tech Stack:

First independent services: Auth, notifications, media processing
Inter-service communication via REST APIs or gRPC

Infrastructure:

Fully cloud-based: AWS ECS, Azure App Services, GCP App Engine
Separate DBs for critical services
Load balancers in place (e.g., AWS ELB)

Technical Analysis:

Monolith bottlenecks emerge (build time, coupled releases)
Partial decoupling improves resilience and deployment independence

Financial Analysis:

Hosting costs from $500 to $5,000/month
More teams, more infrastructure complexity

Decision:

Start splitting services that need to scale independently
Introduce observability tools: tracing, logging, metrics, alerts

Phase 4: 100,000 to 1,000,000 Users

Architecture: True Microservices

Recommended Tech Stack:

Each service has its own database
Use of message brokers (RabbitMQ, Kafka, SQS) for async communication
API Gateway for public access
Strong DevOps pipelines (CI/CD)

Infrastructure:

Kubernetes (EKS, AKS, GKE) or serverless (AWS Lambda, Azure Functions)
Use of Edge Computing for performance
Possible multi-cloud strategy

Technical Analysis:

Services are fully independent: deploy, test, and scale in isolation
Fault isolation improves uptime
High orchestration complexity requires specialized roles (DevOps, SREs)

Financial Analysis:

Infrastructure can cost $10,000 to $100,000+/month
Requires dedicated architecture and operations teams

Decision:

At this scale, microservices become mandatory
Focus shifts from “should we?” to “how well can we orchestrate and scale?”

Final Thoughts

Don’t rush microservices adoption.
Premature complexity is a form of technical debt.
Microservices make sense when:
- You need independent scalability
- Your team is large and mature enough to handle distributed systems
- The business logic exceeds what a monolith can reasonably support
Cloud becomes almost non-negotiable after 10,000 users

Visual Summary:

Phase	Users	Architecture	Key Decision
1	1–100	Simple Monolith	Focus on delivery
2	100–10,000	Modular Monolith	Prepare to modularize
3	10k–100k	Hybrid (Partial Services)	Extract key services
4	100k–1M	Full Microservices	Orchestrate at scale

IA: A Era da Preguiça ou a Era da Produtividade?

TiagoMabango — Sat, 12 Apr 2025 08:16:33 +0000

Vivemos uma transformação histórica. A Inteligência Artificial (IA) está rapidamente se tornando parte do nosso cotidiano, gerando duas reações distintas: alguns a veem como a facilitadora da preguiça, outros como a maior aliada da produtividade moderna. Afinal, qual será o nosso destino?

🤖 O que é Inteligência Artificial?

A IA é a capacidade de máquinas simularem comportamentos humanos como raciocinar, aprender, planejar e resolver problemas. Ela já está presente em assistentes virtuais, sistemas de recomendação, carros autônomos e até no diagnóstico médico.

😴 O que é a Preguiça e como ela surge?

Preguiça é um estado de desmotivação para realizar uma tarefa, mesmo que a pessoa tenha condições físicas e mentais de fazê-la. Pode ser causada por:

Falta de estímulo mental ou físico
Procrastinação
Falta de propósito
Excesso de tarefas repetitivas
Dependência excessiva da tecnologia

🧠 Como estimular o cérebro e vencer a preguiça?

Estabeleça metas claras e pequenas
Faça pausas inteligentes com técnicas como Pomodoro
Movimente-se fisicamente para ativar a mente
Durma bem para manter a energia e clareza mental
Aprenda algo novo regularmente

📉 Profissões que a IA pode substituir (ou transformar)

Com a automação e IA, muitas profissões correm risco de desaparecer ou serem totalmente reformuladas:

💼 Profissões em risco:

Operadores de telemarketing
Atendentes de call center
Caixas de supermercado
Digitadores e datilógrafos
Analistas de crédito (básicos)
Auxiliares administrativos
Motoristas (com veículos autônomos)

Essas ocupações envolvem tarefas repetitivas e previsíveis — áreas onde a IA é extremamente eficiente.

🌱 Novas profissões que vão surgir (fora da área tech)

Nem tudo está perdido — pelo contrário. A IA também cria novas oportunidades, especialmente para quem tiver criatividade, empatia, senso crítico e pensamento estratégico.

🧑‍🎨 Profissões emergentes fora da tecnologia:

Curador de Conteúdo Criativo com IA
Educador Digital com foco em IA
Consultor de Produtividade com IA
Estilista ou Designer de Moda com IA
Diretor de Arte Generativa
Especialista em Comunicação Ética com IA
Redator de Roteiros com IA
Terapeuta com IA de apoio
Planejador de Viagens com IA
Analista de Tendências Culturais

Essas profissões exigem algo que a IA ainda não tem: sensibilidade, ética, empatia, visão humana.

🧠 E as tarefas complexas? Continuaremos a fazer?

Sim, mas com um novo papel.

Tarefas que exigem:

Julgamento ético
Criatividade disruptiva
Tomadas de decisão estratégicas
Inteligência emocional e liderança
Análise de contextos ambíguos

... continuarão nas mãos humanas — com a IA servindo como parceira estratégica, e não como substituta.

📈 O que é produtividade? E como a IA ajuda?

Produtividade é fazer mais com menos esforço, tempo e recursos — sem perder qualidade. É ser eficiente e eficaz.

🚀 Como a IA impulsiona a produtividade?

Automatiza tarefas repetitivas (ex: organizar e-mails, gerar relatórios)
Ajuda na criação de conteúdo (textos, ideias, imagens)
Acelera a tomada de decisão (análise de dados e sugestões)
Organiza rotinas pessoais e profissionais (listas inteligentes, agendas)
Facilita o aprendizado (resumos, traduções, mapas mentais)

A IA se torna uma extensão da mente humana: aumenta a capacidade de pensar, agir, criar e decidir.

⚠️ Mas atenção:

IA não substitui o senso crítico, a ética, a criatividade e o propósito humano. Usá-la bem é o segredo para não virar refém da própria facilidade.

⏳ Transformações tecnológicas do passado: aprendizados para o futuro

A história mostra que toda nova tecnologia transforma a forma como vivemos e trabalhamos. Veja alguns exemplos:

Revolução Industrial: substituiu o trabalho manual com máquinas, criando fábricas e empregos urbanos
Energia elétrica: mudou os hábitos domésticos, lazer e permitiu a produção em massa
Internet: globalizou a informação, criou novas profissões e mudou o consumo e o aprendizado
Smartphones: colocaram o mundo no bolso, aumentando a conexão e a dependência digital

Cada uma dessas inovações causou medo e resistência no início, mas quem se adaptou prosperou.

🧭 A Nova Era com a IA: adaptação é a chave

Estamos agora entrando na Era da Inteligência Artificial — e, assim como nas revoluções anteriores, precisamos nos adaptar.

A IA não veio para parar o ser humano, mas para reformular o papel que exercemos na sociedade, nas empresas e em casa.

O que está acontecendo com a IA é uma repetição do que sempre aconteceu: quem resiste, fica para trás. Quem aprende e evolui, lidera.

Portanto, mais do que ter medo, é hora de compreender, aprender e usar a IA como alavanca de crescimento pessoal e profissional.

📚 Conclusão: Preguiça ou Produtividade?

A IA não cria preguiça por si só, mas pode alimentá-la se usada de forma passiva. Por outro lado, ela pode ser a maior aliada da produtividade inteligente.

Depende de quem a usa.

A era da IA será de preguiça para quem quiser comodidade absoluta.

Mas será de produtividade para quem enxergar nela uma ferramenta de potencialização humana.

Afinal, a IA não vai substituir humanos. Mas os humanos que souberem usá-la vão substituir os que não souberem.

Como Fazer Migrations com MySQL no .NET Usando o Visual Studio

TiagoMabango — Wed, 05 Mar 2025 06:58:35 +0000

As migrations no .NET permitem criar e gerenciar o banco de dados de forma programática, garantindo a rastreabilidade das mudanças no esquema. Quando utilizado com MySQL e o Visual Studio, o processo fica ainda mais prático. Abaixo está o passo a passo para configurar e usar as migrations.

Requisitos

Visual Studio instalado (de preferência a versão mais recente).
Servidor MySQL configurado.
.NET SDK instalado.

Passo 1: Criar o Projeto no Visual Studio

Abra o Visual Studio e selecione " Criar um novo projeto ".
Escolha "Aplicação de API da Web ASP.NET Core ".
Defina o nome do projeto e escolha o local de salvamento.
Selecione .NET 7.0 " (ou superior) e clique em Criar ".

Passo 2: Instalar os Pacotes Necessários

No menu superior, vá em " Ferramentas > Gerenciador de Pacotes NuGet > Console do Gerenciador de Pacotes ".
No console, execute os comandos abaixo:

powershell
Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Pomelo.EntityFrameworkCore.MySql

Passo 3: Configurar o DbContext

Crie uma pasta chamada Data e adicione uma classe ApplicationDbContext.cs.
Implemente o código abaixo:

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<User> Users { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Passo 4: Configurar a String de Conexão

No arquivo appsettings.json, adicione a string de conexão:

"ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=mydb;User=root;Password=mypassword;"
}

No Program.cs, registre o DbContext:

builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseMySql(builder.Configuration.GetConnectionString("DefaultConnection"),
                     ServerVersion.AutoDetect(builder.Configuration.GetConnectionString("DefaultConnection"))));

Passo 5: Criar e Aplicar Migrations

No Console do Gerenciador de Pacotes, crie a migration inicial:

Add-Migration InitialMigration

Para aplicar as migrations ao banco de dados, execute:

Update-Database

Passo 6: Testar a Aplicação

Execute a aplicação pressionando F5 ou o botão Iniciar.
Verifique no MySQL se as tabelas foram criadas corretamente.

Dicas Úteis

Para remover a última migration:

Remove-Migration

Para verificar o status das migrations:

Get-Migrations

Conclusão

O uso do Visual Studio facilita o gerenciamento das migrations e o controle do banco de dados durante o desenvolvimento. Com a combinação de .NET, MySQL e as ferramentas integradas do Visual Studio, você terá um fluxo de trabalho produtivo e eficiente.

How to Secure Your API Against Unauthorized Requests

TiagoMabango — Wed, 22 Jan 2025 14:18:54 +0000

APIs are critical components of modern applications, enabling communication between different systems. However, they are also frequent targets for unauthorized access and abuse. Securing your API requires a layered approach that combines CORS validation, strong authentication mechanisms, and robust monitoring. In this article, we will cover several strategies to protect your API and ensure it is only accessible by trusted clients.

1. Configure CORS Properly

Cross-Origin Resource Sharing (CORS) is an essential layer of security that determines which origins are allowed to interact with your API. Configuring CORS correctly is vital to prevent unauthorized access.

Example in ASP.NET Core:

builder.Services.AddCors(options =>
{
    options.AddPolicy("RestrictOrigins", policy =>
    {
        policy.WithOrigins("https://mywebsite.com", "https://trustedpartner.com") // Allowed origins
              .AllowAnyHeader()
              .AllowAnyMethod();
    });
});

// Apply the CORS policy
app.UseCors("RestrictOrigins");

Key Rules:

Avoid AllowAnyOrigin: Allowing all origins opens your API to vulnerabilities.
Do not use SetIsOriginAllowed(_ => true): This bypasses origin validation entirely.
Limit methods and headers: Restrict AllowAnyMethod and AllowAnyHeader to what is strictly necessary.

2. Implement Authentication and Authorization

Authentication ensures that only authorized users or systems can access your endpoints. A common approach is using JSON Web Tokens (JWT).

Steps to Implement JWT:

On the client side, send the JWT in the request header:

   Authorization: Bearer <your-jwt-token>

On the server side, validate the token:

   app.UseAuthentication();
   app.UseAuthorization();

Example Configuration in ASP.NET Core:

builder.Services.AddAuthentication("Bearer")
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = "https://mywebsite.com",
            ValidAudience = "https://mywebsite.com",
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("secret-key"))
        };
    });

3. Validate the `Origin` Header Explicitly

Even with CORS configured, you can add an extra layer of security by manually validating the Origin header in server-side middleware.

Example:

app.Use(async (context, next) =>
{
    var origin = context.Request.Headers["Origin"].ToString();
    var allowedOrigins = new[] { "https://mywebsite.com", "https://trustedpartner.com" };

    if (!string.IsNullOrEmpty(origin) && !allowedOrigins.Contains(origin))
    {
        context.Response.StatusCode = StatusCodes.Status403Forbidden;
        await context.Response.WriteAsync("Origin not allowed.");
        return;
    }

    await next();
});

4. Block Suspicious IPs

Filter and block requests from known malicious IP addresses to reduce attack vectors.

Example Middleware:

app.Use(async (context, next) =>
{
    var clientIp = context.Connection.RemoteIpAddress;
    var blockedIps = new[] { "192.168.1.100", "10.0.0.50" };

    if (blockedIps.Contains(clientIp.ToString()))
    {
        context.Response.StatusCode = StatusCodes.Status403Forbidden;
        await context.Response.WriteAsync("Blocked IP.");
        return;
    }

    await next();
});

5. Implement Rate Limiting

Protect your API from abuse and brute force attacks by limiting the number of requests a client can make.

Example with ASP.NET Core:

Install the package:

dotnet add package AspNetCoreRateLimit

Configure rate limiting:

builder.Services.AddMemoryCache();
builder.Services.Configure<IpRateLimitOptions>(options =>
{
    options.GeneralRules = new List<RateLimitRule>
    {
        new RateLimitRule
        {
            Endpoint = "*",
            Limit = 100, // Request limit
            Period = "1m" // Per minute
        }
    };
});

builder.Services.AddInMemoryRateLimiting();
app.UseIpRateLimiting();

6. Use HTTPS for All Connections

Ensure secure communication between clients and your API by enforcing HTTPS.

Configure HTTPS in ASP.NET Core:

webBuilder.UseKestrel()
          .UseHttps();

Redirect HTTP traffic to HTTPS:

app.UseHttpsRedirection();

7. Monitor and Log Requests

Implement logging to detect unusual patterns, such as multiple requests from unknown origins.

Example:

app.Use(async (context, next) =>
{
    var origin = context.Request.Headers["Origin"].ToString();
    Console.WriteLine($"Request from origin: {origin}");
    await next();
});

Use tools like Application Insights, Serilog, or Elastic Stack for comprehensive monitoring.

8. Avoid Detailed Error Responses

Do not expose sensitive information in error messages, as it can aid attackers.

Example:

app.UseExceptionHandler("/error"); // Redirect errors to a secure page

Conclusion

Securing your API against unauthorized requests requires a multi-layered approach:

Configure CORS properly.
Validate origins and headers explicitly.
Implement authentication and rate limiting.
Use HTTPS and monitor traffic.

By following these best practices, you can significantly reduce the risk of unauthorized access and ensure that only trusted clients can interact with your API.

Arquitetura RESTful Moderna: Guia Completo de Comunicação Frontend-Backend.

TiagoMabango — Thu, 16 Jan 2025 07:13:53 +0000

Arquitetura RESTful Moderna: Guia Completo de Comunicação Frontend-Backend

A arquitetura RESTful se tornou o padrão de facto para desenvolvimento de aplicações web modernas. Neste artigo, vamos explorar como estruturar uma aplicação completa com comunicação Frontend-Backend seguindo as melhores práticas REST.

Estrutura do Frontend

Camadas Principais

Interface do Usuário (UI)
- Componentes visuais
- Gerenciamento de estado
- Interação com usuário
Services/API Clients
- Abstração das chamadas HTTP
- Gerenciamento de requests/responses
- Tratamento de erros

Estrutura do Backend (API RESTful)

Camadas Principais

Controllers
- Gerenciamento de rotas
- Validação de inputs
- Direcionamento para services
Services
- Lógica de negócio
- Regras da aplicação
- Orquestração de dados
Repository
- Acesso ao banco de dados
- Persistência de dados
- Queries e transformações

Endpoints REST e Operações CRUD

GET - Leitura

GET /api/resource       # Lista recursos
GET /api/resource/:id   # Obtém recurso específico

POST - Criação

POST /api/resource      # Cria novo recurso

Payload exemplo:

{
    "name": "Novo Recurso",
    "description": "Descrição do recurso"
}

PUT - Atualização

PUT /api/resource/:id   # Atualiza recurso existente

Payload exemplo:

{
    "name": "Recurso Atualizado",
    "description": "Nova descrição"
}

DELETE - Remoção

DELETE /api/resource/:id  # Remove recurso

Boas Práticas

Nomenclatura de Endpoints
- Use substantivos no plural para recursos
- Mantenha URLs consistentes e intuitivas
- Utilize hierarquia quando necessário
Status HTTP
- 200: Sucesso
- 201: Criação bem-sucedida
- 400: Erro do cliente
- 404: Recurso não encontrado
- 500: Erro do servidor
Segurança
- Implemente autenticação JWT
- Use HTTPS
- Valide inputs
- Implemente rate limiting
Performance
- Utilize caching quando possível
- Implemente paginação
- Otimize queries
- Use compressão de dados

Considerações de Implementação

Frontend
- Use frameworks modernos (React, Angular, Vue)
- Implemente gerenciamento de estado
- Crie interceptors para tratamento de erros
- Desenvolva componentes reutilizáveis
Backend
- Utilize frameworks robustos (Spring, Node.js/Express, Laravel)
- Implemente logging e monitoramento
- Use documentação automática (Swagger/OpenAPI)
- Mantenha versionamento da API

Conclusão

Uma arquitetura RESTful bem implementada proporciona escalabilidade, manutenibilidade e uma clara separação de responsabilidades. A chave é manter a consistência nas convenções adotadas e seguir os princípios REST.

DEV Community: TiagoMabango

When to Migrate to Microservices: A Journey from 1 to 1 Million Users

Phase 1: 1 to 100 Users

Phase 2: 100 to 10,000 Users

Phase 3: 10,000 to 100,000 Users

Phase 4: 100,000 to 1,000,000 Users

Final Thoughts

IA: A Era da Preguiça ou a Era da Produtividade?

🤖 O que é Inteligência Artificial?

😴 O que é a Preguiça e como ela surge?

🧠 Como estimular o cérebro e vencer a preguiça?

📉 Profissões que a IA pode substituir (ou transformar)

💼 Profissões em risco:

🌱 Novas profissões que vão surgir (fora da área tech)

🧑‍🎨 Profissões emergentes fora da tecnologia:

🧠 E as tarefas complexas? Continuaremos a fazer?

📈 O que é produtividade? E como a IA ajuda?

🚀 Como a IA impulsiona a produtividade?

⚠️ Mas atenção:

⏳ Transformações tecnológicas do passado: aprendizados para o futuro

🧭 A Nova Era com a IA: adaptação é a chave

📚 Conclusão: Preguiça ou Produtividade?

Como Fazer Migrations com MySQL no .NET Usando o Visual Studio

Passo 3: Configurar o DbContext

Passo 4: Configurar a String de Conexão

Passo 5: Criar e Aplicar Migrations

Passo 6: Testar a Aplicação

Dicas Úteis

Conclusão

How to Secure Your API Against Unauthorized Requests

1. Configure CORS Properly

Example in ASP.NET Core:

Key Rules:

2. Implement Authentication and Authorization

Steps to Implement JWT:

Example Configuration in ASP.NET Core:

3. Validate the Origin Header Explicitly

Example:

4. Block Suspicious IPs

Example Middleware:

5. Implement Rate Limiting

Example with ASP.NET Core:

6. Use HTTPS for All Connections

Configure HTTPS in ASP.NET Core:

7. Monitor and Log Requests

Example:

8. Avoid Detailed Error Responses

Example:

Conclusion

Arquitetura RESTful Moderna: Guia Completo de Comunicação Frontend-Backend.

Arquitetura RESTful Moderna: Guia Completo de Comunicação Frontend-Backend

Estrutura do Frontend

Camadas Principais

Estrutura do Backend (API RESTful)

Camadas Principais

Endpoints REST e Operações CRUD

GET - Leitura

POST - Criação

PUT - Atualização

DELETE - Remoção

Boas Práticas

Considerações de Implementação

Conclusão

3. Validate the `Origin` Header Explicitly