Building a Docker‑Powered Microservice PaaS with Spring Cloud Netflix

Microservice Access Path

The platform follows a typical request flow: external request → load balancer → service gateway (Zuul) → microservice → data or messaging service. Both the gateway and microservices rely on service registration and discovery, while configuration is provided by a centralized config server.

Service Gateway (Zuul)

The gateway acts as the entry point for client browsers and mobile devices, routing requests to backend services. It is deployed in a cluster behind an Amazon EC2 instance pool with Elastic Load Balancing (ELB). SSL termination is handled by Nginx. Core capabilities include dynamic routing, rate limiting and fault tolerance, authentication, monitoring, and access logging.

Dynamic routing: routes requests to appropriate backend clusters while hiding internal complexity.

Rate limiting & fault handling: rejects excess traffic and provides fallback responses.

Authentication & security: validates users and can implement anti‑scraping measures.

Monitoring: collects metrics for performance tuning.

Access logs: records service usage for analysis.

Implementation uses Spring Cloud Netflix's Zuul with custom filters to achieve these functions.

Service Registration and Discovery (Eureka)

Microservices register themselves with an Eureka server, sending heartbeats every 30 seconds. The server considers a service dead after missing three consecutive heartbeats (default 90 seconds) unless self‑preservation mode is enabled. Eureka nodes synchronize via DNS‑based clustering.

Microservice Deployment

Each microservice runs as a Docker container, allowing language‑agnostic development and easy scaling. Docker images contain the JDK and application code, stored in a private image repository. Containers are orchestrated with Docker Swarm, and a load balancer (Ribbon) distributes traffic among service instances.

Service Fault Tolerance (Hystrix)

Hystrix provides circuit breaking, thread isolation, fallback, and rate limiting. Circuit breaking stops calls to unhealthy services after a 50 % error threshold, entering a half‑open state to test recovery. Thread pools isolate services, preventing a single failure from exhausting resources. Fallback logic can return default values or cached data. Rate limiting caps concurrent requests to protect downstream services.

Circuit breaking: stops calls when error rate exceeds a threshold.

Thread isolation: each service runs in its own thread pool.

Fallback: custom logic executed on failure or timeout.

Rate limiting: rejects excess traffic to avoid overload.

Dynamic Configuration Center

Configuration files are stored in a private Git repository. Spring Cloud Config Server reads these files at runtime. When a developer pushes changes, a server‑side Git hook notifies the Config Server via a message queue, prompting it to refresh the affected configurations without rebuilding images.

The platform combines Zuul, Eureka, Hystrix, Ribbon, and Config Server to provide a complete, cloud‑native microservice architecture that supports rapid development, continuous integration, and scalable operations.