Netflix Eureka Server And Client Setup With Spring Boot

Netflix Eureka Server Setup


  • We will set up a Eureka server (service registry used to register multiple services/microservices).
  • We will set up multiple Eureka clients(REST services that register to Eureka Server).
  • We will do client-side load balancing and service discovery through Eureka.

Setting up Eureka Server

The dependency required to set up a eureka server is “spring-cloud-starter-netflix-eureka-client” along with spring-boot-starter-parent. you can generate the code by going to , and provide the group id, artifact id and provide the required dependencies as shown below, and click on generate which will generate the sample code with dependency added to your pom.xml

The corresponding pom.xml should look like the below

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="" xmlns:xsi=""
		<relativePath/> <!-- lookup parent from repository -->
	<description>Demo project for Spring Boot</description>







Once you have the project open the main Springboot Class with annotation @SpringbootApplication and add the annotation @EnableEurekaServer, the class should look like this.

package com.example.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

public class EurekaserverApplication {

	public static void main(String[] args) {, args);


The last step in setting up the server is adding the application.yml file which will have eureka relate properties when you start the application with @EnableEurekaServer annotation it will look for bootstrap.yml file if not found it will look for application.yml file for the properties the yml file should look something like this.

  port: 9090

    register-with-eureka: false
    fetch-registry: false
      defaultZone: http://localhost:9090/eureka/

The above properties yaml file defines the eureka defaultZone serviceUrl where eureka is supposed to run. register-with-eureka property is set to false as we don’t want to register Eureka Server to itself.
Once everything is the project structure should look like the below image

Go ahead and start the spring boot application, the eureka server should be up in whatever port you mentioned in application.yml file in this case eureka server will be up at localhost:9090 and will look like below.

Ola, we have set up the eureka server.

Now we will go ahead and create two clients named client1 and client2 from the spring initializer like the above with adding one more dependency Eureka Discovery Client, as shown below

Once we have both the projects created we will go ahead and add the annotation @EnableDiscoveryClient on the root SprintBootApplication class as shown below for both the clients Client1 and Client2

package com.example.client2;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

public class Client2Application {

	public static void main(String[] args) {, args);


Similarly, we need to update the application.yml file as below providing the required eureka config details.

    name: 'client1'
  port: 8081

    hostname: ${vcap.application.uris[0]:localhost}
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 10
    lease-expiration-duration-in-seconds: 20
      defaultZone: http://localhost:9090/eureka

In the above code, we have provided the spring application name and eureka client service URL where the eureka server resides, so once you start the client it will look into the service URL and tries to register itself. The property lease-renewal-interval-in-seconds: 10 & lease-expiration-duration-in-seconds: 20 lets the Eureka Server when to check for the health of the client. Once you made these changes go ahead and start both the clients.

If you go back to Eureka Server you will now be able to see the two clients registered with names CLIENT1 and CLIENT2 as shown below.

Now the setup has been completed the two clients can talk to each with using the service discovery.

Here is the video tutorial explaining the same

Java Datatypes

What is a Datatype?
A data type is an attribute of data that tells the compiler or interpreter how the programmer intends to use the data.

Data types in Java programming language

There are two different sets of data types in Java

  • Primitive Datatypes
  • Non Primitive Datatypes

The below image depicts different data types in java

Java Datatypes

The Java programming language is statically-typed, which means that all variables must first be declared before they can be used. This involves stating the variable’s type and name.

boolean: is used to store true or false value.

byte, short, int, long: is used to store whole numbers.

float, double: is used to store fractional numbers.

The below table depicts different datatypes and the size of those datatypes.


public class BasicDataTypes {
	static byte i = 127;
	static short j = 3456;
	static int k = 24233534;
	static long l = 34564;
	static float fl = 35325432;
	static double db = 34523763;
	static boolean b = true;
	static char c = 'c';
	static String testString = "Hello World";
	public static void main(String [] args) {
		char[] testCharString = new char[11];
		testCharString[0] = 'h';
		testCharString[1] = 'e';
		testCharString[2] = 'l';
		testCharString[3] = 'l';
		testCharString[4] = 'o';
		testCharString[5] = ' ';
		testCharString[6] = 'w';
		testCharString[7] = 'o';
		testCharString[8] = 'r';
		testCharString[9] = 'l';
		testCharString[10] = 'd';
		System.out.println("Default value of byte is ---> "+i);
		System.out.println("Default value of short is ---> "+j);
		System.out.println("Default value of int is ---> "+k);
		System.out.println("Default value of long is ---> "+l);
		System.out.println("Default value of float is ---> "+fl);
		System.out.println("Default value of double is ---> "+db);
		System.out.println("Default value of boolean is ---> "+b);
		System.out.println("Default value of char is ---> "+c);
		System.out.println("Default value of String is ---> "+testString);
		System.out.println("Default value of char is ---> "+String.valueOf(testCharString));



Here is the video

Difference between JDK, JRE, and JVM

In this post, we will see the major differences between JDK, JRE, and JVM.

JDK (Java Development Kit): JDK is the one you need to build applications in Java, it contains everything that is required to build and run Java applications. When you download java from the oracle site to develop applications you actually download JDK, which comes with JRE and the following Devtools,

JavaC: Java Compiler which compiles your Java code.
Java: Interpreter/loader which reads your java code.
JavaDoc: This helps in generating java documentation for your code.

JRE (Java Runtime Environment): JRE contains everything to run the java application, it contains code libraries required to develop java applications. JRE contains the Java class libraries, the Java class loader, and the Java Virtual Machine. In this system:
The class loader is responsible for correctly loading classes and connecting them with the core Java class libraries. The JVM is responsible is to ensure Java applications have the resources they need to run and perform well in your device or cloud environment.
The JRE is an orchestrator between these components.

JVM (Java Virtual Machine): JVM is machine-specific and can only read byte code that has been generated using java compiler.  Once the java compiler compiles the code to byte code, JVM is the one which reads it and runs on that machine, you might have heard that Java is portable, this is what it meant the compiled byte code can be run on any machine with the help of JVM.

Java Conceptual Diagram
Image Courtesy

You might have seen the below image saying Java is being run on 3 billion devices, it actually means JVM is running.

3 Billion devices run java

Here is the basic intro to Java Programming Language.