O Nacos (Dynamic Naming and Configuration Service) é uma plataforma focada no gerenciamento de microserviços, facilitando a descoberta de instâncias e a centralização de configurações. Construído sobre o ecossistema Spring Boot, o Nacos pode ser iniciado rapidamente para desenvolvimento.

Para iniciar o servidor Nacos em modo local (Standalone) no Windows, execute o seguinte comando no diretório bin:

startup.cmd -m standalone

A interface administrativa fica disponível em localhost:8848/nacos, utilizando as credenciais padrão nacos/nacos.

1. Gerenciamento de Configuração

1.1 Utilizando o Java SDK

Para interagir programaticamente com o Nacos sem depender de frameworks complexos, utilizamos o nacos-client. Abaixo, um exemplo de como recuperar e monitorar alterações em um arquivo de configuração.

Dependência Maven:

<dependency>
    <groupId>com.alibaba.nacos</groupId>
    <artifactId>nacos-client</artifactId>
    <version>2.2.1</version>
</dependency>

Exemplo de Implementação:

public class NacosConfigManager {
    public static void main(String[] args) throws Exception {
        String remoteAddress = "127.0.0.1:8848";
        String configId = "app-settings";
        String groupName = "DEFAULT_GROUP";

        Properties props = new Properties();
        props.put("serverAddr", remoteAddress);
        
        ConfigService service = NacosFactory.createConfigService(props);
        
        // Recuperação inicial da configuração
        String currentConfig = service.getConfig(configId, groupName, 3000);
        System.out.println("Configuração Atual: " + currentConfig);

        // Registro de Listener para atualizações em tempo real
        service.addListener(configId, groupName, new Listener() {
            @Override
            public void receiveConfigInfo(String updatedInfo) {
                System.out.println("Alteração detectada: " + updatedInfo);
            }

            @Override
            public Executor getExecutor() {
                return null;
            }
        });

        System.in.read(); // Mantém o processo ativo
    }
}

1.2 Integração com Spring Boot

No ecossistema Spring Boot, o processo é simplificado através de annotations que injetam valores diretamente nas propriedades dos Beans.

Dependência:

<dependency>
    <groupId>com.alibaba.boot</groupId>
    <artifactId>nacos-config-spring-boot-starter</artifactId>
    <version>0.2.12</version>
</dependency>

Configuração (application.properties):

nacos.config.server-addr=127.0.0.1:8848
nacos.config.auto-refresh=true
nacos.config.bootstrap.enable=true
nacos.config.data-id=app-settings

Uso no Controller:

@RestController
public class SettingsController {

    @NacosValue(value = "${app.feature.enabled:false}", autoRefreshed = true)
    private boolean isFeatureEnabled;

    @GetMapping("/status")
    public String getFeatureStatus() {
        return "Feature ativa: " + isFeatureEnabled;
    }
}

1.3 Spring Cloud Nacos Config

Para ambientes Spring Cloud, utiliza-se o bootstrap.yml ou bootstrap.properties para garantir que as confiugrações sejam carregadas antes do contexto principal da aplicação.

bootstrap.properties:

spring.application.name=inventory-service
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.file-extension=properties

Para que a atualização automática funcione com @Value padrão do Spring, a classe deve ser anotada com @RefreshScope.

2. Gerenciamento de Serviços (Discovery)

A descoberta de serviços permite que microserviços se comuniquem sem conhecer IPs fixos, utilizando apenas o nome lógico do serviço.

2.1 Registro Manual via Java SDK

É possível registrar instâncias de forma manual, defniindo metadados e pesos para o balanceamento de carga.

public class ServiceRegistryApp {
    public static void main(String[] args) throws Exception {
        NamingService naming = NamingFactory.createNamingService("127.0.0.1:8848");

        // Registrando instância com metadados
        Instance instance = new Instance();
        instance.setIp("192.168.1.50");
        instance.setPort(8080);
        instance.setWeight(2.0);
        instance.addMetadata("version", "v1");

        naming.registerInstance("order-service", instance);
        
        System.out.println("Serviço registrado com sucesso.");
        System.in.read();
    }
}

2.2 Descoberta de Serviços via Spring Cloud

Com o Spring Cloud, o registro e a descoberta são automáticos. Basta adicionar a dependência de discovery.

Dependência Discovery:

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

Habilitando no Application:

@SpringBootApplication
@EnableDiscoveryClient
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
}

Consumo do Serviço com LoadBalancer:

Ao utilizar o RestTemplate, a annotation @LoadBalanced permite o uso do nome do serviço na URL em vez do IP.

@Configuration
public class ClientConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@RestController
public class ProxyController {
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/fetch-order")
    public String callOrderService() {
        // O Nacos resolve 'order-service' para um IP válido
        return restTemplate.getForObject("http://order-service/details", String.class);
    }
}