microservice-sample

This is a proof-of-concept application, which demonstrates Microservice Architecture Pattern using Spring Boot, Spring Cloud, Spring Config.

---

## Functional services

Decomposed into two core microservices. All of them are independently deployable applications, organized around certain business capability.

Login service

Method: POST
Path : /authenticate
Description: Validate userid password.
Curl Command: curl -H "Content-Type: application/json" -X POST -d '{"loginId":"xyz","password":"xyz"}' http://localhost:1112/loginservice/authenticate

Note: Business logic is hard coded, If userid/password are sample its authenticated.

---

Edge Server

This is entry point to outside world.

In theory, a client could make requests to each of the microservices directly. But obviously, there are challenges and limitations with this option, like necessity to know all endpoints addresses, perform http request for each peace of information separately, merge the result on a client side. Another problem is non web-friendly protocols, which might be used on the backend.

It can be used for authentication, insights, stress and canary testing, service migration, static response handling, active traffic management.

With Spring Cloud we can enable it with one @EnableZuulProxy annotation

@EnableZuulProxy public class Config { }

Route requests to appropriate microservices, defined in application.properties

zuul.prefix=/api
zuul.ignoredServices='*'
zuul.routes.auth-service.path=/auth-service/**
zuul.routes.auth-service.serviceId=AUTH-SERVICE
zuul.ribbon.restclient.enabled=true
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=60000

Note: Detail code for edge server can be found in edge-server project

---

Service Discovery

The key part of Service discovery is Registry. I use Netflix Eureka in this project. Eureka is a good example of the client-side discovery pattern, when client is responsible for determining locations of available service instances (using Registry server) and load balancing requests across them.

With Spring Boot, you can easily build Eureka Registry with spring-cloud-starter-eureka-server dependency, @EnableEurekaServer annotation and simple configuration properties.

@EnableEurekaServer @SpringBootApplication public class EurekaServerApplication {

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

}

Every service will get register to Eureka server on its starup and provide all required info like URL, Host etc.

application.properties for eureka server.

spring.application.name=eureka-service
server.port=1111
eureka.instance.client.register-with-eureka=false
eureka.instance.client.fetch-registry=false
logging.level.com.netflix.eureka=OFF
logging.level.com.netflix.discover=OFF

Note: Detail code for eureka server can be found in eureka-server project

---

##Load balancer, Circuit breaker and Http client

####Ribbon

Ribbon is a client side load balancer which gives you a lot of control over the behaviour of HTTP and TCP clients. Compared to a traditional load balancer, there is no need in additional hop for every over-the-wire invocation - you can contact desired service directly.

Out of the box, it natively integrates with Spring Cloud and Service Discovery. Eureka Client provides a dynamic list of available servers so Ribbon could balance between them.

####Hystrix

Hystrix is the implementation of Circuit Breaker pattern, which gives a control over latency and failure from dependencies accessed over the network. The main idea is to stop cascading failures in a distributed environment with a large number of microservices. That helps to fail fast and recover as soon as possible - important aspects of fault-tolerant systems that self-heal.

Besides circuit breaker control, with Hystrix you can add a fallback method that will be called to obtain a default value in case the main command fails.

####Feign

Feign is a declarative Http client, which seamlessly integrates with Ribbon and Hystrix. Actually, with one spring-cloud-starter-feign dependency and @EnableFeignClients annotation you have a full set of Load balancer, Circuit breaker and Http client with sensible ready-to-go default configuration.

public interface LoginService {
@RequestMapping(value="/authenticate", method=RequestMethod.POST, produces="application/json")
public MessageWrapper authenticate(@RequestBody Object loginBean);
}

@FeignClient(value="login-service", fallback=LoginServiceFallBack.class)
public interface LoginServiceClient extends LoginService
{
}

NOTE: PLEASE LOOK INTO AUTH-CLIENT PROJECT FOR FEIGN

---

Notes

Once you download code and its setup in standard ID starts the application in following sequence.

1 - Eureka Server - You might get error at console saying replica server is not configure, we can ignore for development purpose.
2 - Login Service
3 - Auth Client
4 - Edge Server

Use following curl command to test

curl -H "Content-Type: application/json" -X POST -d '{"loginId":"xyz","password":"xyssssz"}' http://localhost:1114/api/auth-service/login/authenticate

curl -H "Content-Type: application/json" -X POST -d '{"loginId":"xyz","password":"xyz"}' http://localhost:1114/api/auth-service/login/authenticate

If you want to check FALLBACK mechanism, stop login/token service and execute above commands again.

Once fallback scenario is tested start the login/token service and execute above commands. Wait for 1 Minute once server are started as hystrix default isolation for thread is set to 1min.

---