Spring Cloud Discovery – Eureka vs Consul

Dlaczego service discovery jest ważne?

W architekturze mikrousług aplikacje składają się z wielu niezależnych serwisów. Każdy serwis może działać na różnych maszynach, portach i może być skalowany poziomo. **Service discovery** rozwiązuje fundamentalny problem: jak serwisy mogą się nawzajem znajdować i komunikować?

Bez service discovery musielibyśmy hardkodować adresy IP i porty w konfiguracji, co jest niemożliwe w dynamicznych środowiskach cloud. To jak próba znalezienia konkretnej osoby w mieście bez książki telefonicznej.

Netflix Eureka – sprawdzony weteran

**Eureka** to service discovery opracowany przez Netflix, który stał się de facto standardem w ekosystemie Spring Cloud. Składa się z dwóch głównych komponentów:

### Konfiguracja Eureka Server

    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-server

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

# application.yml
server:
  port: 8761

eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

### Eureka Client – rejestracja serwisu

    org.springframework.cloud
    spring-cloud-starter-netflix-eureka-client

# application.yml
spring:
  application:
    name: user-service

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
  instance:
    preferIpAddress: true

HashiCorp Consul – wszechstronny kombajn

**Consul** to kompleksowe rozwiązanie od HashiCorp, które oferuje nie tylko service discovery, ale także distributed configuration, health monitoring i service mesh. Jest to bardziej zaawansowane narzędzie niż Eureka.

### Uruchomienie Consul

# Pobranie i uruchomienie Consul
wget https://releases.hashicorp.com/consul/1.6.2/consul_1.6.2_linux_amd64.zip
unzip consul_1.6.2_linux_amd64.zip
./consul agent -dev -ui -client=0.0.0.0

Lub przez Docker:

docker run -d --name=consul -p 8500:8500 consul:1.6.2 agent -server -ui -bootstrap-expect=1 -client=0.0.0.0

### Spring Cloud Consul – konfiguracja

    org.springframework.cloud
    spring-cloud-starter-consul-discovery

# application.yml
spring:
  application:
    name: order-service
  cloud:
    consul:
      host: localhost
      port: 8500
      discovery:
        enabled: true
        health-check-path: /actuator/health
        health-check-interval: 15s

Porównanie praktyczne – co wybrać?

### Komunikacja między serwisami

Oba rozwiązania umożliwiają komunikację przez nazwy serwisów zamiast hardkodowanych adresów:

@RestController
public class OrderController {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @GetMapping("/orders/{orderId}/user")
    public User getUserForOrder(@PathVariable String orderId) {
        // Zamiast http://192.168.1.10:8080/users/123
        // używamy nazwy serwisu zarejestrowanego w discovery
        return restTemplate.getForObject(
            "http://user-service/users/" + getUserId(orderId), 
            User.class
        );
    }
}

@Configuration
public class RestConfig {
    
    @Bean
    @LoadBalanced // Automatyczny load balancing!
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Kiedy wybrać Eureka?

**Wybierz Eureka gdy:**
– Masz proste potrzeby service discovery
– Pracujesz głównie w ekosystemie Spring/Netflix
– Chcesz szybko zacząć bez dodatkowej infrastruktury
– Używasz AWS (Eureka ma świetną integrację z ELB)
– Zespół ma ograniczone doświadczenie z devops

### Przykład production-ready setup dla Eureka

# Eureka Server - application-prod.yml
eureka:
  server:
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 15000
  client:
    register-with-eureka: false
    fetch-registry: false
    serviceUrl:
      defaultZone: http://eureka1:8761/eureka/,http://eureka2:8761/eureka/

Kiedy wybrać Consul?

**Wybierz Consul gdy:**
– Potrzebujesz zaawansowanych health checks
– Chcesz mieć distributed configuration w jednym miejscu
– Planujesz service mesh w przyszłości
– Masz multi-datacenter setup
– Używasz też innych technologii niż Java/Spring

### Zaawansowane możliwości Consul

# application.yml z Consul configuration
spring:
  cloud:
    consul:
      config:
        enabled: true
        format: YAML
        data-key: config
      discovery:
        health-check-critical-timeout: 3m
        health-check-interval: 30s
        tags:
          - version=1.0
          - environment=production

Testowanie service discovery

@SpringBootTest
@TestPropertySource(properties = {
    "eureka.client.enabled=false",
    "spring.cloud.discovery.enabled=false"
})
public class OrderServiceTest {
    
    @MockBean
    private DiscoveryClient discoveryClient;
    
    @Test
    public void shouldFindUserService() {
        // Given
        ServiceInstance userService = mock(ServiceInstance.class);
        when(userService.getUri()).thenReturn(URI.create("http://localhost:8080"));
        when(discoveryClient.getInstances("user-service"))
            .thenReturn(Arrays.asList(userService));
        
        // When & Then
        List instances = discoveryClient.getInstances("user-service");
        assertThat(instances).hasSize(1);
    }
}

Przydatne zasoby:

• Spring Cloud Netflix dokumentacja
• Consul Connect service mesh
• Netflix Eureka Wiki
• Spring Guide – Service Registration

Który system service discovery wybierasz dla swojego następnego projektu? Podziel się swoimi doświadczeniami w komentarzach – zwłaszcza jeśli miałeś okazję używać obu rozwiązań w production!