Tagged articles
health check
63 articles · Page 1 of 1
This article analyzes Nacos service registration and discovery internals, covering architecture, Spring Cloud Commons integration, heartbeat-based health checks, OpenAPI registration flow, and the HostReactor's three-map caching mechanism with 10-second periodic updates and failover support.
NacosRaftService Discovery
0 likes · 21 min read

The November 2026 Microsoft Outlook outage, triggered by automated health checks incorrectly taking servers offline, caused a cascading failure across Microsoft 365 services, exposing seven layers of enterprise risk from business continuity to security blind spots, and prompting nine concrete resilience actions for organizations dependent on cloud infrastructure.
Microsoft 365Microsoft Outlookbusiness continuity
0 likes · 20 min read

On November 12, a Microsoft cloud outage took down Microsoft 365, Outlook, and Teams for hours, also disrupting OpenAI and Anthropic services; the root cause was servers failing health checks under load, triggering a cascading failure that Microsoft mitigated by pausing deployments and rerouting traffic, with recovery underway by November 13.
AnthropicMicrosoft 365OpenAI
0 likes · 3 min read

This guide covers 10 essential Elasticsearch command categories with practical examples, including cluster health checks, index management, CRUD operations, mapping design, and node/shard monitoring for production troubleshooting.
ElasticsearchIndex OperationsMapping
0 likes · 7 min read

This article provides a comprehensive interview self‑test covering Spring Boot Actuator’s built‑in endpoints, health‑check JSON format, status aggregation logic, custom HealthIndicator implementation, show‑details configuration, @Endpoint operation annotations, liveness vs. readiness probes, handling of DOWN status, disabling auto‑configured indicators, security risks of exposing all endpoints, HealthIndicatorRegistry naming rules, additional Actuator endpoints, CompositeHealth construction, and custom HealthStatusHttpMapper mapping.
ActuatorJavaKubernetes
0 likes · 22 min read

This guide walks through setting up Spring Boot 3.x with JDK 17+, adding Actuator and test dependencies, and implementing a comprehensive JUnit 5 test suite that validates health endpoint aggregation, status priority, show‑details configuration, custom endpoints, JVM metrics, endpoint exposure, health groups, and custom HTTP status mapping, with instructions for running the tests via Maven or an IDE.
ActuatorJDK 17JUnit5
0 likes · 17 min read

This guide walks through verifying the Nginx environment, configuring a reliable upstream block, setting proper proxy headers and timeouts, validating backend health, handling failures, exposing observability, and performing controlled rollouts to ensure traffic is correctly balanced without service disruption.
ConfigurationLinuxhealth check
0 likes · 28 min read

This guide explains how to set up Nginx as a load balancer for several OpenAI‑compatible large language model instances, covering health checks, upstream configuration, algorithm selection, streaming vs non‑streaming proxy settings, logging, rate limiting, graceful reloads, and troubleshooting techniques.
LLMOpenAI compatibleProxy
0 likes · 25 min read

This article walks through building a simple, cost‑effective high‑availability solution for Nginx using Keepalived’s VRRP‑based VIP failover, covering environment setup, configuration of master and backup nodes, health‑check scripts, testing procedures, troubleshooting tips, and rollback steps.
FailoverHigh AvailabilityKeepalived
0 likes · 29 min read

This guide walks through the differences between 4‑layer (TCP) and 7‑layer (HTTP) load balancing in Nginx, explains when to use each, and provides step‑by‑step configuration examples, health‑check setups, performance tuning, SSL handling, WebSocket support, and common pitfalls.
ConfigurationPerformance Tuninghealth check
0 likes · 25 min read

After splitting a monolithic blog into independent services, this article explains how to solve the core problem of locating services by introducing Nacos as a registration center, detailing its installation, configuration, service registration, discovery, load balancing, health‑checking, common pitfalls, and a complete hands‑on example.
NacosService DiscoveryService Registration
0 likes · 14 min read

This comprehensive guide explains the fundamentals of reverse proxy, walks through Nginx configuration, load‑balancing algorithms, health‑check setups, caching strategies, session‑persistence methods, high‑availability designs, performance tuning, monitoring, and troubleshooting, providing practical code snippets for real‑world deployments.
High Availabilityhealth checkload-balancing
0 likes · 30 min read


