Microservices pattern : Self-Registration

microservices-self-registration/README.md

@@ -0,0 +1,236 @@
+---
+title: "Microservices Self-Registration Pattern in Java with Spring Boot and Eureka"
+shortTitle: Microservices Pattern - Self-Registration
+description: "Dynamically register and discover Java microservices using Spring Boot and Eureka for resilient, scalable communication."
+category: Service Discovery
+language: en
+tag:
+    - Microservices
+    - Self-Registration
+    - Service Discovery
+    - Eureka
+    - Spring Boot
+    - Spring Cloud
+    - Java
+    - Dynamic Configuration
+    - Resilience 
+---
+
+## Intent of Microservices Self-Registration Pattern
+
+The intent of the Self-Registration pattern is to enable microservices to automatically announce their presence and location to a central registry (like Eureka) upon startup, simplifying service discovery and allowing other services to find and communicate with them without manual configuration or hardcoded addresses. This promotes dynamic and resilient microservices architectures.
+
+## What's in the Project
+
+This project demonstrates the Microservices Self-Registration pattern using Java, Spring Boot (version 3.4.4), and Eureka for service discovery. It consists of three main components: a Eureka Server and two simple microservices, a Greeting Service and a Context Service, which discover and communicate with each other.
+
+### Project Structure
+* **`eureka-server`:** The central service registry where microservices register themselves.
+* **`greeting-service`:** A simple microservice that provides a greeting.
+* **`context-service`:** A microservice that consumes the greeting from the Greeting Service and adds context.
+
+ The **Eureka Server** acts as the discovery service. Microservices register themselves with the Eureka Server, providing their network location.
+
+    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);
+        }
+    }
+
+ The **Greeting Service** is a simple microservice that exposes an endpoint to retrieve a greeting.
+
+    package com.example.greetingservice;
+
+    import org.springframework.boot.SpringApplication;
+    import org.springframework.boot.autoconfigure.SpringBootApplication;
+    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+
+    @SpringBootApplication
+    @EnableDiscoveryClient
+    public class GreetingServiceApplication {
+
+        public static void main(String[] args) {
+            SpringApplication.run(GreetingServiceApplication.class, args);
+        }
+    }
+
+ Greeting Controller 
+
+    package com.example.greetingservice.controller;
+
+    import org.springframework.web.bind.annotation.GetMapping;
+    import org.springframework.web.bind.annotation.RestController;
+
+    @RestController
+    public class GreetingController {
+
+        @GetMapping("/greeting")
+        public String getGreeting() {
+            return "Hello";
+        }
+    }
+
+The **Context Service** consumes the greeting from the Greeting Service using OpenFeign and adds contextual information.
+
+    package com.example.contextservice;
+
+    import org.springframework.boot.SpringApplication;
+    import org.springframework.boot.autoconfigure.SpringBootApplication;
+    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
+    import org.springframework.cloud.openfeign.EnableFeignClients;
+
+    @SpringBootApplication
+    @EnableDiscoveryClient
+    @EnableFeignClients
+    public class ContextServiceApplication {
+
+        public static void main(String[] args) {
+            SpringApplication.run(ContextServiceApplication.class, args);
+        }
+    }
+
+ Feign Client : Spring Cloud OpenFeign is a declarative HTTP client that makes it easier to consume RESTful web services in your Spring Cloud applications. Instead of writing the boilerplate code for making HTTP requests, you simply declare interface with annotations that describe the web service you want to consume.
+
+    package com.example.contextservice.client;
+
+    import org.springframework.cloud.openfeign.FeignClient;
+    import org.springframework.web.bind.annotation.GetMapping;
+
+    @FeignClient(name = "greeting-service")
+    public interface GreetingServiceClient {
+
+        @GetMapping("/greeting")
+        String getGreeting();
+    }
+
+ Context Controller
+
+    package com.example.contextservice.controller;
+
+    import com.example.contextservice.client.GreetingServiceClient;
+    import org.springframework.beans.factory.annotation.Autowired;
+    import org.springframework.beans.factory.annotation.Value;
+    import org.springframework.web.bind.annotation.GetMapping;
+    import org.springframework.web.bind.annotation.RestController;
+
+    @RestController
+    public class ContextController {
+
+        @Autowired
+        private GreetingServiceClient greetingServiceClient;
+
+        @Value("${user.region}")
+        private String userRegion;
+
+        @GetMapping("/context")
+        public String getContext() {
+            String greeting = greetingServiceClient.getGreeting();
+            return "The Greeting Service says: " + greeting + " from " + userRegion + "!";
+        }
+    }
+
+ 1. Both the Greeting Service and the Context Service register themselves with the Eureka Server upon startup using the _@EnableDiscoveryClient_ annotation.
+ 2. The Context Service, annotated with _@EnableFeignClients_, uses the GreetingServiceClient interface with _@FeignClient(name = "greeting-service")_ to declare its intent to communicate with the service named "greeting-service" in Eureka.
+ 3. When the /context endpoint of the Context Service is accessed, it calls the _getGreeting()_ method of the GreetingServiceClient.
+ 4. OpenFeign, leveraging the service discovery information from Eureka, resolves the network location of an available instance of the Greeting Service and makes an HTTP GET request to its /greeting endpoint.
+ 5. The Greeting Service responds with "Hello", and the Context Service then adds the configured user.region to the response.
+
+ This project utilizes Spring Boot Actuator, which is included as a dependency, to provide health check endpoints for each microservice. These endpoints (e.g., /actuator/health) can be used by Eureka Server to monitor the health of the registered instances.
+
+## Steps to use for this Project
+
+Prerequisites:
+ - Java Development Kit (JDK): Make sure you have a compatible JDK installed (ideally Java 17 or later, as Spring Boot 3.x requires it).
+ - Maven or Gradle: You'll need either Maven (if you chose Maven during Spring Initializr setup) or Gradle (if you chose Gradle) installed on your system.
+ - An IDE (Optional but Recommended): IntelliJ IDEA, Eclipse, or Spring Tool Suite (STS) can make it easier to work with the project.
+ - Web Browser: You'll need a web browser to access the Eureka dashboard and the microservice endpoints.
+
+Step :
+ - You'll need to build each microservice individually. Navigate to the root directory of each project in your terminal or command prompt and run the appropriate build command:
+   _cd eurekaserver
+   mvn clean install
+   cd ../greetingservice
+   mvn clean install
+   cd ../contextservice
+   mvn clean install_
+Step :
+ - Navigate to the root directory of your eurekaserver project in your terminal or command prompt
+   _mvn spring-boot:run_
+ - Wait for the Eureka Server application to start. You should see logs in the console indicating that it has started on port 8761 (as configured).
+ - Open your web browser and go to http://localhost:8761/. You should see the Eureka Server dashboard. Initially, the list of registered instances will be empty.
+Step :
+ - Run the Greeting Service
+   - Open a new terminal or command prompt.
+   - Navigate to the root directory of your greetingservice project. 
+   - Run the Spring Boot application: _mvn spring-boot:run_
+   - Wait for the Greeting Service to start. You should see logs indicating that it has registered with the Eureka Server.
+   - Go back to your Eureka Server dashboard in the browser (http://localhost:8761/). You should now see GREETINGSERVICE listed under the "Instances currently registered with Eureka". Its status should be "UP".
+Step :
+ - Run the Context Service
+   - Open a new terminal or command prompt.
+   - Navigate to the root directory of your contextservice project.
+   - Run the Spring Boot application: _mvn spring-boot:run_
+   - Wait for the Context Service to start. You should see logs indicating that it has registered with the Eureka Server.
+   - Go back to your Eureka Server dashboard in the browser (http://localhost:8761/). You should now see CONTEXTSERVICE listed under the "Instances currently registered with Eureka". Its status should be "UP".
+STEP :
+   - Test the Greeting Service Directly: Open your web browser and go to http://localhost:8081/greeting. You should see the output: Hello.
+   - Test the Context Service (which calls the Greeting Service): Open your web browser and go to http://localhost:8082/context. You should see the output: The Greeting Service says: Hello from Chennai, Tamil Nadu, India!. This confirms that the Context Service successfully discovered and called the Greeting Service through Eureka.
+
+Optional: Check Health Endpoints
+
+You can also verify the health status of each service using Spring Boot Actuator:
+ - Greeting Service Health: http://localhost:8081/actuator/health (should return {"status":"UP"})
+ - Context Service Health: http://localhost:8082/actuator/health (should return {"status":"UP"})
+ - Eureka Server Health: http://localhost:8761/actuator/health (should return {"status":"UP"})
+
+## When to use Microservices Self-Registration Pattern
+
+ - **Dynamic Environments:** When your microservices are frequently deployed, scaled up or down, or their network locations (IP addresses and ports) change often. This is common in cloud-based or containerized environments (like Docker and Kubernetes).
+ - **Large Number of Services:** As the number of microservices in your system grows, manually managing their configurations and dependencies becomes complex and error-prone. Self-registration automates this process.
+ - **Need for Automatic Service** Discovery: When services need to find and communicate with each other without hardcoding network locations. This allows for greater flexibility and reduces coupling.
+ - **Implementing Load Balancing:** Service registries like Eureka often integrate with load balancers, enabling them to automatically distribute traffic across available instances of a service that have registered themselves.
+ - **Improving System Resilience:** If a service instance fails, the registry will eventually be updated (through heartbeats or health checks), and other services can discover and communicate with the remaining healthy instances.
+ - **DevOps Automation:** This pattern aligns well with DevOps practices, allowing for more automated deployment and management of microservices.
+
+## Real-World Applications of Self-Registration pattern
+
+ - E-Commerce platforms have numerous independent services for product catalogs, order processing, payments, shipping, etc. Self-registration allows these services to dynamically discover and communicate with each other as the system scales during peak loads or as new features are deployed.
+ - Streaming services rely on many microservices for user authentication, content delivery networks (CDNs), recommendation engines, billing systems, etc. Self-registration helps these services adapt to varying user demands and infrastructure changes.
+ - Social media These platforms use microservices for managing user profiles, timelines, messaging, advertising, and more. Self-registration enables these services to scale independently and handle the massive traffic they experience.
+
+## Advantages 
+
+ - Microservices can dynamically locate and communicate with each other without needing to know their specific network addresses beforehand. This is crucial in dynamic environments where IP addresses and ports can change frequently.
+ - Reduces the need for manual configuration of service locations in each microservice. Services don't need to be updated every time another service's location changes.
+ - Scaling microservices up or down becomes easier. New instances automatically register themselves with the service registry, making them immediately discoverable by other services without manual intervention.
+ - If a service instance fails, it will eventually stop sending heartbeats to the registry and will be removed. Consumers can then discover and connect to other healthy instances, improving the system's overall resilience.
+ - Services are less tightly coupled as they don't have direct dependencies on the physical locations of other services. This makes deployments and updates more flexible.
+ - Service registries often integrate with load balancers. When a new service instance registers, the load balancer can automatically include it in the pool of available instances, distributing traffic effectively.
+ - Microservices can be deployed across different environments (development, testing, production) without significant changes to their discovery mechanism, as long as they are configured to connect to the appropriate service registry for that environment.
+
+## Trade-offs
+
+ - Introducing a service registry adds another component to your system that needs to be set up, managed, and monitored. This increases the overall complexity of the infrastructure.
+ - The service registry itself becomes a critical component. If the service registry becomes unavailable, it can disrupt communication between microservices. High availability for the service registry is therefore essential.
+ - Microservices need to communicate with the service registry for registration, sending heartbeats, and querying for other services. This can lead to increased network traffic.
+ - There might be a slight delay between when a microservice instance starts and when it becomes fully registered and discoverable in the service registry. This needs to be considered, especially during scaling events.
+ - You need to consider how your microservices will behave if they fail to register with the service registry upon startup. Robust error handling and retry mechanisms are often necessary.
+ - Microservices need to include and configure client libraries (like the Eureka Discovery Client) to interact with the service registry. This adds a dependency to your application code.
+ - In distributed service registries, ensuring consistency of the registry data across all nodes can be a challenge. Different registries might have different consistency models (e.g., eventual consistency).
+
+## References
+
+ - Microservices Patterns: https://microservices.io/
+ - Eureka Documentation: https://github.com/Netflix/eureka | https://spring.io/projects/spring-cloud-netflix 
+ - Spring Boot Documentation: https://spring.io/projects/spring-boot
+ - Spring Cloud OpenFeignDocumentation: https://spring.io/projects/spring-cloud-openfeign
+ - Spring Boot Actuator Documentation: https://www.baeldung.com/spring-boot-actuators

microservices-self-registration/contextservice/.gitattributes

@@ -0,0 +1,2 @@
+/mvnw text eol=lf
+*.cmd text eol=crlf

microservices-self-registration/contextservice/.gitignore

@@ -0,0 +1,33 @@
+HELP.md
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/

microservices-self-registration/contextservice/.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+wrapperVersion=3.3.2
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.9/apache-maven-3.9.9-bin.zip