Microservice architecture using Eureka

Category : Microservices | Sub Category : Microservices | By Prasad Bonam Last updated: 2023-11-12 08:01:18 Viewed : 562

Microservice architecture using Eureka:

the components and concepts involved in a microservice architecture using Eureka.

1. Microservices:

• Definition: Microservices is an architectural style where an application is composed of small, independent services that communicate with each other through well-defined APIs.
• Benefits: Improved scalability, easier maintenance, independent deployments, and resilience.

2. Service Registry and Discovery:

• Definition: In a microservices architecture, services need to find and communicate with each other. Service registry and discovery help manage this process dynamically.
• Service Registry: A central component where microservices can register themselves, providing information about their location and capabilities.
• Service Discovery: A mechanism for services to locate and communicate with each other without hardcoding the network locations.

3. Eureka:

• Definition: Eureka is a service registry and discovery server developed by Netflix. It is part of the Netflix OSS (Open Source Software) suite.
• Role in Microservices: Eureka allows microservices to register themselves and discover other services in the system.

4. Eureka Server:

• Definition: The Eureka Server is the central component that holds information about all the microservices instances in a system.
• Functionality:
  • Service Registry: Microservices register themselves with the Eureka server upon startup.
  • Service Discovery: Microservices query the Eureka server to discover the network location (IP address and port) of other microservices.

5. Eureka Client:

• Definition: In the context of microservices using Eureka, a client is a microservice that registers itself with the Eureka server and queries the server to discover other services.
• Integration: Eureka clients are typically integrated with the microservice application using libraries or annotations provided by the Spring Cloud framework.

6. Spring Cloud and Eureka:

• Definition: Spring Cloud is a set of tools and libraries built on top of the Spring Framework to simplify the development of distributed systems.
• Eureka Integration: Spring Cloud integrates with Eureka to provide a seamless way to build microservices that can register and discover each other using Eureka.

7. Example Workflow:

• Registration: A microservice (Eureka client) registers itself with the Eureka server upon startup. The registration includes information like service name, network location, and health status.
• Discovery: Other microservices can query the Eureka server to discover the location of a specific service. This allows for dynamic and runtime discovery of services in the system.

8. Use Cases:

• Load Balancing: Eureka can be used in conjunction with load balancing to distribute incoming requests among multiple instances of a service.
• Resilience: If a service instance fails, Eureka can handle the removal of that instance from the registry, preventing traffic from being sent to a non-responsive service.

In summary, Eureka simplifies the complexities of service registration and discovery in a microservices architecture, allowing for a more dynamic and scalable system. It plays a crucial role in enabling the benefits of microservices, such as independent service deployment and improved resilience.

To create a simple microservice using Eureka and Spring Boot, you will need two projects: one for the Eureka Server and another for a microservice that registers itself with the Eureka Server. Below are step-by-step instructions for creating such an example:

1. Eureka Server:

Create a new Spring Boot project for the Eureka Server.

EurekaServerApplication.java

javaCopy code
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);
    }
}

application.properties

propertiesCopy code
server.port=8761
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

2. Microservice:

Create another Spring Boot project for your microservice.

MicroserviceApplication.java

javaCopy code
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

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

application.properties

propertiesCopy code
server.port=8080
spring.application.name=microservice
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

3. Run the Applications:

1. Start the Eureka Server application (EurekaServerApplication).
2. Start the Microservice application (MicroserviceApplication). This microservice will register itself with the Eureka Server.

4. Verify:

• Access the Eureka Server console at http://localhost:8761 to see the registered services.
• Your microservice should be listed in the Eureka dashboard.

Now you have a basic setup with Eureka and a microservice. In a real-world scenario, you would have more microservices, and they would communicate with each other using the service names registered in Eureka.

Note: This example uses the default configurations. In a production environment, you may want to customize configurations according to your requirements. Additionally, consider securing your Eureka Server and microservices with appropriate security configurations