Docker Microservices Blueprint: Service Discovery, API Gateway & CI/CD

Introduction

Having worked with Docker since 2015, the author shares lessons from building a microservice architecture in a startup, aiming to help DevOps engineers and developers understand enterprise‑grade service design.

Microservice and Docker

Rapid development in startups often leads to monolithic or simple front‑back separation, which creates hidden costs as the team grows. Early adoption of microservices, combined with Docker’s ecosystem, can reduce long‑term complexity. Each microservice can follow a hexagonal DDD design, exposing clear domain boundaries.

Service Discovery Patterns

Two main patterns are discussed:

Client‑side discovery – exemplified by Netflix Eureka, where each client queries a registry and performs load balancing locally.

Server‑side discovery – a load balancer (e.g., HAProxy or Nginx) queries the registry and forwards requests; common implementations include Consul, Etcd, and Zookeeper.

Typical client‑side flow with Eureka:

com.netflix.discovery.DiscoveryClient : DiscoveryClient _SERVICE-USER/{ip}:service-user:{port}:... registering service...

Self‑registration (Eureka) is simple but Java‑only, while third‑party registrars like Registrator can bridge other languages to Consul or Etcd.

Service Registration Patterns

Self‑registration (each instance registers/unregisters itself) and third‑party registration (a sidecar registrar handles registration and heartbeats) are compared, with diagrams illustrating both approaches.

Inter‑Process Communication (IPC)

Two categories are presented:

Synchronous – REST/HTTP, Thrift, Dubbo (Java), or Spring Cloud RPC for cross‑language calls.

Asynchronous – message queues such as RabbitMQ (AMQP), Kafka, ActiveMQ, or RocketMQ for decoupled communication.

Examples of message‑queue components (producer, broker, consumer) are described.

API Gateway

The gateway aggregates multiple service calls (e.g., user, order, product) into a single client request, reducing client complexity and enabling response‑time optimization via reactive programming (RxJava, CompletableFuture). It also centralizes authentication, load balancing, caching, error handling, timeout, and retry policies.

Typical gateway flow uses non‑blocking I/O and can combine results with RxJava Observables.

Continuous Integration & Deployment

Docker images are built with Maven or Gradle, stored in a private registry (e.g., Docker Registry v2). Source code resides in GitLab. Container orchestration options include Docker Compose for small clusters, Docker Swarm (native since Docker 1.12), and Kubernetes for large‑scale deployments.

Database & Storage Choices

Relational databases (MySQL InnoDB) are recommended for core data, with sharding and partitioning considered per domain. Key‑Value stores (Redis with RDB/AOF persistence, Memcached) serve caching and lightweight data. Graph databases (Neo4j) suit social‑graph scenarios, while document stores (MongoDB) handle flexible JSON‑like data.

Search Technologies

Elasticsearch (or Solr) provides distributed full‑text search and analytics, often deployed via Docker.

Security

Network security measures include firewalls, HTTPS, ACLs (Consul, Zookeeper), and token‑based authentication via Spring Security. Service‑level ACLs and internal‑network access are emphasized.

Logging & Monitoring

Logs are collected from gateways and services using Spring filters, enriched with trace IDs, and shipped to an ELK stack (Logstash → Elasticsearch → Kibana). High‑throughput logging can be offloaded through message queues.

Key Architectural Takeaways

Five pillars of the Docker microservice stack are highlighted: performance (message queues, RxJava, caching, Elasticsearch), availability (container clusters, circuit breakers, retries), scalability (Kubernetes, sharding, NoSQL), extensibility (Docker‑native design), and security (HTTPS, Spring Security).

Conclusion

The author stresses that while microservice adoption requires careful planning, the combination of Docker, service discovery, API gateways, and modern DevOps tooling provides a robust foundation for rapid yet sustainable growth.