EUREKA - RIBBON - Client Load Balancing (I)

Comenzamos aquí una serie de cuatro entradas.

En la primera trataremos la creación de un servidor de registro EUREKA.

La segunda la reservamos para RIBBON. En ella veremos dos microservicios:

• El primero con tres replicas en ejecución, mediante tres puertos diferentes.
• El segundo usará RIBBON para invocar al primero mediante balanceo desde cliente. Lo haremos de dos formas:
• Mediante EUREKA (con conocimiento del nombre del primer microservicio)
• Sin EUREKA (invocando en lugar del nombre a "localhost")

En la tercera desplegaremos estos elementos en un entorno docker.

En la cuarta lo haremos sobre un entorno kubernetes.

Estas entradas surgen al explorar la solución de Spring para el load balancing en cliente. Nos ha parecido interesante exponer ambas apis de forma conjunta para verlas en acción.

Hubiésemos preferido hacerlo todo en una sola entrada, pero sería demasiado largo, así que vayamos con EUREKA.

Como siempre, os podéis descargar el código del siguiente enlace gitlab.

Qué es EUREKA

Antes de nada, qué es eureka. Es un servicio de registro. Es decir, es un "lugar" donde podemos registrar nuestro microservicios con un nombre, de forma que cuando otro microservicio quiera acceder a uno ya registrado pueda hacerlo por el nombre, y no por dominio, puerto, etc...

Nos abstrae de los detalles de la infraestructura. Sólo necesitamos conocer su nombre para acceder. En un entorno cloud, ni siquiera necesitaremos saber el puerto. En nuestro caso, para la prueba de concepto, fuera de cloud, si que necesitaremos este último dato.

pom.xml

Para no hacerlo demasiado extenso anexo sólo la configuración específica (en gitlab está todo el detalle):

    <dependencies>
        <dependency>
           <groupId>org.springframework.cloud</groupId>
           <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
    </dependencies>

application.yml

Pondremos la siguiente información relevante:

    server:
      port: 8761
  
    eureka:
      client:
        register-with-eureka: false
        fetch-registry: false

Asignamos el puerto 8761, el habitual para este servicio.

En entornos reales, habitualmente dispondremos de un cluster eureka, sin embargo para esta prueba no es necesario. Por ello, hemos deshabilitado las dos propiedades que están a false. En un entorno real estarían a true, indicando que un nodo se registraría en los otros nodos, y que cada uno de ellos obtendría una copia del registro de los otros nodos. De esa forma aunque un cliente se registrase en un sólo nodo eureka, el resto tendría el registro completo.

java

En la clase main añadimos la anotación "@EnableEurekaServer" en la cabecera.
Con esto nos es suficiente.

Prueba

Como veis parece bastante sencillo. 

Levantemos nuestro servidor de registro como cualquier aplicación springboot, ya sea desde eclipse o desde línea de comandos. En este último caso hay dos opciones*:

1. java -jar nuestro_jar.jar (desde el directorio donde tengamos el jar de la aplicación)
2. mvn spring-boot:run (desde el directorio donde esté el pom.xml de la aplicación). 

Como podemos ver, no hay ningún servicio registrado, eso lo haremos en la siguiente entrada, en la que registraremos los dos microservicios comentados al principio.

En esa segunda entrada veremos como se puede invocar desde el microservicio dos al uno vía RIBBON, utilizando el nombre de registro de dicho microservicio uno en EUREKA.

(*) Recordad que se requiere Java 8, si tenéis el JAVA_HOME apuntando a una versión anterior, deberéis setear dicha variable a la carpeta base del jdk 8 que tengáis en vuestro pc (set JAVA_HOME=C:\XXXXXXX).

Más info

La web oficial de Spring es un muy buen punto de entrada. Ahí siempre dispondremos de ejemplos con las últimas versiones de Spring.

Otra web interesante, aunque a veces contiene ejemplos con versiones anteriores es baeldung.com.

Recordamos el enlace al código de nuestro gitlab.
Asimismo, enlace a la segunda entrada.