ITPUBFeb 20, 2026 · Databases
This guide introduces a collection of PostgreSQL SKILL scripts for automated health checks and operational analysis, explains the repository layout, shows how to run individual or full daily checks, lists all available skills, and provides a sample report with actionable recommendations.
PostgreSQLSQLdatabase monitoring
0 likes · 11 min read

This article reveals three hidden traps in Nginx‑Keepalived high‑availability setups—network‑partition split‑brain, inadequate health‑check scripts, and unsafe configuration‑sync timing—explains real incidents caused by each, and provides concrete configuration changes, Bash scripts, and automation tips to prevent service outages.
Keepalivedautomationhealth check
0 likes · 16 min read

This guide explains the differences between Layer 4 and Layer 7 load balancing in Nginx, shows how to select the appropriate mode for various scenarios, provides detailed configuration examples—including upstream settings, health checks, SSL handling, and performance tuning—and shares best‑practice tips to avoid common pitfalls.
Performance Tuninghealth checklayer 4
0 likes · 24 min read

A financial services outage caused by misconfigured Kubernetes liveness and readiness probes illustrates how misunderstanding these health checks can trigger costly restart loops, while this guide explains their core differences, proper configuration, advanced strategies, common pitfalls, and monitoring techniques to ensure stable, resilient services.
KubernetesLiveness ProbeReadiness Probe
0 likes · 9 min read

This article reveals three hard‑to‑detect pitfalls in Nginx + Keepalived high‑availability setups—split‑brain caused by network partitions, inadequate health‑check scripts, and unsafe configuration‑sync timing—provides real‑world incident examples, and offers complete, battle‑tested solutions with ready‑to‑use scripts.
Configuration SyncHigh AvailabilityKeepalived
0 likes · 16 min read

Dynamic‑datasource 4.3.1 offers a powerful AOP‑based, annotation‑driven solution for seamless multi‑database routing, read‑write separation, and load‑balancing in Spring Boot applications, while addressing common pitfalls such as transaction boundaries, connection‑pool configuration, health‑check failures, and version compatibility.
Multi-DataSourcedynamic-datasourcehealth check
0 likes · 18 min read

This guide walks through configuring a SpringBoot application to automatically start on Linux boot and recover from crashes using native systemd service files or the cross‑platform Supervisor tool, covering scripts, service definitions, common pitfalls, health checks, and restart‑limit strategies.
Process ManagementSpringBootauto-restart
0 likes · 13 min read

This comprehensive guide walks you through installing HAProxy via yum, RPM packages, or source compilation, then details every core configuration block—including global, defaults, frontend, backend, and listen sections—while covering load‑balancing algorithms, ACL routing, health checks, SSL termination, statistics, and practical code examples for building a robust, high‑performance load‑balancer.
ConfigurationHAProxyOperations
0 likes · 53 min read

This article explores how to embed load‑balancer concepts such as intelligent request distribution, health checks, automatic failover, and dynamic strategy adjustment directly into PHP applications using algorithms like weighted round‑robin, response‑time balancing, and circuit‑breaker patterns, providing code examples and practical deployment scenarios.
FailoverPHPhealth check
0 likes · 11 min read

Explore comprehensive Spring Boot 3 Actuator capabilities—including enabling CORS, creating custom endpoints, configuring health indicators, HTTP tracing, security auditing, and process monitoring—through detailed explanations, YAML configurations, and full Java code examples, empowering developers to effectively monitor and manage production-ready applications.
ActuatorCustom EndpointSpring Boot
0 likes · 8 min read

To prevent service disruption caused by overly aggressive or sluggish Kubernetes liveness and readiness probes, this guide shows how to implement a custom health‑check script that periodically tests a service endpoint, exits the container on failure, and lets Kubernetes automatically restart the pod.
Container RestartCustom ScriptDocker
0 likes · 5 min read

