This article presents a detailed, end‑to‑end case study of how Yanhuang Data leveraged the Honghu data‑analysis platform to build a complete Nginx operations‑management solution, covering data ingestion, parsing, modeling, visualization, alerting, third‑party integration, and best‑practice recommendations.
This article explains the thundering herd phenomenon in multi‑process servers, walks through Nginx’s master‑worker architecture and its use of epoll, and compares three practical mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—complete with code excerpts and configuration examples.
This article explains what a 502 Bad Gateway error means, why it is usually generated by a reverse‑proxy like nginx, and provides step‑by‑step methods to identify common causes such as backend timeouts, process crashes, and misconfigured upstream servers.
Using only Tomcat for web services leads to DNS limits, scaling costs, lack of health checks, and no static file handling, so the article explains why Nginx is essential for load balancing, failover, and virtual‑host configuration, and provides practical Nginx examples.
This step‑by‑step guide shows how to install FastDFS on a Linux server, configure its tracker and storage nodes, integrate it with Nginx, and expose the file service to the Internet using the cpolar tunneling tool, all with detailed commands and configuration files.
This article walks you through understanding what a Raspberry Pi Zero W is, preparing the hardware, flashing Raspbian Lite, configuring SSH and Wi‑Fi, optimizing the system, installing nginx, and exposing the device to the internet using tools like ngrok.
This article explains Docker fundamentals, compares containers with virtual machines, details Docker’s core components and common commands, and provides complete step‑by‑step instructions for packaging, building, running, automating, and pushing both a Vite‑based React frontend and an Express‑based Node.js backend using Nginx and shell scripts.
This article explains how Nginx's ip_hash directive implements session affinity by routing all requests from the same client IP to a single backend server, demonstrates configuration examples, analyzes behavior when servers go down, and discusses the method's limitations such as load imbalance and dynamic IP issues.
This article explains how to achieve session affinity using Nginx's ip_hash directive, covering the concept, configuration syntax, practical examples, common pitfalls, and test results for handling client IP‑based load balancing across backend servers.
This article explains the thundering herd effect in multi‑process servers, describes Nginx's master‑worker architecture and its use of epoll, then compares three mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—showing code snippets and performance insights.
This article explains what a Web Application Firewall (WAF) is, introduces the open‑source SafeLine WAF, and provides step‑by‑step instructions for containerized installation, describes its architecture and core security capabilities such as semantic attack detection, IP intelligence, traffic control, and high‑performance protection for web sites.
This tutorial explains why centralized log collection is essential for micro‑service systems, introduces the ELK stack (Elasticsearch, Logstash, Kibana), provides step‑by‑step installation on Ubuntu, shows how to configure Logstash shipper and indexer pipelines, and demonstrates integration with Spring Boot and Nginx logs for real‑time monitoring.
This article explains how to configure Nginx as a stream proxy to securely connect to MySQL servers, covering required modules, stream, server, listen directives, IP access restrictions, and provides complete configuration examples for both single‑instance and clustered environments.
This guide walks through the two most typical Nginx HTTP‑to‑HTTPS redirection setups—direct client access and proxy‑mediated access—showing why the simple 301 rule works in the first case, why it fails with an upstream proxy, and how to correctly use request headers and Nginx variables to achieve reliable redirects.
This article explains how to configure Nginx's stream module to proxy MySQL connections, including building Nginx with the required module, setting up stream, server, and listen directives, and using allow/deny rules to restrict access by IP, followed by a complete configuration example.
This article provides an in‑depth overview of Nginx, covering its core features, performance benefits, request processing flow, forward and reverse proxy concepts, startup commands, directory layout, detailed nginx.conf settings, location directive syntax, common SPA 404 handling, CORS setup, and gzip compression for building high‑performance web services.
This guide explains how to use Nginx’s stream module as a jump‑host to securely proxy MySQL connections, covering module compilation, core directives, configuration examples for single and clustered servers, and IP‑based access restrictions to protect database traffic.
SQL injection is a critical web security flaw where unsanitized user input can alter database queries, and this article explains its mechanics, demonstrates vulnerable Java code, and outlines four prevention methods—PreparedStatement, MyBatis #{}, request parameter filtering, and Nginx reverse‑proxy rules—complete with code examples.
This article explains the importance of Docker for frontend development, covering its role as a consistent runtime environment, the benefits of standardized CI/CD pipelines, multi‑stage builds, caching strategies, and practical deployment patterns for static assets, Node.js services, and micro‑frontend architectures.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
The article explains why rate limiting is essential for high‑traffic Spring Boot services, compares counter, sliding‑window, token‑bucket and leaky‑bucket algorithms, demonstrates implementations with plain Java, Guava RateLimiter, AOP, and distributed approaches using Redis‑Lua and Nginx‑Lua, and provides practical configuration examples.
This article explains the complete browser caching workflow for Google Chrome, covering strong and conditional caching mechanisms, the differences between disk and memory caches, relevant HTTP response headers, how to clear or bypass caches, and practical Nginx configuration tips for front‑end developers.
This guide explains how to collect Nginx access logs, convert them to JSON, ship them with Promtail to Loki, and visualize the data in Grafana, including installation steps, configuration snippets, GeoIP setup, and dashboard customization for a complete observability solution.
This article analyzes the challenges of browser caching in micro‑frontend projects, presents a systematic optimization plan—including resource versioning, server‑side URL proxying, nginx cache‑control configuration, and CDN integration—and demonstrates a 48.5% reduction in page‑load time with detailed implementation steps and performance data.
This comprehensive guide walks you through the challenges of monolithic deployments, explains core Nginx concepts, shows step‑by‑step installation, configures reverse proxy, static‑dynamic separation, compression, buffering, caching, security features, SSL, high‑availability with keepalived, and essential performance tuning for production‑grade servers.
This guide explains three ways to generate SSL certificates using OpenSSL, including creating a private key, self‑signed certificate, and CSR‑based signing, and shows how to configure Nginx to enable HTTPS with the generated certificates.
This comprehensive guide walks you through installing Nginx, configuring reverse proxy, setting up load balancing, enabling static‑dynamic separation, resource compression, buffering, caching, IP whitelist/blacklist, cross‑origin support, anti‑hotlinking, large file handling, SSL certificates, high‑availability with Keepalived, and performance tuning tips for production environments.
This article explains how Nginx can be used to achieve various load‑balancing strategies—including round‑robin, least‑connections, IP hash, generic hash, least‑time, and random—provides detailed configuration examples, shows how to integrate Nginx with SpringBoot services, and outlines testing and deployment steps.
This guide explains how to edit the Nginx configuration file to set appropriate worker_processes and worker_cpu_affinity values based on CPU cores and I/O characteristics, includes practical command examples, and provides sample configurations for different core counts.
This article shares a hands‑on journey of solving cross‑origin issues in a multi‑domain education product, covering CORS fundamentals, simple and preflight requests, Nginx and SpringBoot configurations, response‑code choices, and Chrome’s insecure private‑network restrictions, with practical solutions and lessons learned.
This article explains how to fine‑tune PHP‑FPM by adjusting key settings in php‑fpm.conf and pool.d/www.conf, covering user/group, listen address, process management, child limits, timeout values, and provides a fully commented example configuration to improve backend performance and stability.
This article walks through a real‑world Nginx reverse‑proxy SSL issue, explains the root cause of 502 and handshake failures caused by missing SNI support, and provides step‑by‑step configuration changes and code snippets to resolve the problem.
This guide explains how to set up a gray‑release (canary) deployment using Nginx as a reverse‑proxy gateway, Docker containers for isolation, and two versions of a NestJS service, with traffic split controlled by cookies and configurable percentages.
This guide explains how to edit the nginx.conf file to configure the number of worker processes, determine appropriate values based on CPU cores and workload, and bind workers to specific CPU cores using worker_cpu_affinity, including practical command examples and considerations for blocking I/O.
This article provides a complete Nginx configuration example that proxies requests to an Alibaba Cloud OSS domain, adds the client’s real IP via the X-Real-IP header, enables gzip compression, and includes detailed comments and logging settings.
This article walks through installing Nginx on CentOS, configuring DNS across three servers, applying common Nginx hardening techniques such as version hiding, log rotation, connection keep‑alive tuning, image caching, and implementing anti‑hotlinking to protect site resources.
This guide explains why nginx logs grow, introduces Logrotate as the Linux log‑management tool, walks through installation, core configuration, custom rotation rules, manual execution, compression options, time‑ and size‑based policies, hourly scheduling, and handling SELinux when rotating nginx logs.
This guide explains how to configure Nginx to block malicious IPs, mitigate DDoS attacks, limit request rates and body size, and prevent SQL injection and XSS attacks by using blacklist files, conditional rules, connection and request limits, and security headers.
This guide walks you through deploying backend services with Docker Desktop, from installing Docker and pulling an Nginx image to configuring ports, volumes, and environment variables, then shows how to create and build a custom Dockerfile for persistent containerized applications.
This article walks through the root causes of CORS errors when a front‑end site on port 8080 calls a back‑end service on port 59200, explains the four essential CORS response headers, demonstrates common error scenarios, and provides complete Nginx configuration snippets—including handling pre‑flight OPTIONS requests, custom headers, and method allowances—to reliably eliminate cross‑origin problems.
This step‑by‑step tutorial explains how to install and configure Nginx for free, create a simple website, start the server, and use a free tunneling service to expose the site to the internet without paying for hosting or a domain.
Learn step‑by‑step how to create an Nginx configuration file, use AWK and shell scripts to detect IPs with more than 60 requests per minute, automatically generate deny rules, and schedule the process with crontab to keep your personal site safe from attacks.
The article explains Apache's three MPMs (prefork, worker, event), how Nginx's event‑driven architecture and epoll model improve concurrency handling, and provides performance comparisons showing Nginx handling tens of thousands of connections with far lower memory usage than Apache.
This article explains how Docker can create isolated, reproducible local development environments, outlines its advantages, guides through installation pitfalls like WSL2 kernel updates and BIOS virtualization settings, and demonstrates running an Nginx container while highlighting further challenges such as file mapping and custom Dockerfile creation.
This guide explains why Nginx proxying to an HTTP backend causes the browser URL to change, how to fix the redirect by using HTTPS, and how to achieve session consistency across multiple Tomcat instances by integrating Memcached for shared session storage.
This tutorial explains what a PHP container is, why containers are useful for modern DevOps, and provides step‑by‑step instructions—including Dockerfile creation, image building, and container execution—to package a PHP 7.4 application with Nginx using Docker.
In this article we walk through five successive optimizations—adding Redis caching, scheduling asynchronous jobs, introducing local Caffeine cache, enabling Nginx GZip compression, and slimming Redis data—to dramatically improve the performance of a SpringBoot‑Thymeleaf classification‑tree query, reducing response size from 1 MB to 100 KB and raising QPS from 100 to over 500.
This tutorial walks you through downloading, installing, configuring, and launching Nginx on an old computer, adding a simple HTML page, and exposing the site to the internet using a free tunneling service, all with clear screenshots and code examples.
This article explains how to secure an Nginx web server by configuring rate limiting, restricting access to sensitive directories, mitigating DDoS attacks, and strengthening SSL/TLS settings, providing detailed code examples and annotations for each security measure.
This guide explains why and how to configure NGINX to force browsers to download files instead of displaying them, covering simple header settings, regex‑based filename handling, location priority rules, and the necessary reload command.
Learn how to configure NGINX to force browsers to download files instead of displaying them, using Content‑Disposition headers, regex location blocks, and proper MIME handling to reduce server load and handle IE quirks.
This guide explains how to optimize NGINX on Linux by adjusting worker processes, connection limits, GZIP compression, timeout values, buffer sizes, log handling, static content caching, and open file caching, providing step‑by‑step commands and configuration snippets for maximum server efficiency.
This guide introduces Nginx’s essential configuration blocks, explains how to set up reverse proxy, outlines six load‑balancing strategies, demonstrates static‑dynamic content separation, and provides common directives such as return, rewrite, error_page, logging, and access control for beginners.
This article walks readers through downloading and installing Nginx, configuring the server, launching the service, creating a basic HTML page, and using a free tunneling tool to make the site accessible from the internet, while also including promotional links to related resources.
This article explains the meaning of HTTP 502 Bad Gateway errors, how reverse proxies like nginx generate them, common causes such as premature connection termination, server crashes, misconfigured upstreams, and practical steps to diagnose and fix the problem.
The article compares Nginx and Apache, showing how Nginx’s event‑driven, single‑threaded architecture and efficient use of memory and I/O allow it to handle tens of thousands of concurrent connections with far lower resource consumption than Apache’s prefork or worker models.
This guide walks through identifying where packet loss occurs in the Linux network stack, using tools like hping3, netstat, tc, iptables and tcpdump, and demonstrates step‑by‑step fixes such as removing netem rules, adjusting MTU and verifying HTTP responses.
This article outlines a comprehensive flash‑sale system architecture covering front‑end separation, Nginx static handling, traffic shaping, Redis caching and locking, message‑queue throttling, database sharding, and captcha mechanisms to achieve high concurrency while ensuring security and reliability.
This article provides a collection of ready‑to‑run Bash scripts that cover disk partition creation, server initialization, real‑time network traffic monitoring, Nginx log rotation and analysis, disk usage alerts, MySQL backups, process counting with zombie termination, and automated blocking of malicious IPs, offering a practical toolkit for Linux system administrators.
This tutorial introduces Nginx Proxy Manager, a visual reverse‑proxy management interface, and provides step‑by‑step instructions for installing it via Docker‑Compose, configuring domains, setting up SSL with Let’s Encrypt, and managing proxy hosts through its web UI.
This article traces the evolution of Java web architectures from early JSP/Servlet projects to modern SpringBoot+Vue stacks, explains Nginx’s role as a high‑performance reverse proxy, details server name matching, load‑balancing strategies, static‑dynamic separation, and URL rewrite techniques with practical configuration examples.
This article explains how to configure Nginx to split access logs by day using the $time_iso8601 variable, align log timestamps with the local timezone via Docker‑Compose or Dockerfile settings, and introduces the GoAccess tool for visual log analysis.
This tutorial shows how to enable Nginx's stub_status module, install the Nginx Prometheus Exporter, configure Prometheus to scrape Nginx metrics, and visualize the data in Grafana, providing a complete end‑to‑end monitoring solution.
This article describes how to identify abnormal Nginx requests caused by bots like AhrefsBot and Scrapy, and provides a step‑by‑step Docker‑based solution that includes a custom Nginx configuration, agent‑deny rules, and optional Alibaba Cloud security‑group IP blocking to prevent memory spikes.
This step‑by‑step tutorial shows how to configure Alibaba mirrors, install PHP 8.2, Nginx, MySQL 8, Redis 6 and Composer on Ubuntu 20.04, adjust PHP‑FPM settings, create a test PHP file, start services, and verify the full LEMP stack works within about 20 minutes.
This article explains Java rate‑limiting fundamentals, covering time‑window and resource dimensions, common algorithms such as token bucket, leaky bucket and sliding window, and practical solutions using Guava, Nginx, Redis, Sentinel, and Tomcat for both single‑node and distributed environments.
This article explains how to design an effective multi‑level caching system for microservice environments, covering client‑side static resource caching, application‑layer CDN caching, and service‑layer Redis caching, and provides practical Nginx configuration examples to implement these caches.
This step‑by‑step guide explains what a Raspberry Pi Zero W is, how to flash Raspbian onto a micro‑SD card, configure Wi‑Fi and SSH, optimize the system, install Nginx, and expose the device to the internet using ngrok, all with clear images and code snippets.
This extensive tutorial walks through Nginx concepts, environment setup, reverse‑proxy load balancing, static‑dynamic separation, resource compression, buffering, caching, IP whitelist/blacklist, CORS handling, anti‑hotlinking, large‑file configuration, SSL certificate setup, high‑availability with Keepalived, and key performance optimizations.
nginxWebUI provides a graphical interface for configuring and managing Nginx, supporting HTTP/TCP forwarding, reverse proxy, load balancing, SSL automation, multi‑server clustering, Docker deployment, systemd startup, and detailed usage instructions, enabling administrators to generate and control nginx.conf without manual coding.
This article provides a step‑by‑step guide to Docker, covering its core concepts, differences between virtual machines and containers, installation methods, Dockerfile syntax, building and running images, and best‑practice recommendations for containerized deployments.
The article explains Apache’s three processing models (prefork, worker, event), compares their resource usage with Nginx, and demonstrates how Nginx’s event‑driven, single‑threaded architecture achieves far higher concurrent connection capacity and better performance for web services.
This article presents nine useful Bash scripts that automate common Linux system administration tasks such as DOS attack mitigation, email alerts, MySQL backups, Nginx log management, network traffic monitoring, server initialization, and multi‑host disk usage checks.
This article explains how to set up a high‑availability Nginx service using Keepalived on two CentOS virtual machines, covering installation, configuration of keepalived, health‑check scripts, virtual IP management, and failover testing to ensure continuous service availability.
This guide walks through building and configuring NGINX 1.22 with OpenTracing and Jaeger, covering required dependencies, compiling gcc, cmake, jaeger-client‑cpp, and the nginx‑opentracing module, and shows how to set up tracing configuration and verify spans in Jaeger.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse proxy and various load‑balancing methods, configuring upstream directives, enabling SSL, and building high‑availability clusters using Keepalived and LVS with detailed command examples and configuration snippets.
Cloudflare engineers have rewritten a core Nginx module in Rust, creating the Pingora proxy to replace Nginx, improve performance and safety, and pave the way for a future backend infrastructure without Nginx, highlighting Rust’s security benefits for complex, high‑scale services.
This article explains why an Nginx reverse‑proxy configuration that proxies HTTPS requests to a backend server causes the browser URL to change, how to fix the redirect by using HTTPS in the proxy, and how to achieve session consistency across multiple Tomcat instances by deploying Memcached with Docker and adjusting Tomcat’s session manager.
This article explains how to design an effective multi-level caching system in a microservice environment, covering client‑side browser caching, application‑layer CDN and Nginx caching, and service‑layer in‑process and distributed caches, along with consistency strategies and practical deployment examples.
This guide walks through setting up a Jenkins container to build and deploy a Spring Boot application, creating Docker and Docker‑Compose configurations, integrating Nginx as a reverse proxy, and automating the CI/CD workflow with detailed scripts and best‑practice recommendations.
This guide provides a fully automated Bash script that downloads, verifies, compiles, installs, and configures Nginx as a systemd service on CentOS and Ubuntu systems, including dependency installation, service setup, and common management commands.
This extensive tutorial walks through Nginx fundamentals, environment setup, reverse‑proxy load balancing, static‑dynamic separation, resource compression, buffering, proxy caching, IP black‑white listing, anti‑hotlinking, large‑file handling, SSL configuration, high‑availability with Keepalived, and key performance‑tuning techniques for production deployments.
This article walks through installing Docker and Docker‑Compose, creating a project directory, writing a docker‑compose.yml that defines Redis, MySQL, Nginx, Java, and a file‑preview service, configuring each container, and using docker‑compose commands to build, start, monitor, and manage the full SpringBoot‑Vue application stack.
This extensive tutorial walks through installing Nginx from source, setting up environment, configuring reverse proxy load balancing, static resource handling, compression, buffering, caching, IP black‑white lists, anti‑hotlinking, large file transfer, SSL certificates, high availability with Keepalived, and advanced performance tuning techniques.
This guide explains why rotating Nginx access logs is essential for maintainability and demonstrates a straightforward shell script plus a cron job to split logs by day, ensuring smooth log management and easy analysis.
This guide walks you through creating a blockip.conf file, integrating it into Nginx, using AWK to detect IPs with over 60 requests per minute, writing a shell script to generate deny rules, and scheduling the process with cron for automatic IP blocking.
This article provides an in‑depth tutorial on Nginx, covering installation on Linux, core configuration directives, server name and location matching, reverse proxy setup, various load‑balancing algorithms, caching strategies, HTTPS setup, CORS handling, gzip compression, and an overview of Nginx's process architecture and module system.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse proxy and various load‑balancing methods, configuring upstream directives, deploying Keepalived for high‑availability failover, and building an LVS‑DR cluster to achieve robust, production‑grade traffic distribution.
This article introduces nginxWebUI, a web‑based graphical interface for managing Nginx configurations, explains its technical architecture, provides step‑by‑step installation instructions for jar, Docker and systemd service on Linux, and demonstrates how to use the UI for HTTP, TCP, SSL, load‑balancing, and remote server management.
This guide explains the fundamentals of distributed file systems, compares them with traditional storage, introduces MinIO’s architecture and features, and provides step‑by‑step instructions for deploying a multi‑node MinIO cluster with Nginx load balancing on Linux.
This guide walks developers through installing a Baota panel, configuring Nginx, creating a dedicated git user with bare repositories and post‑receive hooks, initializing and generating a Hexo blog locally, pushing it via the hexo‑deployer‑git, setting up an image host and Nginx reverse proxy, and backing up the project for quick deployment on a lightweight Lighthouse server.
This guide provides a comprehensive walkthrough of nginxWebUI—a graphical web interface for configuring and controlling Nginx—including feature overview, installation via JAR or Docker, systemd service setup, command‑line options, SSL automation, backup management, API usage, and password recovery.
This article compares the main cloud‑native ingress gateway options—Nginx Ingress, Alibaba Cloud ALB, and Alibaba Cloud MSE—covering their architecture, exposure methods, configuration nuances, health‑check settings, reload behavior, and practical selection guidelines for Kubernetes deployments.
This guide explains the fundamental dimensions of rate limiting, compares token‑bucket, leaky‑bucket, and sliding‑window algorithms, and details practical implementations using Guava, Nginx, Redis, and Sentinel for both single‑node and distributed systems.
This article explains the key features of HTTP/2—including binary framing, header compression, flow control, multiplexing, request priority, and server push—alongside TLS 1.3 enhancements, ECC advantages, and Brotli compression, and provides practical Nginx configuration steps to leverage all of them for faster, more secure web delivery.
This article introduces a highly recommended open‑source Nginx visualization project, outlines its core features such as configuration management and performance monitoring, provides step‑by‑step installation and deployment instructions for Linux, and shares the source code location along with remaining challenges.
To prevent repeated logins in distributed microservice systems, this article explains four session‑sharing solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based session caching, and cookie‑based storage—detailing their principles, configuration examples, and advantages and disadvantages.
Learn how systemd replaces traditional init on modern Linux, its key features, command syntax, unit file structure, and step-by-step hands-on examples that show how to create and control systemd services for Nginx, Tomcat, and custom Java JAR applications using systemctl.
This guide explains how to turn a low‑cost Raspberry Pi into a Wi‑Fi hotspot, DHCP/DNS server, and offline PyPI mirror using minirepo, pypiserver, and nginx, enabling client devices to install Python packages without Internet access.
This guide explains what systemd is, its key advantages over traditional init, the basic systemctl syntax, how unit files are structured, and provides step‑by‑step examples for creating systemd services to manage Nginx, Tomcat, and a custom Java JAR application on CentOS 7 and similar Linux distributions.
