📡 Como Comunicar Múltiplas APIs com .NET – ██FR█████ █INTELL███████████

This content originally appeared on DEV Community and was authored by Danilo O. Pinheiro, dopme.io

No ecossistema de software moderno, é cada vez mais comum que aplicações precisem se comunicar com múltiplas APIs para compor funcionalidades. Essa integração pode envolver APIs internas (microserviços) ou externas (parceiros, serviços de terceiros).
No .NET, temos um conjunto robusto de ferramentas e práticas para garantir que essa comunicação seja eficiente, resiliente e segura.

Neste artigo, vamos explorar os principais padrões, bibliotecas e estratégias para implementar comunicação entre múltiplas APIs usando .NET moderno.

1. Desafios na Comunicação com Múltiplas APIs

Antes de entrar nas soluções, é importante entender os principais desafios que surgem:

Gerenciamento de conexões: evitar abertura excessiva de conexões HTTP.
Resiliência e tolerância a falhas: lidar com indisponibilidade temporária.
Latência e performance: evitar bloqueios e gargalos.
Segurança: autenticação, autorização e proteção contra ataques.
Padronização: manter consistência no tratamento de erros, logs e métricas.

2. Estrutura Base com HttpClientFactory

No .NET Core e posteriores, a forma recomendada de fazer chamadas HTTP é utilizando o IHttpClientFactory. Ele resolve problemas como socket exhaustion e facilita a configuração de políticas globais.

builder.Services.AddHttpClient("ServiceA", client =>
{
    client.BaseAddress = new Uri("https://api.servicoa.com");
    client.DefaultRequestHeaders.Add("Accept", "application/json");
});

builder.Services.AddHttpClient("ServiceB", client =>
{
    client.BaseAddress = new Uri("https://api.servicob.com");
});

E o uso:

public class ApiService
{
    private readonly HttpClient _clientA;
    private readonly HttpClient _clientB;

    public ApiService(IHttpClientFactory factory)
    {
        _clientA = factory.CreateClient("ServiceA");
        _clientB = factory.CreateClient("ServiceB");
    }

    public async Task<string> GetFromServiceAAsync()
    {
        var response = await _clientA.GetAsync("/endpoint");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

3. Padrões de Comunicação

3.1 Comunicação Síncrona

Chamadas HTTP diretas, geralmente usando REST ou gRPC. Boa para respostas imediatas, mas exige cuidado com latência.

3.2 Comunicação Assíncrona

Uso de mensageria (RabbitMQ, Kafka, Azure Service Bus) para desacoplar serviços e aumentar resiliência.

3.3 API Gateway

Centraliza chamadas para múltiplas APIs. Exemplos no .NET: Ocelot, YARP.

4. Resiliência com Polly

Para evitar falhas em cascata, usamos o Polly, uma biblioteca que implementa políticas de retry, circuit breaker, timeout e fallback.

builder.Services.AddHttpClient("ServiceA", client =>
{
    client.BaseAddress = new Uri("https://api.servicoa.com");
})
.AddTransientHttpErrorPolicy(p => p.WaitAndRetryAsync(3, _ => TimeSpan.FromSeconds(2)))
.AddTransientHttpErrorPolicy(p => p.CircuitBreakerAsync(5, TimeSpan.FromSeconds(30)));

5. Segurança e Autenticação

Quando lidamos com múltiplas APIs, precisamos padronizar a autenticação:

OAuth 2.0 / OpenID Connect para APIs externas.
JWT para APIs internas.
API Keys quando não há suporte a protocolos mais avançados.

Exemplo de configuração de token JWT no HttpClient:

builder.Services.AddHttpClient("SecureService", client =>
{
    client.BaseAddress = new Uri("https://api.secure.com");
    client.DefaultRequestHeaders.Authorization =
        new AuthenticationHeaderValue("Bearer", "seu-token-aqui");
});

6. Observabilidade

Para monitorar múltiplas integrações, é essencial incluir:

Logging com ILogger<T>.
Tracing distribuído com OpenTelemetry.
Métricas expostas para Prometheus, Datadog, etc.

builder.Services.AddOpenTelemetryTracing(b =>
{
    b.AddAspNetCoreInstrumentation()
     .AddHttpClientInstrumentation()
     .AddJaegerExporter();
});

7. Estratégia de Versionamento e Evolução

Ao integrar múltiplas APIs, versionamento é fundamental:

Versionar endpoints (ex.: /v1/orders).
Criar camadas de abstração para evitar acoplamento direto.
Usar DTOs para controlar contratos de entrada e saída.

Conclusão

A comunicação entre múltiplas APIs com .NET exige mais do que apenas chamadas HTTP. É necessário pensar em resiliência, segurança, observabilidade e padronização. Ferramentas como HttpClientFactory, Polly, API Gateways e protocolos modernos como gRPC ajudam a criar integrações robustas e escaláveis.

Ao seguir boas práticas e padrões arquiteturais, conseguimos reduzir o risco de falhas, aumentar a manutenibilidade e preparar o sistema para crescer de forma sustentável.