This article explores Polaris‑Mesh’s server‑side health‑check mechanism, detailing how client heartbeat requests are received via gRPC, processed through Apiserver, Resource Auth Filter, Service, Healthcheck, and Checker Plugin, and how the system’s configuration, plugins, and time‑wheel ensure reliable instance health monitoring.
GoPolarisMeshhealth check
0 likes · 11 min read


IT NiukeJun 2, 2024 · Backend Development
The article analyzes the limitations of deploying web services with Tomcat alone—such as DNS IP caps, scaling costs, lack of health checks, static file handling, and release downtime—and demonstrates how Nginx’s reverse‑proxy, health‑check, and virtual‑host features overcome these issues with concrete configuration examples.
DNSTomcatWeb Servers
0 likes · 11 min read


21CTOFeb 13, 2024 · Backend Development
Laravel 11 adds a default health‑check endpoint accessible via the /up route, configured in bootstrap/app.php, which dispatches a DiagnosingHealth event and returns an animated "Application up" page to verify application status.
LaravelLaravel 11PHP
0 likes · 2 min read

This article deep‑dives into Nacos as a service registry, explaining the differences between temporary and permanent instances, registration mechanisms across 1.x and 2.x versions, heartbeat and health‑check strategies, service discovery methods, data‑consistency models, and the underlying data model that powers Nacos clusters.
ConsistencyNacosgRPC
0 likes · 28 min read

This article walks through implementing three load‑balancing algorithms (random, round‑robin, weighted round‑robin) in Go, explains the weighted selection math with step‑by‑step examples, and presents two service‑liveness solutions—heartbeat via Docker/Kafka and HTTP health checks—complete with code snippets and deployment commands.
DockerGoKafka
0 likes · 9 min read

This article investigates why a Go‑based service health‑check system experiences high latency, examines differences from Nginx checks, runs experiments on physical machines and Docker, and explores goroutine scheduling, GOMAXPROCS, and garbage‑collection tuning to reduce average response time from 40 ms to under 10 ms.
Dockergarbage collectionhealth check
0 likes · 10 min read

This guide explains how to combine Kubernetes and Spring Boot to implement zero‑downtime releases by configuring readiness and liveness probes, defining graceful shutdown, applying rolling update strategies, setting up horizontal pod autoscaling, integrating Prometheus monitoring, and separating configuration via ConfigMaps for reusable images.
PrometheusRolling UpdateSpring Boot
0 likes · 13 min read

This guide explains how to achieve zero‑downtime releases of a Spring Boot application on Kubernetes by configuring readiness/liveness probes, rolling‑update strategies, graceful shutdown, horizontal pod autoscaling, Prometheus metrics collection, and externalized configuration via ConfigMaps.
ConfigMapKubernetesPrometheus
0 likes · 11 min read


21CTONov 17, 2022 · Operations
This article explains what load balancing technology is, reviews common load balancing algorithms such as Round Robin, Weighted Round Robin, Least Connections, and Consistent Hash, and demonstrates their implementations with code examples, while also covering extensions like service discovery, health checks, and slow start mechanisms.
Algorithmsdistributed systemshealth check
0 likes · 21 min read

The article explains how NetEase Media rebuilt its core services with Go, created the open‑source ngo framework to unify dependencies, health‑check, tracing, configuration and OpenID support, and provides detailed code examples and integration guidelines for backend developers.
BackendConfigurationGo
0 likes · 17 min read

This article explains how to assemble a production‑grade service registry by analyzing requirements, defining registration/discovery interfaces, comparing push and health‑check mechanisms, selecting long‑connection technologies, and choosing data‑storage and high‑availability strategies, all illustrated with JSON examples and design guidelines.
Long ConnectionSerializationService Discovery
0 likes · 14 min read

This article explains how developers and operators should prepare a Go‑based service for Kubernetes by implementing health‑check endpoints, graceful shutdown handling, metrics exposure, tracing integration, standardized logging, and operational best practices such as stateless design, high availability, self‑healing, and HTTPS configuration.
DevOpsKubernetesTracing
0 likes · 20 min read

The article outlines four practical steps—application health checks, event annotation, minimizing pod impact, and blue‑green deployment—to streamline production releases, increase visibility, and reduce downtime while ensuring services run as expected.
Blue-GreenPodsdeployment
0 likes · 8 min read

