Netflix oss

netflix oss/spring cloud incubator pack

The purpose of the Netflix OSS/Spring Cloud incubator pack is to provide you with a basic understanding of all the components of the stack implemented using Spring Cloud components. The pack attempts to give you an understanding of what their function is and how to integrate them within a microservice ecosystem.

This incubator is structured around reading material that will prepare you to complete practical assignments and be able to quickly and easily set up a scalable microservice platform.

Pre-reading material

In this incubator pack, we will be relying heavily on Spring Boot and all its magic - dependency injection, IOC, AOP, Auto-Configuration. A basic understanding of Spring and Spring Boot will be advantageous in order to help you understand and master the topics in the incubator. If you are still a bit unfamiliar with these basics or you simply need to brush up, work through the video tutorial playlists below then come back.


Additional reading material

The Spring Cloud stack is fully geared towards a microservice architecture style. It's recommended you have a good understanding of the dos and don'ts of micro-services.

Initial setup

If you need some help in setting up each component individually, here are some great tutorials on how to set these up:

  • Feign - A RESTFul java client architecture for consuming Spring Cloud services.
  • Zuul - A Eureka service discovery enabled proxy and load balancer.
  • Cloud Config - Externalised and git-backed application configuration.
  • Eureka - A Spring Cloud service registry.

Section 1


Zuul has two main function. Filtering traffic and routing requests to the micro-services within the ecosystem that have been registered with Eureka. Zuul offers a flexible mechanism to create powerful filters should you need it.

  • Authentication and Security
  • Insights and Monitoring
  • Load Balancing
  • Static Response handling
  • Multiregion Resiliency

Section 2


Within a microservice architecture, service discovery and orchestration can become difficult to manage. To scale effectively we cannot rely on the old point and shoot to consume services. We need the ability to dynamically find and add more instances of our services. For this, we use Eureka - Spring Cloud's defacto service registry.

eureka has two components
  • The Eureka Server - which houses the services instance information (host, port, context).
  • Eureka Clients - which registers service information on the Eureka server and uses it to locate instances for the different service clients.

Section 3


The Cloud Config server allows us to externalize application configuration properties. This externalisation of environment properties allows us to dynamically update configurations without restarting our services incurring no downtime. Additionally, it is backed by a git repository, adding configuration management out the box.


Step 1

  • Create two Spring boot applications (Service and ServiceB)

Step 2

  • Create a Spring Cloud config server
  • Create config for these two services on the config server and have the services pull their config from here

Step 3

  • Create a Eureka server
  • Register Services A and B on Eureka
  • Make service to service call from A to B

Step 4:

  • Create Zuul proxy and setup to expose services that are registered on Eureka
  • Call A trough Zuul



Now that you have a small ecosystem up and running there are a few things to consider.

How do you make it easy to create a new micro-service and slot it into the ecosystem?

How far could this architecture stretch before it starts failing?

Is the Netflix OSS the right solution for you?

How about mixing?