Preparação do Projeto

Primeiro, criamos um módulo pai no qual removemos a pasta src, mantendo apenas os arquivos .idea e pom.xml.

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.3.RELEASE</version>
</parent>

<!-- Controle de versão global -->
<properties>
    <springCloud.version>Hoxton.SR7</springCloud.version>
    <springCloud-alibaba.version>2.1.1.RELEASE</springCloud-alibaba.version>
</properties>

<dependencyManagement>
    <dependencies>
        <!-- Controle de versão do Spring Cloud -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${springCloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- Dependência do repositório da Alibaba -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>${springCloud-alibaba.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

Criação dos Módulos de Serviço

Criamos dois módulos: um consumidor (consumer) e um provedor (provider).

Configuração do Módulo Consumidor

Adicionamos as seguintes dependências no módulo consumer:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!-- Descoberta de serviços com Nacos -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

Classe de Inicialização do Consumidor

@SpringBootApplication
@Slf4j
@EnableDiscoveryClient
public class ClienteConsumidor {

    public static void main(String[] args) throws UnknownHostException {
        ConfigurableApplicationContext aplicacao = SpringApplication.run(ClienteConsumidor.class, args);
        Environment ambiente = aplicacao.getEnvironment();
        String ip = InetAddress.getLocalHost().getHostAddress();
        String porta = ambiente.getProperty("server.port");
        String caminho = ambiente.getProperty("server.servlet.context-path");
        String perfil = ambiente.getProperty("spring.profiles.active");
        log.info("\n----------------------------------------------------------\n\t" +
                "Aplicacao microservicos rodando! URLs de acesso:\n\t" +
                "Local: \t\thttp://localhost:" + porta + caminho + "/\n\t" +
                "Ambiente atual: \t\t" + perfil + "\n\t" +
                "----------------------------------------------------------");
    }

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

Configuração do Arquivo YML do Consumidor

server:
  port: 5000
  servlet:
    context-path: /cloud-cliente
spring:
  application:
    name: consumer-servico
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.43.204:80
        register-enabled: true

Configuração do Módulo Provedor

Para o módulo providre, criamos uma classe de inicialização similar:

@SpringBootApplication
@Slf4j
@EnableDiscoveryClient
public class ServicoProvedor {

    public static void main(String[] args) throws UnknownHostException {
        ConfigurableApplicationContext aplicacao = SpringApplication.run(ServicoProvedor.class, args);
        Environment ambiente = aplicacao.getEnvironment();
        String ip = InetAddress.getLocalHost().getHostAddress();
        String porta = ambiente.getProperty("server.port");
        String caminho = ambiente.getProperty("server.servlet.context-path");
        String perfil = ambiente.getProperty("spring.profiles.active");
        log.info("\n----------------------------------------------------------\n\t" +
                "Aplicacao microservicos rodando! URLs de acesso:\n\t" +
                "Local: \t\thttp://localhost:" + porta + caminho + "/\n\t" +
                "Ambiente atual: \t\t" + perfil + "\n\t" +
                "----------------------------------------------------------");
    }

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

Configuração do Arquivo YML do Provedor

server:
  port: 7000
  servlet:
    context-path: /cloud-servico
spring:
  application:
    name: provider-estoque
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8085

Teste da Descoberta de Serviços

Ao iniciar ambos os serviços (consumer e provider), podemos verificar no console do Nacos que ambos os serviços foram registrados com sucesso.

Em seguida, podemos configurar o serviço consumer para chamar o serviço provider através da descoberta de serviços:

@RestController
public class ControladorConsumidor {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/buscar-produto/{id}")
    public String buscarProduto(@PathVariable String id) {
        // Utiliza o nome do serviço para invocar o provedor
        String url = "http://provider-estoque/produtos/" + id;
        return restTemplate.getForObject(url, String.class);
    }
}

Com essa configuração, o serviço consumer consegue localizar e invocar o serviço provider automaticamente através do registro no Nacos.