Eureka Server

Crear Eureka Server

La implementación de un Eureka Server requiere configurar una aplicación Spring Boot específica que actúe como registro central de servicios. Este servidor será el punto de encuentro donde todos los microservicios se registrarán y desde donde podrán descubrir otros servicios de la arquitectura.

Configuración del proyecto

Para crear un Eureka Server necesitamos configurar las dependencias correctas en nuestro proyecto. 

Recordemos que ya tenemos un Config Server, y para conectarse a él nuestras aplicaciones de microservicios deben ser Config Clients, por tanto este eureka server también será un Config Client:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>3.5.6</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.example</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>demo</name>
	<description>Demo project for Spring Boot</description>
	<url/>
	<licenses>
		<license/>
	</licenses>
	<developers>
		<developer/>
	</developers>
	<scm>
		<connection/>
		<developerConnection/>
		<tag/>
		<url/>
	</scm>
	<properties>
		<java.version>17</java.version>
		<spring-cloud.version>2025.0.0</spring-cloud.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
	<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>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

El starter spring-cloud-starter-netflix-eureka-server incluye todas las dependencias necesarias para levantar un servidor Eureka, incluyendo la interfaz web administrativa y las APIs REST para el registro y descubrimiento de servicios.

Habilitación del servidor

La clase principal de nuestra aplicación debe incluir la anotación @EnableEurekaServer para activar la funcionalidad de servidor Eureka:

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

La anotación @EnableEurekaServer configura automáticamente todos los componentes internos necesarios para que la aplicación funcione como servidor de registro. No requiere configuración adicional en el código Java.

Ejemplo:

Configuración básica

El archivo application.yml debe contener la configuración mínima para que el Eureka Server funcione correctamente en un entorno de desarrollo:

spring:
  application:
    name: eureka-server

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    enable-self-preservation: false

logging:
  level:
    com.netflix.eureka: OFF
    com.netflix.discovery: OFF

La configuración incluye varios parámetros críticos:

• register-with-eureka: false: Evita que el servidor se registre a sí mismo como cliente
• fetch-registry: false: Impide que el servidor intente obtener información de registro de otros servidores
• enable-self-preservation: false: Desactiva el modo de auto-preservación para desarrollo local
• port: 8761: Puerto estándar para servidores Eureka

Ejemplo mínimo conectando al Config Server:

Estructura del proyecto

El proyecto resultante tendrá una estructura simple:

eureka-server/
├── src/
│   └── main/
│       ├── java/
│       │   └── com/example/eurekaserver/
│       │       └── EurekaServerApplication.java
│       └── resources/
│           └── application.yml
├── pom.xml
└── README.md

Esta estructura minimalista es suficiente para ejecutar un servidor Eureka completamente funcional. No necesitamos configuraciones adicionales, controladores REST personalizados ni componentes complejos.

Ejecución del servidor

Para arrancar el servidor ejecutamos el comando estándar de Spring Boot:

./mvnw spring-boot:run

Una vez iniciado, el servidor estará disponible en http://localhost:8761. La aplicación arrancará mostrando logs similares a:

Started EurekaServerApplication in 3.847 seconds
Eureka server started at port 8761

El servidor incluye una interfaz web administrativa accesible desde el navegador que permite visualizar todos los servicios registrados, sus instancias activas y el estado general del registro. Esta interfaz será fundamental para monitorear qué servicios están disponibles en nuestro ecosistema de microservicios.

Registro simple de instancias (dashboard)

Una vez que tenemos nuestro Eureka Server funcionando, el siguiente paso es comprobar su interfaz web y registrar servicios simples para observar cómo aparecen en el dashboard. El dashboard de Eureka proporciona una vista completa del estado de todos los servicios registrados en tiempo real.

Acceso al dashboard

El dashboard de Eureka está disponible automáticamente en **http://localhost:8761** cuando accedemos desde un navegador web. La interfaz muestra información esencial del servidor:

• System Status: Estado general del servidor Eureka
• DS Replicas: Información sobre réplicas del servidor (vacío en configuración standalone)
• Instances currently registered with Eureka: Lista de servicios registrados
• General Info: Información del entorno y configuración
• Instance Info: Detalles específicos del servidor

Inicialmente, la sección "Instances currently registered with Eureka" aparecerá vacía con el mensaje "No instances available", lo cual es normal ya que aún no hemos registrado ningún servicio.

Creación de un cliente simple

Para visualizar cómo funciona el registro de servicios, crearemos un microservicio básico que se registre automáticamente en Eureka. Necesitamos crear un nuevo proyecto Spring Boot con las siguientes dependencias:

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

La dependencia **spring-cloud-starter-netflix-eureka-client** habilita automáticamente el registro con Eureka sin necesidad de anotaciones adicionales en versiones modernas de Spring Cloud.

Configuración del cliente

El archivo application.yml del cliente debe incluir la configuración básica para conectarse al servidor Eureka:

spring:
  application:
    name: simple-service

server:
  port: 8080

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

La propiedad **spring.application.name** es crucial porque define el nombre del servicio que aparecerá en el dashboard. El defaultZone especifica la ubicación del servidor Eureka donde el cliente debe registrarse.

Implementación básica

La clase principal del cliente es muy simple:

package com.example.simpleclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SimpleClientApplication {

    @GetMapping("/hello")
    public String hello() {
        return "Hello from Simple Service!";
    }

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

No necesitamos la anotación @EnableEurekaClient ya que el registro se activa automáticamente al incluir la dependencia del cliente Eureka.

Observación en el dashboard

Cuando ejecutamos el cliente con ./mvnw spring-boot:run, después de unos segundos veremos en el dashboard de Eureka:

• SIMPLE-SERVICE aparecerá en la lista de aplicaciones
• Se mostrará 1 instance registrada
• El estado aparecerá como UP
• Se incluirán detalles como la IP, puerto y health check URL

La información mostrada incluye:

• Application: Nombre del servicio (SIMPLE-SERVICE)
• AMIs: Número de instancias activas
• Availability Zones: Zonas donde está disponible el servicio
• Status: Estado actual de cada instancia

Verificación del funcionamiento

Podemos comprobar que el servicio está correctamente registrado accediendo directamente a su endpoint:

curl http://localhost:8080/hello

La respuesta "Hello from Simple Service!" confirma que el servicio funciona correctamente y está disponible a través de la dirección registrada en Eureka.

Múltiples instancias

Para observar el comportamiento con múltiples instancias, podemos arrancar el mismo servicio en diferentes puertos:

java -jar target/simple-client-0.0.1-SNAPSHOT.jar --server.port=8081

El dashboard mostrará automáticamente las dos instancias del mismo servicio, cada una con su puerto correspondiente, demostrando cómo Eureka mantiene un registro actualizado de todas las instancias disponibles.