This guide walks operations engineers through a systematic, multi‑layered approach to identifying why static resources load slowly, covering data collection, network diagnostics, server configuration, application settings, client‑side checks, common failure scenarios, and automated monitoring scripts.
This guide explains how to split static and dynamic traffic with Nginx, outlines the architecture, showcases CDN caching, and provides concrete configuration tweaks such as sendfile, tcp_nopush, tcp_nodelay, gzip/brotli, and cache‑control to dramatically improve web performance and scalability.
This article explains how separating static and dynamic traffic with Nginx, configuring precise location rules, cache headers, and kernel optimizations can increase throughput by three to five times in high‑concurrency web architectures while reducing backend load and improving maintainability.
This article explains how Nginx can separate static assets from dynamic requests using location rules and reverse‑proxying, provides a complete configuration example, and details the performance gains from zero‑copy file serving, gzip compression, caching headers, and CDN integration.
This article explains the principle of Nginx static‑dynamic separation, shows how to configure location blocks and caching for static assets, and demonstrates how proxying dynamic requests to backend servers can reduce response time from 200 ms to 50 ms, increasing QPS several‑fold.
This guide walks backend engineers through configuring Nginx for reverse proxy, load balancing, static‑resource handling, rate limiting with IP blacklists, and HTTPS encryption, providing ready‑to‑use code snippets and practical deployment steps to keep services stable and secure.
This guide walks backend engineers through six real‑world Nginx configurations—reverse proxy and load balancing, static asset handling, rate limiting with IP black/white lists, HTTPS encryption, and step‑by‑step deployment—showing how to secure, accelerate, and stabilize services.
This article explains the concept of static‑dynamic separation in web architecture, outlines its performance and maintenance benefits, and provides detailed Nginx configuration examples—including location blocks for static assets, API proxying, and fallback routing—to illustrate how to implement the technique effectively.
This article explains how Nginx static‑and‑dynamic separation works, why it dramatically improves response speed and concurrency, and provides complete configuration examples for serving static assets, proxying dynamic requests, and integrating caching, CDN and load‑balancing for optimal web performance.
The article explains how to build a custom Webpack plugin that uploads compiled static assets to a CDN, rewrites public‑path references to CDN URLs, and employs a hash‑based cache file to skip unchanged files, cutting build time from 40 seconds to 17 seconds in large projects.
The article explains why static assets of a single‑page frontend application disappear after a container restart, analyzes the root cause, and presents a practical solution that stores assets on an external file server or CDN while keeping only index.html inside the container, thereby eliminating 404 errors caused by missing resources.
Since Go 1.16, the //go:embed directive allows developers to embed files, directories, or entire static assets directly into the compiled binary, simplifying deployment; this article explains the directive, its three embedding methods, usage in HTTP servers, unit tests, handling parent directories, and important considerations.
This short guide shows a regular‑expression rule for Fiddler that blocks common static resources such as CSS, JavaScript, images, icons and audio files, and provides a link to a Chinese‑language Fiddler localization package.
Tencent Video slashed static image bandwidth costs by over 60% using AVIF compression and on‑the‑fly image sampling, which together cut average image size by more than half, reduced memory, latency and decode time, and saved tens of millions of yuan across billions of daily requests.
This guide explains Nginx rewrite syntax and flags, provides practical rewrite examples, demonstrates how to configure anti‑hotlinking, outlines static‑dynamic resource separation with caching, and shows step‑by‑step installation and configuration of Keepalived for high‑availability Nginx clusters, including required scripts and host settings.
The article recounts a real‑world CDN failure that broke the passjava.cn site, explains what a CDN is, and details step‑by‑step recovery actions—including downloading assets, using alternative storage, and refreshing a new CDN—to get the site back online.
A detailed post examines why the Xi’an health‑code service collapsed, showing that the lack of CDN for static assets and the resulting 125 Gbps bandwidth demand at 33 k QPS overwhelmed a single data‑center link, rather than any server‑side QR‑code generation issue.
This article explains why H5 pages still need performance attention in modern mobile‑first products and provides a detailed, Baidu‑cloud‑CDN based solution—including background, problem analysis, configuration steps, precautions, and measurable speed‑up results—for accelerating static assets such as CSS, JS, and images.
This article walks through Vite's five static asset handling strategies—including public directory paths, import queries like ?url, ?raw, and ?worker—showing code examples, middleware behavior, and build‑time transformations so developers can quickly understand and apply each method.
This guide shows how creating a same‑named repository with a Markdown README lets you customize the top of your GitHub profile, embed static assets, and use the space as a personal knowledge hub for developers.
Static and dynamic resource separation, commonly known as static‑dynamic separation, involves deploying static files (HTML, JavaScript, CSS, images) on a web server like Nginx while forwarding dynamic requests to a backend application server via reverse proxy, thereby improving static asset delivery speed and enabling parallel front‑end and back‑end development.
This guide walks you through setting up Nginx on CentOS, explains its core features such as event‑driven architecture, lightweight modules, and CPU affinity, then demonstrates practical scenarios like static asset serving, browser caching, cross‑origin handling, anti‑hotlinking, reverse proxy, load balancing algorithms, and proxy caching with detailed configuration examples.
This guide explains how to install Nginx on Linux, serve a built Angular/React/Vue frontend from the server's static directory, and configure Nginx as a reverse proxy to forward API requests to a backend service, completing the setup with a service restart.
The article explains the concept of static/dynamic separation, compares deployment methods such as Nginx and CDN, discusses domain strategies, outlines its benefits and drawbacks, and presents an architecture suitable for high‑traffic static content delivery.
This article explains the evolution of static asset management from simple overwrites to cache‑busting version strings, highlights the problems caused by version‑based updates in large web systems, and presents hash‑based filenames as an optimal solution to ensure reliable upgrades and efficient caching.
Using cookie‑free domains prevents browsers from sending unnecessary cookies with every static asset request, reducing network overhead and improving page load speed, especially on sites with many images, CSS, or JavaScript files.
This article explores how enterprise‑level web teams can move beyond classic Yahoo performance rules by using hash‑based static asset versioning, dependency‑driven templates, and smart bundling to reconcile engineering constraints with front‑end optimization goals.