The article explains why MHA’s default long‑connection ping cannot detect a hung MySQL instance, introduces three configurable ping_type options (select, connect, insert), shows how to modify the configuration and test the behavior with Perl code and shell scripts, and details the internal health‑check workflow.
FailoverMHAMySQL
0 likes · 12 min read

This article explains Nacos's health‑check and heartbeat mechanism in detail, covering the client‑side heartbeat scheduling, metadata configuration, server‑side beat reception, instance health evaluation, and the periodic health‑check tasks that mark or remove unhealthy instances.
BackendNacosService Discovery
0 likes · 13 min read

This article examines Nacos’s default health‑check timing, explains the risks of a 15‑second blind spot when a service crashes, and shows how to configure custom heartbeat intervals, protection thresholds, and Spring Cloud LoadBalancer retry settings to minimize downtime and avoid cascade failures.
NacosRetrySpring Cloud
0 likes · 12 min read

This article examines the motivations for service discovery in microservice architectures, compares client‑side and server‑side discovery patterns, discusses consistency versus availability trade‑offs (CAP, CP vs AP), and reviews various health‑check mechanisms, graceful up/down strategies, metadata considerations, and high‑availability designs.
Consistencyhealth checkload-balancing
0 likes · 14 min read

The article outlines four practical steps—application health checks, event annotation, pod impact minimisation, and blue‑green deployments—to help teams deploy code with minimal effort, zero interruption, and clear visibility into service health across environments.
Blue-Greencloud-nativehealth check
0 likes · 8 min read

Learn how to configure Nginx’s three health‑check methods—TCP, HTTP, and custom—by understanding each parameter such as interval, fall, rise, timeout, and type, and see a complete upstream example that ensures timely detection of unhealthy service nodes.
BackendConfigurationhealth check
0 likes · 7 min read

This article explains how Nginx can automatically register services and remove unhealthy nodes by using TCP or HTTP health‑check schemes, details each configuration parameter, and provides a complete example configuration for reliable service governance.
Service Governancehealth check
0 likes · 7 min read

This article explains how to add a health‑check endpoint to a Node.js service, use gateway polling to verify availability, and coordinate smooth releases with Egg.js plugins, while also covering CDN asset management and manifest‑based code discovery for front‑end resources.
CDNNode.jsegg.js
0 likes · 9 min read

This article explains how SpringBoot Admin visualizes service status via the Spring Actuator health endpoint, why some services appear offline despite functioning, and provides step‑by‑step troubleshooting of Sentinel health checks, including configuration tweaks and code examples to ensure proper initialization and connectivity.
SentinelSpringBootbackend-monitoring
0 likes · 7 min read

Envoy provides active and passive health checks—including HTTP, L3/L4, and Redis types—configurable intervals and failure thresholds, along with a health‑check filter that can bypass, forward, or cache requests, and detailed connection‑pool handling for HTTP/1.1 and HTTP/2 to ensure reliable service routing.
Envoyconnection poolhealth check
0 likes · 7 min read

This article explains Envoy’s service discovery mechanisms—including static, strict DNS, logical DNS, original‑destination, and Service Discovery Service—detailing how they work, their consistency models, and how health‑checking influences routing decisions in production environments.
DNSEnvoyService Discovery
0 likes · 8 min read

This article shares the 2019 cloud‑native migration experience of an e‑commerce team, covering Docker and Kubernetes basics, Java‑Docker compatibility, memory and CPU limits, log collection, JDK version choices, Dockerfile and multi‑stage build practices, health checks, graceful shutdown, and common pitfalls encountered during containerization.
ContainerizationDockerJVM
0 likes · 21 min read

This article walks through building a basic round‑robin load balancer in Go, covering the underlying principles, data structures, reverse‑proxy integration, atomic indexing, concurrency handling, health‑check mechanisms, and how to extend the implementation for production use.
ConcurrencyGobackend development
0 likes · 11 min read

This article walks through building a simple Go load balancer using round‑robin distribution, reverse proxy, atomic indexing, health checks, and concurrency‑safe data structures, providing complete code examples and explanations for each component.
backend developmenthealth checkload balancer
0 likes · 12 min read

