This article explains the concepts, processes, and practical steps of blue‑green, rolling, and canary deployments, illustrates a game‑service topology, and details how to achieve high‑availability gateway discovery and service‑layer gray releases using Consul, Consul‑Template, Nginx, and Dubbo.
This article explains why high availability is critical for internet services, outlines key techniques such as stateless design, service discovery, heartbeat checks, idempotent operations, load balancing, throttling, caching, and micro‑service architecture, and discusses the operational challenges and monitoring tools needed to maintain resilient, scalable systems.
The article discusses how to achieve high availability for large‑scale internet services by adopting stateless architecture, service discovery and registration, heartbeat monitoring, idempotent design, retry mechanisms, rate limiting, caching, and micro‑service decomposition to handle machine failures, network glitches, and high concurrency.
This article provides a comprehensive overview of microservice architecture, covering its definition, historical development, differences from monolithic systems, core characteristics, comparison with SOA, practical implementation concerns such as API gateways, communication, service discovery, fault tolerance, common design patterns, advantages, challenges, and a mindset shift required for successful adoption.
The CCF TF Architecture SIG hosted a densely attended microservices practice seminar in Beijing, featuring leading experts from 25 top tech companies who shared deep insights on service discovery, high‑availability architectures, Spring Cloud adoption, and large‑scale microservice frameworks such as Vintage, OCTO, and rest.li.
This article chronicles a small team’s evolution from single‑repo manual deployments through service splitting, messaging middleware, SDK‑based calls, service discovery, Docker automation, and log handling, highlighting practical lessons and trade‑offs at each stage.
This guide shows how to build a Spring Cloud consumer that registers with Eureka, configures LoadBalancerClient and RestTemplate, and calls a provider service’s endpoint using load‑balanced discovery, complete with Maven dependencies, configuration files, and full Java code examples.
Spring Cloud is a toolbox built on Spring Boot that provides a suite of tools for developing distributed systems, offering features such as configuration management, service discovery, routing, load balancing, circuit breaking, global locks, cluster state management, and a variety of sub‑projects like Config, Netflix, Bus, Consul, Security, Sleuth, Data Flow, Stream, and Zookeeper.
Microservices architecture introduces technical concerns such as service registration, discovery, load balancing, health checks, front-end routing, fault tolerance, dynamic configuration, and framework selection, with common solutions ranging from centralized and in-process load balancers to Netflix and Spring Cloud components.
This article explains microservice architecture versus monolithic design, discusses communication, service discovery, ordering, and messaging strategies, and details GeTui’s practical implementation using OpenResty, API gateways, Zookeeper, and DevOps automation.
This article explains the differences between monolithic and microservice architectures, introduces Docker as a key tool for microservices, and details how a Container‑as‑a‑Service (CaaS) platform can provide service discovery, routing, logging, monitoring, auto‑scaling, SLA enforcement, and deployment strategies to simplify development and operations.
This guide walks through setting up Spring Cloud, explains microservice architecture, and provides step‑by‑step instructions with code samples for creating a Eureka service registry, a compute service provider, and switching to Consul for service discovery in a cloud‑native Java environment.
This article shares the engineering team’s experience of building a high‑growth, reliable backend for English Fluently, covering inter‑service communication with gRPC, service discovery, Docker‑based deployment, health‑checking, monitoring, autoscaling, Kubernetes orchestration, and multi‑cell availability strategies.
This article provides a comprehensive overview of Netflix Eureka, explaining its background, reasons for adoption, core architecture, a step‑by‑step demo, and detailed implementation of the Eureka server, service provider, and service consumer within a Spring Cloud micro‑services environment.
This article explains the fundamental ideas behind microservices, compares them with traditional SOA, discusses when to adopt microservices, outlines design principles, explores technology selections such as Spring Cloud and Docker, and addresses common challenges like service discovery, transaction handling, and operational costs.
This article explains why microservices are chosen over monolithic architectures, outlines their key characteristics, reviews popular frameworks such as Netflix's stack and Spring Cloud, and discusses essential concerns like service discovery, load balancing, security, configuration, monitoring, and fault tolerance.
This article examines the shortcomings of classic microservice architectures, introduces a “micro‑intelligent” design philosophy and a pseudo‑social distributed model, and outlines three foundational elements—service registration, discovery, and monitoring—required to construct a robust, adaptive microservice computing platform.
This article introduces Docker 1.12’s Swarm mode, detailing its new features such as service creation, health checks, scaling, scheduling constraints, load balancing, service discovery, and rolling updates, and provides step‑by‑step instructions for building a multi‑node Swarm cluster, deploying services, and handling node failures.
This article explains how microservices adopt decentralized governance, outlines service registration and discovery mechanisms, details Docker and Kubernetes deployment strategies, describes security using OAuth2/OpenID, discusses transaction handling and fault‑tolerance patterns such as circuit breaking and timeouts, providing practical guidance for building robust cloud‑native systems.
Pinterest shares its real‑world experience using ZooKeeper for service discovery and dynamic configuration, detailing the challenges of connection overload, transaction spikes, network partitions, and human error, and explains the multi‑step solutions that improved resilience and reduced operational risk.
This article walks through designing a microservice application with Go, covering service registration and discovery, various testing strategies—including unit, integration, contract, and chaos testing—illustrates typical architectural patterns, and shares Qiniu's real‑world microservice implementation and practical Q&A.
This article explains the fundamentals of microservices architecture, contrasting it with monolithic and SOA approaches, and details design principles, messaging patterns, integration styles, data decentralization, governance, service discovery, deployment with Docker and Kubernetes, security, transaction handling, and fault‑tolerance techniques.
This article introduces etcd, a highly‑available key‑value store based on the Raft algorithm, and explores its classic use cases such as service discovery, messaging, load balancing, distributed coordination, locks, queues, monitoring, leader election, and compares it with ZooKeeper, highlighting its simplicity, security, and cloud‑native advantages.
The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent host‑level LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as F5/HAProxy, Netflix Eureka/Ribbon, and Airbnb SmartStack.
The article explains three primary load‑balancing and service‑discovery patterns for microservice architectures—centralized external load balancers, client‑side soft load balancing, and independent LB processes—detailing their mechanisms, advantages, drawbacks, and real‑world examples such as Netflix Eureka, Dubbo, and Airbnb SmartStack.
This article compares Nginx and ZooKeeper as load‑balancing solutions, explains their configurations, highlights scalability challenges with many services, and shows how ZooKeeper can serve as a service registry and notification center to complement or replace Nginx in complex environments.
This article walks through why service discovery is essential, compares Consul's features, and provides step‑by‑step instructions for deploying a Consul cluster, integrating it with Nginx/LVS/Docker, managing nodes, and safely upgrading the system.
This article outlines Meipai’s evolution into a billion‑user short‑video platform, detailing its high‑availability, scalable architecture, service discovery via etcd, data storage challenges, CDN and cloud‑storage redundancy, fault‑tolerance mechanisms, and future directions such as H.265 adoption and P2P‑CDN hybrid delivery.
This article explains what microservices are, compares them with monolithic architecture, outlines their key characteristics, and provides practical guidance on client access, inter‑service communication, service discovery, fault tolerance, and deployment considerations.
This article explains how large‑scale internet companies replace local service calls with remote procedure calls (RPC), covering Java dynamic proxies, message encoding, serialization, asynchronous response handling, and Zookeeper‑based service registration and discovery to achieve transparent, scalable service communication.
The article explains how an API Gateway can consolidate multiple fine‑grained microservice endpoints into a single coarse‑grained API for mobile clients, discussing its design considerations, benefits, drawbacks, and implementation techniques such as reactive programming, service discovery, and fault tolerance.
etcd, a highly‑available key‑value store built on the Raft algorithm, provides simple HTTP/JSON APIs for secure, fast, and reliable shared configuration and service discovery, enabling use cases such as service registration, load balancing, distributed locks, queues, leader election, and real‑time cluster monitoring.
In the cloud and mobile era, while many scalability issues can be addressed by cloud platforms, services still face challenges such as remote RPC calls, distributed tracing, configuration management including service discovery and load balancing, and scheduling with lifecycle management, prompting architects to design transparent, pluggable solutions.
