En sistemas distribuidos modernos, la gestión del registro y descubrimiento de servicios, el manejo de configuraciones y el equilibrio de carga son aspectos fundamentales. La combinación de Spring Cloud y Zookeeper proporciona soluciones eficaces para estos desafíos. Este artículo explora cómo construir un sistema de coordinación distribuida utilizando estas tecnologías.

Arquitectura del Sistema

El sistema se compone principalmente de los siguientes componentes:

1. Registro y Descubrimiento de Servicios: Administrado mediante Zookeeper.
2. Gestión de Configuración: Centralizada con Spring Cloud Config.
3. Equilibrio de Carga: Implementado en el cliente con Spring Cloud LoadBalancer.

Selección de Tecnología

• Registro y Desucbrimiento de Servicios: Spring Cloud Zookeeper.
• Gestión de Configuración: Spring Cloud Config.
• Equilibrio de Carga: Spring Cloud LoadBalancer.

Implementación del Registro y Descubrimiento de Servicios

Primero, agregamos las dependencias necesarias al proyecto:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zookeeper-discovery</artifactId>
</dependency>

Configuramos la conexión a Zookeeper en application.yml:

spring:
  cloud:
    zookeeper:
      connect-string: localhost:2181
      discovery:
        root: /servicios
        register: true
        instance:
          hostname: localhost

Habilitamos el descubrimiento de servicios en la clase principal:

package com.ejemplo.servicio;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

Implementación de la Gestión de Configuración

Agregamos la dependencia para Spring Cloud Config Server:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Configuarmos el servidor en application.yml:

server:
  port: 8888

spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/tu-repositorio/configuracion

Habilitamos el servidor de configuración en la clase principal:

package com.ejemplo.config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

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

Para el cliente, configuramos:

spring:
  cloud:
    config:
      uri: http://localhost:8888
  application:
    name: servicio-ejemplo

Y habilitamos el cliente de configuración:

package com.ejemplo.cliente;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

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

Implementación del Equilibrio de Carga

Agregamos la dependencia para el equilibrador de carga:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

Configuramos el equilibrador en application.yml:

spring:
  cloud:
    loadbalancer:
      ribbon:
        enabled: false

Creamos un bean de RestTemplate con soporte para equilibrio de carga:

package com.ejemplo.carga;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

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

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

Utilizamos RestTemplate para realizar llamadas a servicios con equilibrio de carga:

package com.ejemplo.carga;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class ControladorCarga {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/invocarServicio")
    public String invocarServicio() {
        return restTemplate.getForObject("http://servicio-ejemplo/punto-final", String.class);
    }
}

Este sistema implementa registro y descubrimiento de servicios, gestión de configuración y equilibrio de carga, mejorando la disponibilidad y estabilidad del entorno distribuido.