This guide walks through installing and compiling Nginx and its Alibaba‑derived fork Tengine, adding the echo‑nginx module, configuring health‑check directives, testing the setup with sample URLs, and explains Nginx upstream fault‑tolerance mechanisms for production environments.
Server configurationTenginehealth check
0 likes · 15 min read

This article explains Baidu’s multi‑stage deployment process, the importance of health‑check monitoring between stages, and how rule‑based and AI‑driven checks automatically detect abnormal metric changes to reduce change‑induced outages and improve operational stability.
DevOpshealth checkintelligent monitoring
0 likes · 10 min read

This article examines three OpenResty-based backend health‑check solutions—ngx_http_upstream_module, lua‑resty‑upstream‑healthcheck, and nginx_upstream_check_module—detailing their implementation principles, configuration examples, node status monitoring, and practical Docker integration, helping developers choose the optimal approach for reliable service availability.
DockerLuaOpenResty
0 likes · 9 min read

This article introduces the concept of load balancing as a key high‑availability technique, explains five common strategies—round robin, weighted round robin, least connections, fastest response, and hash—provides code examples, compares their pros and cons, and outlines health‑check methods to ensure reliable service.
HashLeast Connectionshealth check
0 likes · 10 min read

This article explains what load balancing is, compares it to navigation routing, and details five common strategies—round‑robin, weighted round‑robin, least connections, fastest response, and hash‑based—along with their pros, use‑cases, and health‑check mechanisms for achieving high availability.
AlgorithmBackendOperations
0 likes · 8 min read

This article examines the weak health_check mechanism of open‑source Nginx, demonstrates a test setup with two Tomcat backends, analyzes access and error logs to show how Nginx retries failed servers, explains the role of max_fails, fail_timeout, and compares it with Nginx Plus features.
fail_timeouthealth checkload_balancing
0 likes · 10 min read

The article explains Envoy's outlier detection and ejection process, detailing how unhealthy upstream hosts are identified and temporarily removed based on consecutive 5xx errors, gateway failures, or success‑rate thresholds, and describes the logging format and configuration options for these health‑check mechanisms.
Operationsejectionhealth check
0 likes · 6 min read

This article explains the architecture and key features of CDB for MySQL read-only instances and RO groups, including read-write separation, horizontal scaling, automatic load balancing, health checks, and dynamic instance removal for high-delay instances.
MySQLRO GroupRead-Only Instances
0 likes · 5 min read


ITPUBFeb 5, 2017 · Operations
This article walks through a hands‑on packet‑capture experiment comparing HAProxy and Nginx load‑balancing behavior, showing how HAProxy’s health‑check interval can cause request loss during backend failures while Nginx continues to serve traffic.
HAProxybackend failurehealth check
0 likes · 7 min read

Learn how to create a lightweight HTTP health‑check service with xinetd that runs a shell script to monitor MySQL status, enabling HAProxy to instantly detect failures and stop routing traffic, complete with step‑by‑step configuration, testing commands, and sample scripts.
HAProxyLinuxMySQL
0 likes · 5 min read

This article explains the fundamentals of load balancing, compares common techniques such as DNS round‑robin, hardware and software load balancers, discusses their advantages and drawbacks, and introduces Alibaba's VIPServer as a mid‑tier, seven‑layer load‑balancing solution with advanced health‑check and traffic‑routing features.
Cloud OperationsDNSL4/L7
0 likes · 19 min read

NGINX determines server health through passive checks—stopping forwarding after failures—and active health checks, which periodically probe each backend using the health_check directive, allowing configuration of intervals, failure thresholds, custom URIs, and response matching criteria to ensure reliable load balancing.
Operationsactive checkhealth check
0 likes · 4 min read

This guide walks through the concepts of VRRP, the keepalived daemon, and step‑by‑step installation and configuration of a redundant LVS load‑balancing setup on Linux, including node preparation, keepalived.conf tuning, HTTP service deployment, and health‑check scripting.
KeepalivedLVSLinux
0 likes · 10 min read
