microservices discovery using Eureka server

microservices architecture java: Eureka Server

In the previous microservices articles, we learn how to configure and access Config Server this tutorial we learn what is Spring Cloud Eureka server ?

Why  microservices service registry is needed?

microservices communication : Eureka server/client communication?

How to configure Eureka server using Spring Cloud?

What is Eureka Server?

Eureka server is nothing but a service discovery pattern implementation, where every Microservice is registered and client Microservice looks up Eureka server to get a dependent Microservice to get the job done.

Eureka Server is a Netflix OSS  product and Spring cloud offers the declarative way to register and invoke service by Java annotation.

Why Eureka server/service registry is needed in microservices?

To understand why Eureka server needed in microservices architecture, lets start from simple

Understanding How one service calls another service REST endpoint for communication.

Say we need to call Employee payroll service to get payroll information for an Employee. The payroll service  which is deployed on localhost 8080 port and by passing employee primary key we got that information so we just call following

http://localhost:8080/payroll/1 or

http://127.0.0.1/payroll/1

Where localhost/127.0.0.1  is hostname/IP address and payroll is payroll service context, 1 is the Employee primary key.

But this is only possible when beforehand you know the hostname/IP addresses then you can configure your URL. So here Hostname or IP address is a constraint or a pain point.

If IP address of a  server/container is fixed then you can use that approach but

what happens when your IP addresses and hostname are unpredictable?

Nowadays on a Cloud platform, it is obvious that all the servers or containers use dynamic IPs for autoscaling. And the interesting thing is that in  Microservice architecture the key principle is your service can autoscaled as per load so Cloud platforms are ideal for Microservices.

What I try to say here is we can not predict the IP addresses of container/server beforehand so putting dependent services IP addresses in the config file is not a solution we need a more sophisticated technique to identify service, and Eureka server stepped in here.

Eureka server/client communication:

Every Microservice register itself in Eureka server when bootstrapped. Generally using the {ServiceId} it register into Eureka server or it can use hostname or any public IP(If those are Fixed). After registering, every 30 seconds it pings Eureka server to notify that the service itself is available. If Eureka server not getting any ping from a service for a quite long time this service is unregistered from Eureka server automatically and Eureka Server notifies the new state of the registry to all other services. I will write this mechanism elaborately in next Article.

Now one question may pop up our mind is then What is Eureka server itself?

Eureka server is nothing but an another Microservice which treats itself as a Eureka client.

What I mean by that is Eureka server has to be highly available as every service communicate it to discover other services. So it is recommended that it should not be a single point of failure.To overcome it we need multiple Eureka server instance runs behind a load balancer. Now when there are multiple Eureka servers so each server needs to have synchronized registry details so that every server knows about the current state of every Microservices register in Eureka server registry.

Eureka server communicates its peer server as a client and clone the updated state of registry so Eureka server acts itself as Client we can perform this by just configuring

eureka.client.serviceUrl.defaultZone property.

Eureka server works in  two modes.

Standalone : In local, we configure stand-alone mode where we have only one Eureka server i.e  localhost and same cloning property from itself.

Clustered : where we have multiple Eureka server each cloning it states from its peer.

Eureka server can have properties file and communicate with config server as other Microservices do.

Diagram of Eureka server Communication:

Here I will show you a standalone setup of Eureka server.

Step 1: Create a project template from https://start.spring.io/ while creating the template choose the following modules

1. Config Client.
2. Actuator
3. Eureka Server

