Guia de Implementação de Arquitetura de Microsserviços com Spring Cloud Alibaba

Este guia explora a implementação de uma arquitetura de microsserviços robusta utilizando o ecossistema Spring Cloud Alibaba, abordando desde a configuração inicial até padrões avançados de resiliência.

Configuração do Ambiente

Pré-requisitos incluem JDK 8+, um servidor MySQL e o Maven configurado. O desenvolvimento é tipicamente realizado no IntelliJ IDEA.

Fundamentos do Spring Boot

O Spring Boot simplifica a criação de aplicações stand-alone com configuração mínima. Seus princípios chave são:

Deployment simplificado (executável como JAR/WAR)
Autoconfiguração inteligente via starters
Monitoramento integrado com Actuator

O Actuator fornece endpoints como /health para verificação de status e /actuator para descobrir endpoints disponíveis. A visibilidade detalhada é habilitada com:

management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=*

Gerenciamento de Configuração

O Spring Boot suporta múltiplas fontes de configuração. A abordagem recomendada para ambientes distintos (dev, prod) utiliza Profiles:

# application.yml
spring:
  profiles:
    active: dev

# configuração específica do profile
---
spring:
  config:
    activate:
      on-profile: dev
app:
  setting: valor-dev

Configurações externas via variáveis de ambiente ou argumentos de linha de comando (--key=value) sobrescrevem as do arquivo, seguindo uma ordem de precedência definida.

Decomposição em Microsserviços

A arquitetura monolítica apresenta desafios em escalabilidade e manutenção. Microsserviços promovem modulação, permitindo desenvolvimento e deploy independentes.

Domínios de Exemplo

Considerando um sistema de compartilhamento, podemos extrair dois domínios principais:

Centro de Usuários: Gerencia dados de autenticação, perfis e pontuação.
Centro de Conteúdo: Administra recursos compartilhados, metadados e transações de acesso.

Esquema do Banco de Dados

Para o Centro de Usuários:

-- Tabela principal de usuários
CREATE TABLE user_data (
    uid INT PRIMARY KEY AUTO_INCREMENT,
    wx_identifier VARCHAR(64) NOT NULL,
    display_name VARCHAR(64) NOT NULL,
    avatar_path VARCHAR(255),
    registration_date DATETIME NOT NULL,
    score_balance INT DEFAULT 300
);

-- Log de transações de pontos
CREATE TABLE score_transaction_log (
    log_id INT PRIMARY KEY AUTO_INCREMENT,
    user_ref INT NOT NULL,
    point_change INT NOT NULL,
    event_type VARCHAR(20),
    transaction_time DATETIME NOT NULL,
    note VARCHAR(100)
);

Para o Centro de Conteúdo:

-- Recursos compartilhados
CREATE TABLE shared_resource (
    resource_id INT PRIMARY KEY AUTO_INCREMENT,
    author_id INT NOT NULL,
    title VARCHAR(80) NOT NULL,
    creation_time DATETIME NOT NULL,
    is_original BOOLEAN DEFAULT FALSE,
    cover_image_url VARCHAR(256),
    description VARCHAR(256),
    access_cost INT DEFAULT 0,
    download_link VARCHAR(256),
    access_count INT DEFAULT 0,
    approval_status ENUM('PENDING','APPROVED','REJECTED') DEFAULT 'PENDING'
);

-- Muitos-para-muitos: usuários que adquiriram recursos
CREATE TABLE user_resource_access (
    access_id INT PRIMARY KEY AUTO_INCREMENT,
    user_ref INT NOT NULL,
    resource_ref INT NOT NULL
);

Scaffold do Projeto

Um projeto Spring Boot típico integra MyBatis para persistência. A configuração do gerador de código pode incluir suporte a Lombok:

<plugin>
    <groupId>org.mybatis.generator</groupId>
    <artifactId>mybatis-generator-maven-plugin</artifactId>
    <configuration>
        <!-- ... -->
    </configuration>
    <dependencies>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>4.1.5</version>
        </dependency>
    </dependencies>
</plugin>

Uma aplicação Spring Boot inicial:

@SpringBootApplication
@MapperScan("com.example.app.repository")
public class UserServiceApp {
    public static void main(String[] args) {
        SpringApplication.run(UserServiceApp.class, args);
    }
}

Orquestração com Spring Cloud Alibaba

O Spring Cloud Alibaba oferece uma suíte completa para microsserviços, alinhada com os padrões do Spring Cloud.

Descoberta de Serviços com Nacos

Nacos serve como servidor de configuração e registro de serviços. Para registrar um microsserviço:

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

# application.yml
spring:
  application:
    name: content-service
  cloud:
    nacos:
      discovery:
        server-addr: nacos-host:8848
        cluster-name: REGION-A
        metadata:
          version: "1.0"

A obtenção de instâncias de um serviço é feita programaticamente via DiscoveryClient.

Balanceamento de Carga com Ribbon

Integrado ao spring-cloud-starter-alibaba-nacos-discovery, o Ribbon fornece balanceamento do lado do cliente. Para ativar:

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced // Habilita Ribbon no RestTemplate
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

O balanceador pode ser customizado por serviço. Para escolher aleatoriamente entre instâncias:

public class RandomSelectionRule extends AbstractLoadBalancerRule {
    @Override
    public Server choose(Object key) {
        List<Server> servers = getLoadBalancer().getReachableServers();
        return servers.get(ThreadLocalRandom.current().nextInt(servers.size()));
    }
    // ... métodos de configuração
}

A configuração via propriedades é preferida por sua simplicidade:

# Balanceamento aleatório para o serviço 'user-service'
user-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

Cliente HTTP Declarativo com Feign

O Feign abstrai chamadas HTTP em interfaces Java, simplificando a comunicação interserviços.

// Declarar a interface do cliente
@FeignClient(name = "user-service", configuration = FeignLogConfig.class)
public interface UserClient {
    @GetMapping("/users/{userId}")
    UserDetails fetchUser(@PathVariable("userId") Long id);
}

// Utilizar no serviço
@Service
public class ContentServiceImpl {
    private final UserClient userClient;

    public ContentDetails getContent(Long contentId) {
        // ... busca o conteúdo
        UserDetails author = userClient.fetchUser(content.getAuthorId());
        // ... combina os dados
    }
}

A configuração de logging (ex: nível FULL) é aplicada diretamente na anotação ou via YAML:

feign:
  client:
    config:
      default:
        loggerLevel: basic

Para performance, pode-se trocar o cliente HTTP subjacente por Apache HttpClient ou OkHttp e configurar pools de conexão.

Resiliência com Sentinel

Sentinel gerencia fluxo de tráfego, circuit breaking e degradação de sistema.

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

Recursos (endpoints ou blocos de código) podem ser protegidos anotando-os com @SentinelResource. O dashboard do Sentinel permite definir regras como:

Controle de Fluxo: Limitar QPS ou número de threads concorrentes para um recurso.
Degradação: Abrir o circuito após N exceções ou tempo de resposta alto, redirecionando para um fallback.

A integração com o console permite monitoramento em tempo real e configuração dinâmica das regras.

Conclusão

A combinação de Nacos para descoberta e configuração, Ribbon para balanceamento, Feign para comunicação e Sentinel para resiliência forma uma base sólida para arquiteturas de microsserviços escaláveis e resilientes.

Tags: Spring Cloud Alibaba Nacos Ribbon Feign sentinel

Publicado em 6-21 21:23

Doido Dev