Cómo configurar Eureka Client en un microservicio Spring Cloud

En una arquitectura moderna basada en microservicios, cada componente debe poder descubrir a los demás sin que tengamos que codificar manualmente direcciones IP ni puertos. Aquí es donde entra en juego Eureka Client, una pieza clave del ecosistema Spring Cloud.

En este post vamos a tratar de explicar qué es Eureka Client, para qué sirve y cómo configurarlo paso a paso en un microservicio utilizando la anotación @EnableDiscoveryClient. A medida que avancemos, construiremos un ejemplo funcional hasta comprobar en el panel web de Eureka que el microservicio se ha registrado correctamente.

¿Qué es Eureka Client?

Eureka Client es un componente que forma parte de la solución de descubrimiento de servicios Eureka (compuesta por Eureka Server, Eureka Client y Load Balancer). Su función principal es:

Registrarse automáticamente en el servidor Eureka (Eureka Server).
Consultar otros servicios registrados para interactuar con ellos de forma dinámica.

🔃 Gracias a este mecanismo, los microservicios no necesitan saber de antemano dónde están ubicados el resto de los microservicios de la aplicación. En su lugar, Eureka les informa de qué instancias están disponibles y de cómo llegar a ellas.

¿Para qué sirve? En concreto, en una aplicación basada en la arquitectura de microservicios, el uso de Eureka Client te permite lo siguiente:

✅ Automatizar el registro y descubrimiento de servicios.
✅ Escalar instancias sin modificar configuraciones.
✅ Integrar balanceadores de carga como Ribbon o Spring Cloud LoadBalancer.
✅ Mantener la arquitectura desacoplada y resistente.

Paso a paso: configurar Eureka Client en un microservicio

A continuación, vamos a montar un microservicio Spring Boot que actúe como Eureka Client y se registre automáticamente en un Eureka Server que ya tengamos funcionando en localhost:8761.

➕ Paso 1: Crear el proyecto Spring Boot

Para crear el proyecto Spring Boot, puedes utilizar Spring Initializr y seleccionar las siguientes dependencias en dicha web:

Spring Web
Eureka Discovery Client

Si ya tienes creado el proyecto Spring Boot, entonces tendrías que proceder a añadir las siguientes dependencias en su "pom.xml":

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

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>${spring-cloud.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
 

Asegúrate de que tu proyecto usa una versión de Spring Boot compatible con Eureka (una que no sea demasiado antigua).

➕ Paso 2: Anotar la clase principal con `@EnableDiscoveryClient`

Aunque muchas versiones modernas de Spring Boot ya lo hacen automáticamente, es buena práctica usar explícitamente @EnableDiscoveryClient.

package com.ejemplo.user;

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

@SpringBootApplication
@EnableDiscoveryClient
public class UserApplication {

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

Esta anotación activa el componente DiscoveryClient de Spring Cloud, que conecta este microservicio con Eureka Server.

➕ Paso 3: Configurar fichero de propiedades

Vamos a definir el nombre del microservicio y los datos de conexión con el componente Eureka Server. Si usas application.properties, habría que incluir lo siguiente:

 
spring.application.name=users-ws
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/
eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true
 

📌 Explicación de las propiedades anteriores:

spring.application.name: nombre con el que se registrará en el servidor Eureka.
server.port: puerto local del microservicio.
defaultZone: URL del servidor Eureka.
register-with-eureka: activa el registro automático.
fetch-registry: permite consultar otras instancias registradas en Eureka. Esto resultará útil si queremos comunicarnos con otro microservicio.

⛔ En caso de tener problemas con el nombre que se registra el microservicio en Eureka, podemos configurarlo con estos parámetros:

eureka.instance.hostname → fuerza un endpoint de registro para nuestro servicio
eureka.instance.prefer-ip-address → registra el servicio con endpoint igual a la IP de nuestra máquina

 
# Forma de registro del servicio en Eureka 
#eureka.instance.hostname=localhost
eureka.instance.prefer-ip-address=true
 

Por otra parte, si queremos, podemos establecer el nombre de una instancia concreta del microservicio (cada microservicio puede tener varias instancias o réplicas) con la siguiente propiedad:

 
# Instancia del microservicio en Eureka
eureka.instance.instance-id=${spring.application.name}:${spring.application.instance_id:${random.value}}

👉 Adicionalmente, podemos enviar información de nuestro servicio al servidor Eureka en los Metadatos. Dicha información podrá ser consultada posteriormente en el panel web de Eureka. Esto se podría hacer, por ejemplo, con estos parámetros:

 
eureka.instance.metadata-map.configPath=/users-app/api
eureka.instance.metadata-map.user=admin
eureka.instance.metadata-map.password=admin
 

En otro microservicio esos metadatos podrán ser recuperados mediante la clase DiscoveryClient y haciendo uso del método “getInstance.getMetadata()”

➕ Paso 4: Crear un controlador simple para probar el microservicio

Para probar la configuración anterior, podemos crear un controlador simple y añadir un endpoint básico que devuelva un mensaje de prueba:

 
package com.ejemplo.user.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UsersController {

    @GetMapping("/saludo")
    public String saludar() {
        return "¡Hola desde el servicio-users!";
    }
}
 

Este controlador nos permitirá comprobar que el microservicio está en funcionando correctamente en el puerto previamente configurado (8081).

➕ Paso 5: Ejecutar el microservicio

Una vez que tienes configurado el proyecto y el software del microservicio, puedes arrancar la aplicación desde tu IDE o ejecutando el comando:

mvn spring-boot:run

Durante el arranque del servicio, deberías ver en la consola algo similar a lo siguiente:


DiscoveryClient_USERS-WS/localhost:users-ws: registering service...

Este log nos está indicando que el servicio se ha registrado correctamente en Eureka.

➕ Paso 6: Consultar el panel web de Eureka

Abre tu navegador y accede al panel web de Eureka en:


http://localhost:8761/

En la sección "Instances currently registered with Eureka", deberías ver:

Con detalles como:

Status: UP
Hostname / IP
Puerto: 8081
Renews: intervalo de latido de la instancia

Si has seguido correctamente los pasos anteriores, ahora tu microservicio ya debería haber quedado correctamente registrado en Eureka.

¿Qué ocurre si detienes el servicio?

Eureka implementa un sistema de heartbeat o latido. Si un servicio no renueva su estado después de un tiempo determinado (por defecto, 90 segundos), Eureka lo marcará como DOWN y lo eliminará del registro.

Esto es especialmente útil para mantener la integridad del sistema y evitar llamadas a servicios que ya no están disponibles.

Conclusión

Registrar correctamente un microservicio en Eureka es una pieza fundamental en cualquier arquitectura de microservicios Spring Cloud. Te libera de configuraciones estáticas, permite una integración más robusta y te prepara para usar herramientas más avanzadas como FeignClient, Spring Cloud Gateway o Config Server (configuración centralizada).

¡Nos vemos en el siguiente post!

Saludos.

Buscar este blog

Universo Java