Step 2:  open the downloaded code template and import it as Maven project in your IDE. The pom.xml looks like

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>

    <artifactId>EmployeeEurekaServer</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>EmployeeEurekaServer</name>

    <description>Demo project for Spring Boot</description>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.4.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <java.version>1.8</java.version>

        <spring-cloud.version>Dalston.SR1</spring-cloud.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-actuator</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-config</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-eureka-server</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>${spring-cloud.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

Step 3: Now open the EmployeeEurekaServerApplication.java and put the annotation  @EnableEurekaServer on top of the class. By doing so this application now acts as Service Registry all other Microservices can register themselves by using this service URL we will discuss it in next article.

package com.example.EmployeeEurekaServer;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@EnableEurekaServer

@SpringBootApplication

public class EmployeeEurekaServerApplication {

    public static void main(String[] args) {

        SpringApplication.run(EmployeeEurekaServerApplication.class, args);

    }

}

Step 4:Now change the application.properties to bootstrap.properties as it may consult with config server if it has any properties defined in config server. In bootstrap.properties file write the following lines

spring.application.name=EmployeeEurekaServer

eureka.client.serviceUrl.defaultZone:http://localhost:9091/eureka/

server.port=9091

eureka.client.register-with-eureka=false

eureka.client.fetch-registry=false

Name	Description
spring.application.name	Unique name for Eureka server service
eureka.client.serviceUrl.defaultZone	It consult with other Eureka server for sync the service registry as it is standalone mode I give the local server address.
server.port	In which port server will be bound.
eureka.client.register-with-eureka	This determines is this server register itself as client as I said earlier Eureka server is also act as client so that it  can sync the registry.The value false means prevent itself act as a client.
eureka.client.fetch-registry	Not register itself in service registry

Now our Eureka server setup is completed. We will now run this project as java application . Now hit the following url

http://localhost:9091 you will see the following dashboard

Read more

java microservices tutorial:spring cloud config server

microservices architecture java: Config Server 

In microservices we create a central spring cloud config server  where all configurable parameters of micro-services are written and it is version controlled, benefit of central config server is if we change a property for a microservice it can reflect on the fly without redeploying the Microservice.

Before Microservices era we create a properties files where we maintain our configurable parameter so if we change the parameter value or add or delete a parameter we generally need to restart the application container moreover think about the environments often we have development, Staging and Prod environment and each has separate Url for different services like JMS, JNDI etc. so also if environment changes we need to pick right properties file like for development we need to load development property file. Spring provides the Profile concept where based on the passing profile Spring load appropriate environments property.

Like if profile value is dev it loads all {}-dev.properties.

But the main problem is , it is tied to the codebase or statically packaged so any changes in properties file need to build and redeployed the application which is violation of Microservice principle  where it clearly stated

build just once and deploy it any environment.

So somehow we need a technology which maintains all properties and if any properties are changed it will pick up the changes and reflect the same without application rebuild or restart.

The answer is Spring Cloud config server.

Spring Cloud config server Architecture

Few important components of config server .

Repository area : Config server stores all Microservices property files in a Version control system so it can be version controlled and this version control system can be git or svn, but most popular are GIT.Also, you can store it in filesystem then your profile should be native.Config server stores each micro-service properties based on the Service ID. we can configure Microservice Service Id by giving a unique value of spring.application.name property in bootstrap.properties file for that Microservice.

Say I have an Employee Payroll Microservice then I can create a ServiceID like following

In Employee Payroll bootstrap.property file.

spring.application.name=EmployeePayroll.

Now in Config server, we have a set of property files for Employee payroll based on environment

like

EmployeePayroll-dev.properties

EmployeePayroll-stg.properties

EmployeePayroll-prod.properties

Based on profile value.

Note that properties file name should be in the following format.

{ServiceID}-{profile}.properties.

If we do not give the profile name in property file then it is considered as default

Here EmployeePayroll-dev is Service ID and dev/stg/prod are environments.

REST Endpoint : Now every microservices need to communicate with Config server so it can resolve the property value, as all property is stored in Config server. Config server publishes rest endpoint through that microservices communicate with them or we can see the properties in the browser.

Actuator :  If any properties for a microservice has been changed that has been refreshed through Actuator refresh rest endpoint. By doing this Microservice got updated property without rebuild the application.

Cloud Bus : This is optional but very useful. think if we need to refresh actuator endpoint manually for each service then it will be a hectic task as a complex business domain has many microservices. In this scenario, cloud bus helps to push the updated properties to all its subscribed Microservices but for trigger this action we need to manually refresh one Microservice endpoint.

I will talk letter about cloud bus.

Load Balancer :  As all the configurable properties are stored in Config server so it is necessary to up before all Microservices started as all Microservices instance querying the config server to resolve it properties when bootstrapped. So Config server should be Highly Available so if we maintain only one Config server Box/Container it can be a Single point of failure Ideally it should be load balanced so that we can run multiple instances of config servers and load balancer pool should have one public address where every microservice communicated. I also talk about Load Balancer in another article elaborately.

Config server Architecture Diagram (Without load balancing and Cloud bus.

Now we will create a config server using Spring Cloud

1. Setting up File Sytem:

Here I will setup a native  Filesystem based config server  I am not using git. So I will create a local file structure but in production environment please create a git remote repository. To set up a local filesystem execute the following commands in Linux environment (same for windows just need to create file using GUI.)

1. mkdir CentralRepo
2. cd CentralRepo
3. touch config.properties
4. vi config.properties
5. Hit insert
6. Write welcome.message=Hello Spring Cloud
7. Hit esc and wq!

2. Coding for Config server:

Implement config server we will use Spring cloud Netflix config server distribution.

Go to https://start.spring.io/

Create a template project using dependencies Actuator and Config server

Page will look like following

Now  hit the Generate Project button so it will download the code template.

After that I extract the code template and then import the project as an Maven project into eclipse.

If you open the pom.xml it will look like following

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>

    <artifactId>MicroserviceCongigServer</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>MicroserviceCongigServer</name>

    <description>Demo project for Spring Boot</description>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>1.5.4.RELEASE</version>

        <relativePath/> <!-- lookup parent from repository -->

    </parent>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <java.version>1.8</java.version>

        <spring-cloud.version>Dalston.SR1</spring-cloud.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-actuator</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-config-server</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-test</artifactId>

            <scope>test</scope>

        </dependency>

    </dependencies>

    <dependencyManagement>

        <dependencies>

            <dependency>

                <groupId>org.springframework.cloud</groupId>

                <artifactId>spring-cloud-dependencies</artifactId>

                <version>${spring-cloud.version}</version>

                <type>pom</type>

                <scope>import</scope>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

Now open the MicroserviceCongigServerApplication.java under com.example.MicroserviceCongigServer package.

Put @EnableConfigServer annotation on top of the class by doing so we tell SPring boot app to treat it as Config server module.

MicroserviceCongigServerApplication.java

package com.example.MicroserviceCongigServer;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

@EnableConfigServer

public class MicroserviceCongigServerApplication {

    public static void main(String[] args) {

        SpringApplication.run(MicroserviceCongigServerApplication.class, args);

    }

}

Now rename the application properties to bootstrap.properties and put the following lines

server.port=9090

spring.cloud.config.server.native.searchLocations=file://${user.home}/CentralRepo/

SPRING_PROFILES_ACTIVE=native

So the config server runs on 9090 port and we put the native file system location so config server gets the properties files from file system rather than git we also tell config server that this is a native profile.

At this point, we are all set to  run the MicroserviceCongigServerApplication.java and it will up the config server

Now test it using http://localhost:9090/config/default/master url

and we can see following response

{"name":"config","profiles":["default"],"label":null,"version":null,"state":null,"propertySources":[{"name":"file:///home/shamik/centralRepo/config.properties","source":{"welcome.message":"Hello Spring Cloud"}}]}

Read more