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.
This article introduces the open‑source Nginx‑GUI tool, explains its configuration‑management and performance‑monitoring features, and provides a step‑by‑step tutorial—including download, file edits, Linux‑specific renaming, and server deployment—complete with code snippets and screenshots for users.
This article explains why Docker containers often stop right after starting, covering the role of PID 1, Linux init processes, daemonized services, and the container runtime architecture that determines container lifecycle.
This article provides a step‑by‑step tutorial on configuring Nginx as an HTTP server, static file server, reverse proxy, load balancer, and explains location matching, variable usage, and common directives such as return, rewrite, error_page, and access logging.
This comprehensive guide walks you through installing Docker and containerd, configuring yum repositories, setting up kubeadm/kubelet/kubectl, initializing a multi‑master Kubernetes cluster, enabling Flannel CNI and IPVS, building a Nginx‑Keepalived HA load balancer, deploying the Kubernetes dashboard, configuring NFS storage with a dynamic provisioner, and installing a secure Harbor image registry for private images.
This comprehensive tutorial walks through preparing multiple Linux nodes, installing Docker and containerd, setting up kubeadm, kubelet and kubectl, initializing a HA Kubernetes control plane, configuring Flannel networking, deploying the Kubernetes dashboard, installing Nginx + Keepalived for load balancing, setting up NFS with rsync, provisioning storage via Helm, and finally installing a secure Harbor image registry, all with detailed commands and configuration snippets.
This article explains how to achieve load balancing using Nginx, covering the concepts of hardware and software load balancers, various Nginx balancing algorithms with configuration examples, and a step‑by‑step guide to integrate Nginx with a SpringBoot application, test it, and handle common pitfalls.
This article explains why Nginx logs are critical, compares various log‑analysis tools, provides detailed installation and configuration steps for GoAccess, discusses selection criteria, and shares real‑world case studies that demonstrate how to extract valuable system and business insights from massive access logs.
This article provides an in-depth overview of Nginx, covering its core concepts, advantages, request handling, load balancing strategies, reverse proxy, static and dynamic resource separation, security, rate limiting, health checks, compression, and practical configuration examples for high‑performance web services.
This article explains why Docker containers often stop right after starting by examining the Linux PID 1 init process, the behavior of foreground versus daemonized commands in Dockerfiles, and how container runtimes like containerd‑shim and runc manage the container’s main process.
Nginx has announced two new releases—stable 1.22.1 and mainline 1.23.2—primarily addressing security vulnerabilities in the mp4 module while also introducing new variables, TLS session handling improvements, logging level adjustments, and several bug fixes and workarounds.
This comprehensive guide explains how to configure Nginx as an HTTP server, static file server, reverse proxy, and load balancer, covering directory setup, location matching rules, priority order, upstream strategies, and useful directives such as return, rewrite, error_page, logging and access control.
This article provides a step‑by‑step tutorial on configuring Nginx as an HTTP server, static file server, reverse proxy, load balancer, and explains location matching, priority rules, and useful directives such as return, rewrite, error_page, logging, and built‑in variables.
This step‑by‑step guide walks you through deploying a production‑grade Kubernetes environment, covering node preparation, Docker and containerd setup, kubeadm initialization, high‑availability configuration with Nginx and Keepalived, installing the dashboard, and setting up a private Harbor registry with NFS storage, all using cloud‑native best practices.
This guide explains Nginx load balancing concepts, compares hardware and software approaches, details various balancing algorithms with configuration examples, and shows how to integrate Nginx with SpringBoot for practical load‑balancing tests and deployment tips.
This article presents a comprehensive Java web application that combines movies, music, and books, built with Spring Boot, MyBatis, Redis, and Nginx, and provides detailed environment specifications, architecture diagrams, feature screenshots, and step‑by‑step deployment instructions.
This article introduces Nginx as a high‑performance web and reverse‑proxy server, explains its key features, walks through installation and startup steps, details the main nginx.conf sections, and demonstrates practical configurations for reverse proxy, load balancing, and static‑dynamic separation.
This article explains how to build a high‑concurrency ticket‑seckill system that can handle one million users buying ten thousand tickets simultaneously by using distributed load‑balancing, Nginx weighted round‑robin, Go‑based HTTP services, Redis atomic stock deduction, and practical performance testing.
This article explains how Nginx can be used to achieve various load‑balancing strategies—including round‑robin, least connections, IP hash, generic hash, random and least‑time—provides concrete upstream and server configuration examples, shows how to integrate Nginx with a Spring Boot application, and details testing procedures to verify balanced request distribution.
This article provides a detailed overview of Nginx, covering its lightweight architecture, high‑concurrency event‑driven model, common use cases such as static file serving, reverse proxy and load balancing, step‑by‑step configuration examples, and advanced topics like rate limiting, health checks, gzip compression, and high‑availability deployment.
This guide shows how to enable HTTPS on Nginx by either obtaining a free Alibaba Cloud SSL certificate—generating a CSR, submitting it, and configuring the server—or creating a self‑signed OpenSSL certificate with custom SANs, installing it, updating hosts, and verifying the secure connection.
This guide explains why and how to migrate Nginx Ingress or traditional micro‑service gateways to Alibaba Cloud's MSE cloud‑native gateway, covering security motivations, a five‑stage migration process, preparation steps, command‑line checks, CRD configuration, testing, and gradual SLB traffic shifting.
This article explains the common frustrations of setting up local development environments—dependency conflicts, environment variables, port clashes, and differing production setups—and shows how Docker, Docker‑Compose, and Laradock can provide a unified, fast, and reproducible solution for PHP/Laravel projects.
The article examines the Chengdu COVID‑19 testing system failure, analyzes its root causes such as oversized MySQL tables and insufficient load handling, and then presents a step‑by‑step high‑concurrency roadmap—including single‑machine, service‑database separation, caching, load balancing, read/write splitting, sharding, hardware and DNS load balancing—to help backend developers design scalable systems.
This guide walks you through using Docker‑Compose to orchestrate a React front‑end, an Express back‑end, and a MariaDB database, covering environment setup, Dockerfile creation, Nginx configuration, container building, and common pitfalls for seamless full‑stack deployment.
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.
