This article explains the common pain points of local development and provides a step‑by‑step guide on installing Docker, Docker‑Compose, and Laradock, configuring environment files, setting up Nginx and host entries, and running containers to create a consistent, portable development environment.
This guide walks through using Docker Compose to package and launch a complete full‑stack application—including a React front‑end, an Express back‑end, and a MariaDB database—with a single command, covering prerequisites, Dockerfiles, Nginx configuration, and runtime management.
This article introduces MinIO, a high‑performance, GNU‑AGPL‑licensed object storage compatible with Amazon S3, explains its core concepts such as buckets, drives, sets and erasure coding, and provides a detailed step‑by‑step guide for deploying a distributed MinIO cluster on Linux, including configuration, systemd service setup, Nginx load balancing, and client (mc) usage.
This article provides a step‑by‑step tutorial on configuring Nginx rewrite rules, implementing anti‑hotlinking protection, separating static and dynamic resources, and building a high‑availability architecture using Keepalived with detailed code examples and deployment instructions.
This article explains the common frustrations of setting up local development environments, introduces Docker as a portable container solution, and provides step‑by‑step instructions for installing Docker, Docker‑Compose, cloning Laradock, configuring environment files, Nginx, hosts, and running the containers for a Laravel project.
This comprehensive tutorial walks you through deploying a production‑grade Kubernetes cluster on multiple nodes, configuring Docker and containerd, setting up kubeadm, enabling IPVS, installing a high‑availability Nginx + Keepalived load balancer, deploying the Kubernetes dashboard, and installing a secure Harbor image registry with NFS storage.
This guide explains how to pull, export, transfer, import, and run Docker images without network access by using two servers, illustrating the process with the nginx:1.21.6 image and detailed Docker commands.
This article presents a comprehensive design and implementation of a high‑concurrency train‑ticket flash‑sale system, covering distributed architecture, load‑balancing strategies, Nginx weighted round‑robin configuration, Go‑based services, Redis‑backed stock management, and performance testing results.
This article provides a step‑by‑step tutorial on understanding Raspberry Pi Zero W, preparing the hardware, flashing the Raspbian image, configuring SSH and Wi‑Fi, installing nginx, enabling remote access via ngrok, and optimizing the system for lightweight web hosting.
The guide shows how to deploy an Nginx container with Docker, configure it to proxy a custom domain to a SpringBoot microservice registered in Nacos, add a Spring Cloud Gateway upstream, and route all requests through Nginx, simplifying access and eliminating CORS issues.
This article explains the principle of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then delves into distributed rate‑limiting dimensions, common algorithms like token‑bucket and leaky‑bucket, and concrete implementations using Guava, Nginx, Redis and Lua with full code examples.
This guide walks through creating an Nginx deployment on Kubernetes, exposing it via a NodePort service, generating the corresponding YAML configuration, performing dynamic scaling tests, and using various kubectl commands to manage resources and namespaces.
This comprehensive guide explains how to configure Nginx as a static file server, set up location mappings, implement reverse proxying, apply various load‑balancing strategies, use custom variables, and manage directives such as rewrite, return, error_page, logging, and access control.
This article provides a comprehensive tutorial on configuring Nginx as a static file server, setting up location mappings, implementing reverse proxy, various load‑balancing strategies, dynamic‑static separation, and essential directives such as return, rewrite, error_page, logging, and access control.
This guide shows how to repurpose an old Android phone into a functional web server by installing Termux, configuring SSH with Dropbear, setting a static IP, installing Ruby, Sinatra, Puma and nginx, enabling port forwarding, dynamic DNS, and performing basic load testing and security considerations.
This article walks through a real‑world case of a private‑cloud service experiencing 504 and 499 errors due to cross‑continent latency, detailing step‑by‑step troubleshooting, log analysis, Nginx timeout parameter tuning, SLB configuration changes, and key concepts behind Nginx error codes and proxy settings.
This article explains Nginx's network design, showing how the master process only creates and binds listening sockets while worker processes each create an epoll instance, register events, and handle accept, read, and write operations, illustrating the complete flow from code snippets to multi‑process coordination.
Version 1.23.0 of the Nginx mainline branch introduces several internal API updates, header handling improvements, bug fixes for Vary and WWW‑Authenticate headers, SSL logging level adjustments, EPOLLRDHUP handling, and corrected caching behavior for Expires and Cache‑Control headers.
This comprehensive guide explains what Nginx is, its advantages, typical use cases, request handling, high‑concurrency model, forward and reverse proxy concepts, directory layout, key configuration directives, load‑balancing algorithms, rate limiting, health checks, gzip compression, and practical examples for virtual hosts and module management.
This guide walks through installing Nginx, explains essential directives such as listen, server_name, location and proxy_pass, demonstrates reverse‑proxy setups, details rate‑limiting and connection‑limiting modules, explores various upstream load‑balancing strategies, and covers performance‑tuning options like keepalive, gzip, and CORS handling.
This tutorial walks developers through installing Docker on Ubuntu, explains core concepts such as images, containers and repositories, and demonstrates practical tasks including pulling a hello‑world image, running nginx and MySQL containers, configuring network bridges, handling common errors, and building a custom Spring Boot image with a Dockerfile.
This article explains how to properly set file and process permissions for Nginx, PHP‑FPM, and MySQL on Linux servers, recommending the use of a dedicated www user group, showing configuration snippets, and illustrating how to verify running processes to enhance security and avoid permission‑related errors.
This article demonstrates how to set up an Nginx location block that proxies image requests to a PHP watermark service, provides a complete PHP Watermark class implementation, and shows a usage example for applying watermarks to images on the fly.
This guide explains how to use OpenResty’s Lua capabilities to replace Tomcat‑based Redis access with direct Nginx‑Redis integration, apply compression to reduce bandwidth, set up periodic cache refreshes, configure single‑worker timers, and manage cache settings via a signed backend API.
This article provides a comprehensive guide to Nginx, covering its core concepts, installation steps, key configuration sections, reverse‑proxy and load‑balancing examples, static‑dynamic separation, performance tuning, and high‑availability clustering for production environments.
The Netcraft April 2022 survey analyzes over 1.16 billion sites, 271 million domains and nearly 12 million web‑facing computers, revealing that nginx leads in market share while providers such as Cloudflare, OpenResty, Pepyaka and GHS show notable growth and shifts in the global web‑server landscape.
This tutorial explains how to prevent overseas IP addresses from reaching a website by installing the libmaxminddb-devel dependency, adding the ngx_http_geoip2 module to Nginx, upgrading to Nginx 1.18, configuring GeoIP2 database paths, mapping country codes, and returning a 404 response for foreign requests.
This comprehensive guide explains what Nginx is, its core features, typical use cases, ecosystem extensions, installation methods, detailed configuration examples—including HTTPS, redirects, static mapping, proxying, rate limiting, authentication, load‑balancing strategies, and security hardening—plus an overview of its architecture and source‑code layout.
This article explains how to secure cross‑data‑center traffic by applying TLS principles, setting up a private Certificate Authority, generating self‑signed certificates with OpenSSL, configuring mutual TLS (mTLS) on Nginx proxies for both HTTP and TCP streams, and verifying the setup with curl and redis‑cli commands.
This article explains how to use OpenResty with Lua to integrate Redis directly into Nginx for cache‑driven request forwarding, data compression, timed updates, single‑process scheduling, and configurable URL caching, thereby improving concurrency, reducing latency, and enhancing backend resilience.
This guide explains the principles of API idempotency using unique business IDs or token mechanisms, explores distributed rate‑limiting dimensions, compares token‑bucket and leaky‑bucket algorithms, and provides concrete implementations with Guava RateLimiter, Nginx configuration, and a Redis‑Lua script integrated into Spring Boot, including annotation‑based AOP for easy usage.
This guide explains how to configure and read Nginx access and error logs, covering log format definitions, file locations, log level settings, and practical commands for parsing log entries to troubleshoot server and application issues.
This article explains how Nginx can act as a reverse proxy, distribute traffic with various load‑balancing methods, serve static assets separately from dynamic back‑ends, and rewrite friendly URLs, providing clear configuration snippets for each technique.
This article explains how a large-scale customer service instant messaging platform uses clustered WebSocket services, Redis, Nginx load balancing, and message‑queue broadcasting to achieve real‑time, reliable message delivery and robust reconnection handling across multiple servers.
This article explains Nginx's network design, detailing how the master process only creates and binds listening sockets while multiple worker processes each create their own epoll instance, register events, and handle client connections through accept, connection initialization, and event‑driven I/O.
This article compares LVS and Nginx load balancing, explaining their layer differences, performance characteristics, configuration flexibility, health‑check capabilities, and typical use‑cases, while also discussing related concepts such as forward/reverse proxy, static‑dynamic separation, and practical deployment considerations.
This article explains how to secure cross‑data‑center traffic by encrypting it with TLS/mTLS, covering the principles of TLS, certificate authority roles, generating self‑signed certificates with OpenSSL, and configuring Nginx proxies for both HTTP and TCP streams to provide transparent encrypted channels without modifying applications.
This guide walks through setting up the GitLab CE repository, installing GitLab, generating SSL certificates, configuring GitLab and Nginx for HTTPS, and verifying access on a CentOS server using command‑line operations.
The article recounts a real‑world incident where a JSON POST from a front‑end domain triggered a cross‑origin 418 error because a Web Application Firewall’s XSS filter mistakenly blocked a JavaScript validator field, and after the security team modified the WAF rules the issue was resolved, highlighting systematic debugging and deep knowledge of DNS, Nginx, ingress, Tomcat and WAF layers.
This article explains key high‑concurrency web concepts such as QPS, throughput, and response time, then details traffic and server optimizations, load‑balancing strategies (L4/L7, Nginx, LVS), CDN fundamentals, process/thread/coroutine models, asynchronous I/O, PHP Swoole concurrency, and database caching techniques for scalable backend systems.
This guide walks through downloading, compiling, and installing Nginx from source on Linux, configuring dependencies, creating a systemd service, managing start/stop commands, understanding the directory layout, and setting up basic nginx.conf directives—including worker processes, connections, MIME types, and virtual host server_name patterns.
This step‑by‑step guide shows how to create a React project, build Docker images using slimmer base images, multi‑stage builds, and Nginx, reducing the final image size from over a gigabyte to just a few megabytes while keeping the app functional.
This guide introduces systemd, explains its key features and unit file syntax, and provides three hands‑on examples showing how to manage Nginx, Tomcat, and a custom JAR application with systemd on modern Linux distributions.
This step‑by‑step guide explains how to install Nginx, configure it for reverse proxy and load balancing, separate static and dynamic content, and achieve high availability with keepalived, while also covering Nginx’s architecture, thread model, and key configuration directives.
This guide provides a step‑by‑step tutorial on Nginx, covering its overview, single‑instance installation, reverse proxy setup, load‑balancing configuration, static‑dynamic separation, high‑availability clustering with keepalived, detailed configuration directives, and performance considerations, complete with command‑line examples and code snippets.
This guide walks you through installing the open‑source NginxConfig visual tool, configuring Node.js, generating Nginx configuration files for static and dynamic proxies, and deploying them on a Linux server to simplify backend operations.
Learn how to configure and read Nginx access and error logs, including defining log formats, setting file locations, customizing log levels, parsing log fields, and using command‑line tools to monitor logs in real time, with practical examples and best‑practice recommendations.
This article describes how Trip.com’s backend engineers introduced QUIC to the Trip.com App, redesigned the Nginx‑based server architecture for multi‑process deployment, solved connection‑migration challenges with a custom load‑balancing layer, and enabled 0‑RTT support using shared ticket keys, achieving roughly a 20% reduction in request latency.
This comprehensive guide walks developers through Nginx fundamentals, key features, installation on CentOS, essential commands, core configuration blocks, directive details, variable usage, upstream and proxy_pass setup, reverse proxy, load balancing strategies, caching, HTTPS, CORS, gzip compression, and the internal architecture, enabling you to confidently deploy and manage Nginx in production environments.
This article explains when cross‑origin problems occur due to the browser's same‑origin policy, describes the restrictions it imposes, and provides detailed Nginx add_header configurations—including specific and global examples—to enable Access‑Control‑Allow‑Origin and Access‑Control‑Allow‑Methods headers for CORS resolution.
This article explains how Nginx separates network responsibilities between its master and worker processes, detailing the creation of listening sockets, the use of epoll for event‑driven I/O, the initialization of modules, and the handling of client connections in a multi‑process environment.
This comprehensive guide explains Nginx's role as a high‑performance web and reverse‑proxy server, details its installation packages and step‑by‑step build process, breaks down the main nginx.conf sections, and demonstrates practical configurations for reverse proxy, load balancing, static‑dynamic separation, worker tuning, and high‑availability clustering.
This article introduces Nginx’s high‑performance architecture, explains its role as a web server, reverse proxy, and load balancer, walks through installation, core configuration, worker tuning, practical reverse‑proxy and load‑balancing examples, and demonstrates building a high‑availability cluster with Keepalived.
This article explains Nginx's multi‑process design, detailing how the master process handles socket binding and listening while each worker creates its own epoll instance, registers events, and processes connections through a well‑structured event loop with code examples from the source tree.
This guide explains how to enable the nginx‑status module, configure Nginx to expose metrics, collect them with Telegraf, store them in InfluxDB, and visualize the data in Grafana, providing a complete end‑to‑end monitoring solution for Nginx servers.
NginxWebUI is an open‑source web‑based interface that simplifies Nginx configuration, offering features such as HTTP/TCP forwarding, SSL certificate automation, multi‑server management, Docker deployment, and a REST API, while providing step‑by‑step installation commands for Ubuntu and container environments.
This article details the design, architecture, key technologies, and deployment of Xiaosi, an AI‑powered intelligent customer service chatbot built on the internal IM platform, highlighting its problem‑diagnosis accuracy, manpower savings, adapter mechanism, high‑availability backend, and practical use cases.
The article discusses how to achieve interface idempotency using unique business identifiers or token mechanisms, then explores distributed rate limiting by outlining its dimensions, common algorithms such as token bucket and leaky bucket, and provides concrete implementation examples with Guava RateLimiter, Nginx, and Redis‑Lua scripts.
This article details a step‑by‑step investigation of an intermittent white‑screen problem on a web application, revealing that Nginx’s use of HTTP 1.0 short connections caused mismatched static resource versions across backend servers, and explains how updating the affected server’s frontend bundle resolves the issue.
This guide walks you through installing Nginx from source, configuring reverse‑proxy and various load‑balancing methods, setting up Keepalived for high‑availability, and integrating LVS (DR, NAT, TUN modes) to create a robust, fault‑tolerant web service architecture on Linux.
This article provides a set of Bash scripts for Linux server administration, including DDoS IP blocking, email alert configuration, MySQL backup (single and multi-loop), Nginx log rotation and analysis, network interface traffic monitoring, system initialization, and disk usage monitoring across multiple servers.
This article explains the fundamentals of cross‑origin restrictions, cookies, and same‑origin policy for frontend developers, demonstrates common CORS errors with sample code, and presents practical solutions—including iframe/postMessage, JSONP, WebSocket, and CORS configurations on servers such as Node.js and Nginx—to enable secure and reliable cross‑domain communication.
This article provides a comprehensive guide to Nginx, covering its high‑performance architecture, reverse‑proxy concepts, load‑balancing strategies, static‑dynamic separation, installation commands, configuration file structure, practical reverse‑proxy and load‑balancing examples, and high‑availability setup with Keepalived.
Learn to protect your server from malicious crawlers by creating a dynamic IP blacklist using Nginx, Lua, and Redis, covering architecture choices, installation steps, configuration snippets, and how to share and update the blacklist across multiple machines.
This article explains why Kubernetes clusters need an ingress point, compares NodePort, LoadBalancer, and Ingress solutions, introduces Ingress Providers, details Nginx and Alibaba Cloud MSE Ingress Controllers, and provides a step‑by‑step tutorial for deploying services and Ingress resources on an ACK cluster.
This step‑by‑step guide shows how to set up a Raspberry Pi Zero W with Raspbian Lite, enable headless SSH, configure Wi‑Fi, install Nginx, and expose the server to the public internet using Ngrok, turning a credit‑card‑sized board into a functional web host.
This article explains various cache layers—from browser and client caches to CDN, reverse‑proxy, local (disk, CPU, application) and distributed caches—detailing their mechanisms, use cases, common strategies, hit‑rate monitoring, and typical challenges such as penetration, breakdown, avalanche, and consistency.
This guide walks through deploying static files with Nginx, configuring location blocks and regex patterns, setting up reverse proxy to Java services, implementing various load‑balancing strategies (round‑robin, weight, ip_hash, fair, url_hash), separating static and dynamic content, and using essential directives such as return, rewrite, error_page, logging, deny, and built‑in variables.
This article explains how to achieve interface idempotency using unique business IDs or token mechanisms and presents comprehensive distributed rate‑limiting techniques—including token‑bucket and leaky‑bucket algorithms, Nginx directives, Guava RateLimiter, and Redis‑Lua scripts—along with practical Spring Boot code examples.
nginxWebUI is a web‑based graphical interface that simplifies configuring, managing, and deploying Nginx—including HTTP/TCP forwarding, reverse proxy, load balancing, SSL certificate automation, and multi‑server cluster support—while providing Docker images and detailed installation steps for Linux, Windows, and macOS environments.
The authors upgraded the Mahimahi record‑and‑replay framework by replacing Apache with modular Nginx, adding native HTTP/2 support and integrating a QUIC module (via quiche), enabling replay of captured traffic under modern protocols, precise network condition control and open‑sourcing the extensions for reproducible performance experiments.
After migrating to a PaaS platform, intermittent 502 errors appeared on both GET and POST requests, and a detailed analysis of Nginx retry behavior, Ingress HTTP version settings, and uWSGI incompatibility reveals the root cause and a configuration fix.
This comprehensive guide explains what Nginx is, its key advantages, typical use cases, request processing flow, high‑concurrency model, proxy types, directory layout, configuration directives, load‑balancing strategies, rate‑limiting, compression, health checks, and differences from Apache, providing practical examples and code snippets for backend developers.
This guide walks through setting up an ELK stack to collect, parse, and visualize Nginx access logs, covering Logstash configuration, Grok patterns, Elasticsearch setup, Nginx proxy with basic authentication, and creating Kibana dashboards for log analysis.
This cheat sheet compiles the most common Nginx configuration snippets—including listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, and SSL settings—providing a quick reference for developers and operators to set up high‑performance web servers.
This article compiles a collection of practical Bash scripts for Linux system administrators, covering automatic DDoS IP blocking, email alert setup, single‑ and multi‑database MySQL backups, Nginx log rotation and analysis, real‑time network traffic monitoring, server initialization, and bulk disk‑usage checks across many hosts.
This guide walks through installing Nginx on Linux, configuring reverse‑proxy and various load‑balancing methods, setting up SSL, integrating Keepalived for high‑availability, and deploying LVS (DR mode) with ipvsadm to create a robust, fault‑tolerant web‑service cluster.
This article provides a comprehensive overview of Nginx, covering its definition, advantages, typical use cases, request processing flow, high‑concurrency design, proxy types, directory layout, key configuration directives, load‑balancing algorithms, rate‑limiting mechanisms, security features, and practical deployment tips for modern web services.
This article provides a step‑by‑step tutorial on installing Nginx, setting up reverse‑proxy and various load‑balancing methods, configuring SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command examples and configuration snippets.
This article explains how to design and implement a high‑concurrency ticket‑seckill system by analyzing the 12306 architecture, introducing multi‑layer load balancing, demonstrating Nginx weighted round‑robin configuration, and providing Go and Redis code to achieve stable, low‑latency ticket purchasing under massive simultaneous requests.
This guide walks you through selecting a low‑cost Raspberry Pi Zero W, flashing Raspbian Lite, enabling SSH and Wi‑Fi via boot‑partition files, configuring the system, installing Nginx, and exposing the site to the internet using ngrok, providing a compact, fully functional web‑hosting platform.
This step‑by‑step guide shows how to collect, parse, and visualize Nginx access logs using the ELK stack, configure Logstash pipelines, set up Elasticsearch indices, proxy Kibana through Nginx, and secure access with HTTP basic authentication.
Nginx, a high‑performance HTTP and mail proxy server, achieves near‑million QPS throughput through its multi‑process architecture, efficient CPU core utilization, and fine‑grained configuration options, and this guide explains its design, core processes, configuration syntax, common directives, and practical usage scenarios for developers and ops engineers.
The article recounts Igor Sysoev’s farewell from Nginx, outlines his pioneering role in creating the world’s leading web server, details the company’s growth, commercialisation, legal battles, and explains how his legacy will continue to shape internet infrastructure.
Learn how to enhance your Nginx server by creating custom 404 error pages, enabling and reading the stub_status module, increasing worker processes and connections, adjusting kernel limits, expanding header buffers, and configuring client-side caching for static assets, with step‑by‑step commands and examples.
This guide demonstrates multiple ways to gather Nginx access and error logs—directly with Filebeat to Elasticsearch, via Filebeat to Logstash then Elasticsearch, and using rsyslog to forward logs to Logstash—providing step‑by‑step configurations, code snippets, and visual illustrations for each method.
This tutorial walks through installing Nginx from source, setting up upstream reverse‑proxy groups, configuring various load‑balancing methods (weight, IP hash, URL hash, least connections), enabling SSL, deploying Keepalived for failover, and building an LVS‑DR high‑availability cluster with detailed command‑line examples.
This guide walks you through setting up a CI/CD environment on a CentOS server using Docker, Git, Java, and Jenkins, covering installation, configuration, plugin management, and practical examples such as building Docker images, deploying a React app with Nginx, and automating the entire pipeline.
This guide explains what virtual hosts are, how they work in Nginx, and provides step‑by‑step commands to create directory structures, test pages, server block configuration files, enable and disable sites, and verify the setup on a Linux server.
This article walks through the evolution from a single‑server Tomcat setup to a multi‑layer architecture using Nginx, a gateway, and LVS, explaining dynamic/static request separation, high‑availability strategies, and the performance trade‑offs that guide scalable backend design.
This roundup introduces Create React App 5 with Webpack 5 and Tailwind support, demonstrates how to use the express‑validator middleware in Express, highlights Pinia as a type‑safe Vue state manager, and points to a practical Nginx location configuration guide.
This article explains how to leverage OpenResty and Lua scripts to integrate Nginx with Redis for direct caching, compression, timed updates, request forwarding, and configurable URL management, thereby improving concurrency, reducing latency, and enhancing the resilience of backend web services.
This tutorial shows how to create a single‑page web app that displays the current date, weekday, and the number of days remaining until major holidays and the weekend, using FastAPI for the backend, Jinja2 for templating, and the zhdate library for lunar calendar conversion.
This guide explains how to keep Swagger annotations in sync with Yapi by generating a swagger.json file, exposing it via Nginx, and configuring Yapi’s automatic import, so that API documentation updates automatically after each code change without manual effort.
This guide walks you through Nginx fundamentals, reverse‑proxy concepts, load‑balancing techniques, static‑dynamic separation, cross‑platform installation steps, essential commands, and core configuration examples, equipping developers with the skills to deploy and manage a robust web server.
This guide explains the principles, installation via Helm, example deployments, authentication, URL rewriting, canary releases, TLS setup, TCP/UDP service exposure, and global configuration of the nginx-based ingress-nginx controller for Kubernetes clusters.
This guide demonstrates how to automate the installation, configuration, and service management of Nginx across multiple hosts using Ansible roles, detailing environment setup, directory structure, task definitions, and execution commands.
This article provides a step‑by‑step tutorial on preparing a CentOS environment, installing Nginx via the LNMP package, explaining core concepts such as epoll, lightweight design and CPU affinity, and detailing configuration examples for basic settings, static resources, caching, CORS, anti‑hotlinking, and proxy services.
This article compiles a practical Nginx cheat sheet covering listening ports, access logs, server names, static file serving, redirects, reverse proxy, load balancing, SSL settings, and a visual configuration tool, providing ready-to-use snippets for high‑performance web server setups.
This article provides a comprehensive overview of load balancing technologies—including LVS, Nginx, and HAProxy—detailing their architectures, operating modes, advantages, and drawbacks, and explains how to choose and configure them for high‑performance, scalable backend systems.
