实现 Eureka 服务发现

In a microservices architecture, services often need to communicate with each other. But how does one service find another?

• Dynamic IPs: Service instances can scale up/down, getting new IP addresses.
• Load Balancing: Multiple instances of a service need to be discovered.
• Manual Configuration: Hardcoding addresses is fragile and not scalable.

Service discovery solves this by providing a central registry where services register themselves.

Netflix Eureka is a powerful solution for service discovery in microservices. It's a REST-based service that is primarily used in the AWS cloud for locating services to achieve load balancing and failover of middle-tier services.

Eureka consists of two main components:

• Eureka Server: The central registry that holds information about all registered services.
• Eureka Client: A component embedded in each microservice that registers with the Eureka Server.

First, let's set up our Eureka Server. You'll need a new Spring Boot project. Add the following dependency to your pom.xml (for Maven) or build.gradle (for Gradle):

Maven:

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

This starter brings in all necessary components for running a Eureka discovery server.

Next, configure your Eureka Server in src/main/resources/application.yml. We need to tell the server NOT to register itself with Eureka, as it is the server!

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false
  instance:
    hostname: localhost

• server.port: 8761 is the default port for Eureka.
• register-with-eureka: false prevents the server from registering as a client.
• fetch-registry: false prevents the server from trying to fetch the registry.

Finally, enable the Eureka Server functionality by adding @EnableEurekaServer to your main Spring Boot application class:

Try running this example:

After running your EurekaServerApplication, you can open your web browser and navigate to http://localhost:8761.

You should see the Eureka dashboard. Initially, it will show no registered service instances. This dashboard is a great way to monitor which services are currently active and registered with your Eureka Server.

Now that our Eureka Server is running, let's register a microservice with it. This microservice will act as a Eureka Client.

When a client service starts up, it registers itself with the Eureka Server, providing its network location. Other services can then query the Eureka Server to find the client's location.

Create another Spring Boot project for your client service (e.g., a 'Hello Service'). Add the following dependency to its pom.xml or build.gradle:

Maven:

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

This dependency provides the necessary tools for your service to act as a Eureka client and register with the server.

Configure your client service in its application.yml. It needs to know where the Eureka Server is located:

server:
  port: 8081 # Or any other unique port

spring:
  application:
    name: my-hello-service # Unique service name

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka

• spring.application.name is how your service will be identified in Eureka.
• defaultZone points to your Eureka Server's URL.

To enable the client service to register with Eureka, add the @EnableDiscoveryClient annotation to its main class. We'll also add a simple REST endpoint.

Try running this example (ensure Eureka Server is running first!):

You've taken a big step into microservices by understanding and implementing Eureka Service Discovery!

• Service Discovery solves the problem of services finding each other dynamically.
• Eureka Server acts as the central registry.
• Eureka Clients (your microservices) register with the server.
• Use @EnableEurekaServer for the server.
• Use @EnableDiscoveryClient for client services.

This setup allows your microservices to communicate without hardcoding addresses, making your architecture more resilient and scalable.