Skip to main content
Mapagam

52 SECTIONS · 1515 TOPICS

Nginx Roadmap

  1. Installing and Compiling Nginx

    1. 1. Installing from Package Managers
    2. Example: Verify Installation
    3. 2. Installing from Official Repository
    4. Example: Add Nginx Repo on Ubuntu
    5. 3. Compiling from Source
    6. Example: Configure with Custom Modules
    7. 4. Adding Custom Modules
    8. Example: Add OpenResty Module
    9. 5. Verifying Installation
    10. Example: Test Configuration
    11. 6. Understanding Build Configuration
    12. Example: Full Build Configuration
    13. 7. Installing Dynamic Modules
    14. Example: Enable Dynamic Module
    15. 8. Setting Up Service Management
    16. Example: Start Nginx Service
    17. 9. Configuring Auto-start
    18. Example: Enable Auto-start on Boot
    19. 10. Installing on Docker
    20. Example: Run Nginx in Docker
    21. 11. Installing on Alpine Linux
    22. Example: Install Nginx on Alpine
    23. 12. Upgrading Nginx Binary
    24. Example: Upgrade via Package Manager

  2. Managing Nginx Service

    1. 1. Starting Nginx
    2. Example: Starting Nginx service
    3. 2. Stopping Nginx
    4. Example: Stopping Nginx via systemctl
    5. 3. Reloading Configuration
    6. Example: Reloading Nginx Configuration
    7. 4. Testing Configuration
    8. Example: Test Nginx Configuration
    9. 5. Checking Service Status
    10. Example: Check Nginx service status
    11. Example: Test Nginx configuration
    12. 6. Viewing Running Processes
    13. Example: Check Nginx Process Status
    14. 7. Sending Signals
    15. Example: Reload Nginx Configuration
    16. 8. Performing Graceful Shutdown
    17. Example: Graceful shutdown using signal
    18. Shutdown Process Overview
    19. 9. Reopening Log Files
    20. Example: Reopening Log Files
    21. 10. Understanding Master and Worker Processes
    22. Example: Master and Worker Process Configuration
    23. Key Points About Nginx Processes
    24. 11. Upgrading Without Downtime
    25. Upgrade Process
    26. Example: Performing a Zero-Downtime Reload
    27. 12. Managing Multiple Nginx Instances
    28. Example: Running Multiple Nginx Instances with Different Configs

  3. Working with Configuration Structure

    1. 1. Understanding Main Context
    2. 2. Locating Configuration Files
    3. Example: Default nginx.conf location
    4. 3. Using Include Directive
    5. Example: Including a Server Block Configuration
    6. 4. Organizing Configuration Files
    7. Example: Main nginx.conf structure
    8. Configuration Organization Best Practices
    9. Steps to Organize Configuration Files
    10. 5. Setting Global Directives
    11. Example: Setting Global Directives
    12. 6. Configuring Events Block
    13. Example: Basic Events Block Configuration
    14. 7. Understanding Configuration Hierarchy
    15. Example: Configuration Hierarchy
    16. 8. Using Configuration Variables
    17. Example: Defining and Using Variables
    18. Example: Using Variables in Conditions
    19. 9. Commenting Configuration
    20. Example: Using Comments in Nginx Config
    21. 10. Splitting Configuration into Modules
    22. Example: Including a Module
    23. Example: Server Configuration Module
    24. 11. Validating Configuration Syntax
    25. Example: Basic syntax validation
    26. Example: Test with specific config file
    27. 12. Understanding Directive Inheritance
    28. Example: Inheritance in Action
    29. Key Points

  4. Configuring HTTP Block

    1. 1. Setting MIME Types
    2. Example: Custom MIME Type
    3. 2. Configuring Access Logging
    4. Example: Basic Access Log Configuration
    5. Example: Custom Log Format
    6. Example: Using JSON Format for Logs
    7. 3. Configuring Error Logging
    8. Example: Basic Error Logging Configuration
    9. Example: Logging to Standard Error
    10. Example: Disabling Error Logging
    11. 4. Setting Charset
    12. Example: Setting Default Charset
    13. 5. Configuring Keepalive
    14. Example: Basic Keepalive Configuration
    15. 6. Setting Client Body Size
    16. Example: Setting client_max_body_size
    17. Example: Setting client_body_buffer_size
    18. 7. Configuring Buffer Sizes
    19. Example: Setting buffer sizes for large uploads
    20. 8. Setting Timeouts
    21. Example: Timeout Configuration
    22. 9. Configuring TCP Options
    23. Example: Enabling TCP optimizations
    24. 10. Setting Server Tokens
    25. Example: Disabling Server Tokens
    26. 11. Configuring Default Server
    27. Example: Default Server Configuration
    28. 12. Setting Real IP
    29. Example: Basic real IP configuration

  5. Creating Server Blocks

    1. 1. Defining Server Block
    2. Example: Basic Server Block Configuration
    3. 2. Configuring Listen Directive
    4. Example: Basic HTTP server block with listen directive
    5. Example: HTTPS server block with SSL listen directive
    6. 3. Setting Server Name
    7. Example: Basic server_name configuration
    8. 4. Using Wildcard Server Names
    9. Example: Wildcard server name configuration
    10. 5. Setting Default Server
    11. Example: Default Server Configuration
    12. 6. Configuring Multiple Server Blocks
    13. Example: Basic Multiple Server Blocks Setup
    14. Workflow: Enabling Multiple Server Blocks
    15. 7. Setting Root Directory
    16. Example: Setting Root Directory
    17. 8. Configuring Index Files
    18. Example: Setting Index Files
    19. 9. Using Server Name Matching
    20. Example: Basic server_name usage
    21. Example: Regex server_name
    22. 10. Setting Server-specific Variables
    23. Example: Setting Custom Variables
    24. 11. Understanding Server Block Selection
    25. Example: Matching server_name directive
    26. 12. Implementing Catch-all Server Block
    27. Example: Catch-all server block returning 444

  6. Working with Location Blocks

    1. 1. Defining Location Block
    2. Example: Basic Location Block
    3. Example: Exact Match Location Block
    4. 2. Understanding Location Matching
    5. Example: Location Priority
    6. 3. Using Exact Match
    7. Example: Exact Match Location Block
    8. 4. Using Prefix Match
    9. Example: Prefix Match Configuration
    10. 5. Using Regex Match
    11. Example: Case-sensitive regex match
    12. Example: Case-insensitive regex match
    13. 6. Using Case-Insensitive Regex
    14. Example: Case-Insensitive Location Match
    15. 7. Understanding Location Priority
    16. Example: Location Priority in Action
    17. 8. Using Preferential Prefix
    18. Example: Preferential Prefix Usage
    19. 9. Nesting Location Blocks
    20. Example: Nested Location Blocks
    21. Matching Priority
    22. 10. Setting Location-specific Directives
    23. Example: Using alias and root
    24. Example: Using try_files for fallback handling
    25. 11. Using Named Locations
    26. Example: Redirect to Named Location
    27. 12. Redirecting to Named Location
    28. Example: Redirecting to Named Location

  7. Using Nginx Variables

    1. 1. Understanding Built-in Variables
    2. Example: Using Variables in Location Blocks
    3. 2. Using Request Variables
    4. Example: Using Variables in Location Block
    5. Example: Logging Request Variables
    6. 3. Using Client Variables
    7. Example: Logging Client IP Address
    8. Example: Blocking Requests Based on User Agent
    9. 4. Using Server Variables
    10. Example: Logging Server Name
    11. 5. Using Upstream Variables
    12. Example: Logging Upstream Variables
    13. 6. Using SSL Variables
    14. Example: Logging SSL Variables
    15. Example: Redirecting Based on SSL Protocol
    16. 7. Using Time Variables
    17. Example: Logging with Time Variables
    18. 8. Creating Custom Variables
    19. Example: Setting a Custom Variable
    20. Example: Using Variables in Headers
    21. 9. Using Map Directive
    22. Example: Basic Map Usage
    23. Map Directive Summary
    24. 10. Using Geo Directive
    25. Example: Using geo with country code
    26. 11. Understanding Variable Evaluation
    27. Example: Using Variables in Location Blocks
    28. 12. Using Regex Captures in Variables
    29. Example: Capturing and Using URI Components
    30. Key Points

  8. Serving Static Content

    1. 1. Configuring Root Directory
    2. Example: Setting Root Directory
    3. 2. Using Alias Directive
    4. Example: Serving Images with Alias
    5. 3. Setting Index Files
    6. Example: Basic Index File Configuration
    7. 4. Enabling Directory Listing
    8. Example: Enabling Directory Listing
    9. 5. Customizing Autoindex
    10. Example: Enabling and Customizing Autoindex
    11. 6. Setting File Permissions
    12. Example: Setting File Permissions
    13. 7. Configuring Expires Headers
    14. Example: Setting Expires Headers for Static Assets
    15. Example: Using expires_by_type for Different Media Types
    16. 8. Adding Cache-Control Headers
    17. Example: Setting Cache-Control for Static Assets
    18. Example: Using expires with relative time
    19. 9. Serving Files with Try Files
    20. Example: Basic try_files usage
    21. Example: Fallback to 404
    22. 10. Handling Missing Files
    23. Example: 404 Error Page
    24. Example: Fallback to Index
    25. 11. Serving Pre-compressed Files
    26. Example: Serving pre-compressed files
    27. 12. Implementing Byte-Range Requests
    28. Example: Enabling Range Requests

  9. Implementing Rewrite Rules

    1. 1. Using Rewrite Directive
    2. Example: Basic Rewrite Rule
    3. Example: Rewrite with Capture Groups
    4. 2. Understanding Rewrite Flags
    5. Example: Using
    6. Example: Using
    7. 3. Using Return Directive
    8. Example: Simple 404 Response
    9. Example: Permanent Redirect
    10. 4. Implementing 301 Redirects
    11. Example: Basic 301 Redirect
    12. Example: Redirect with Capture Group
    13. 5. Implementing 302 Redirects
    14. Example: Basic 302 Redirect
    15. Example: Redirect with Regex Capture
    16. 6. Creating Conditional Rewrites
    17. Example: Conditional Redirect Based on User Agent
    18. Example: Conditional Rewriting Based on IP Address
    19. 7. Using Regex Captures
    20. Example: Capturing and Redirecting
    21. 8. Rewriting with Query String
    22. Example: Rewrite with Query String
    23. 9. Testing Conditions
    24. Example: Testing file existence
    25. Example: Testing directory existence
    26. Example: Testing file size
    27. Example: Testing file permissions
    28. Example: Testing symbolic links
    29. Example: Testing file type
    30. Example: Testing directory type
    31. Example: Testing file ownership
    32. Example: Testing file executable permissions
    33. Example: Testing file writable permissions
    34. Example: Testing file readable permissions
    35. Example: Testing file zero-length
    36. Example: Testing file not readable
    37. Example: Testing file not writable
    38. Example: Testing file not executable
    39. Example: Testing file not owned by current user
    40. Example: Testing file not a regular file
    41. Example: Testing file not a directory
    42. Example: Testing file not a socket
    43. Example: Testing file not a pipe or FIFO
    44. 10. Preserving Query Strings
    45. Example: Rewrite with Query String Preservation
    46. 11. Using Rewrite Log
    47. Example: Enabling Rewrite Logging
    48. 12. Understanding Rewrite vs Return
    49. Example: Using
    50. Example: Using
    51. Comparison:

  10. Working with Headers

    1. 1. Adding Custom Headers
    2. Example: Adding a Custom Header
    3. 2. Removing Headers
    4. 3. Setting Response Headers
    5. Example: Adding a Custom Header
    6. Example: Setting Cache Control
    7. 4. Using Always Parameter
    8. Example: Using
    9. Example: Using
    10. 5. Configuring CORS Headers
    11. Example: Basic CORS Configuration
    12. Example: CORS with Credentials
    13. 6. Setting Security Headers
    14. Example: Setting Security Headers in Nginx
    15. 7. Adding Content Security Policy
    16. Example: Setting CSP Header
    17. Example: CSP Report Only Mode
    18. 8. Setting Referrer Policy
    19. Example: Setting Referrer Policy
    20. 9. Configuring Permissions Policy
    21. Example: Setting Permissions Policy
    22. 10. Using Header Variables
    23. Example: Setting a Custom Header Based on a Query Parameter
    24. Example: Using a Request Header to Modify Response
    25. 11. Proxying Request Headers
    26. Example: Setting Forwarded Headers
    27. 12. Understanding Header Inheritance

  11. Handling Error Pages

    1. 1. Configuring Error Pages
    2. Example: Basic Error Page Configuration
    3. Example: Custom Redirect for 404 Errors
    4. 2. Setting Custom Error Pages
    5. Example: Custom 404 Page
    6. Example: Multiple Error Pages
    7. 3. Using Internal Redirects
    8. Example: Internal Redirect for 404 Errors
    9. 4. Handling Multiple Error Codes
    10. Example: Custom Error Page Configuration
    11. 5. Setting Error Page Response Code
    12. Example: Custom 404 Page with Redirect
    13. Example: Change 500 Error Code to 200
    14. 6. Using Named Locations for Errors
    15. Example: Using Named Locations for Error Handling
    16. 7. Proxying Error Pages
    17. Example: Basic Error Page Proxying
    18. Example: Proxying to Upstream Server
    19. 8. Configuring Recursive Error Pages
    20. Example: Basic Recursive Error Page Configuration
    21. Example: Recursive Error Handling with Custom Logic
    22. 9. Setting Default Error Responses
    23. Example: Basic 404 Error Page
    24. Example: Multiple Error Pages
    25. 10. Logging Error Details
    26. Example: Configuring Error Logging
    27. Example: Log Level Configuration
    28. Error Log Levels
    29. 11. Implementing Custom Error Templates
    30. Example: Basic custom error page setup
    31. Example: Custom 404 page with dynamic content
    32. Example: Using variables in error pages
    33. 12. Handling Upstream Errors
    34. Example: Custom Error Page for 502 Errors
    35. Example: Default Error Page for All Errors

  12. Implementing Reverse Proxy

    1. 1. Configuring Proxy Pass
    2. Example: Basic proxy_pass configuration
    3. Example: Proxying to Unix socket
    4. 2. Setting Proxy Headers
    5. Example: Configuring Proxy Headers
    6. 3. Forwarding Client IP
    7. Example: Configuring IP forwarding
    8. 4. Preserving Host Header
    9. Example: Setting Host Header
    10. 5. Configuring Proxy Buffering
    11. Example: Enabling proxy buffering
    12. 6. Setting Proxy Timeouts
    13. Example: Configuring Proxy Timeouts
    14. 7. Handling Proxy Redirects
    15. Example: Basic proxy_redirect usage
    16. Example: Using proxy_redirect with regex
    17. 8. Configuring WebSocket Proxying
    18. Example: Basic WebSocket Configuration
    19. 9. Using Upstream Variables
    20. Example: Using upstream variables in logs
    21. 10. Setting Proxy SSL
    22. Example: Basic SSL proxy configuration
    23. Example: Mutual TLS proxy configuration
    24. 11. Configuring Proxy Cache Key
    25. Example: Custom Cache Key
    26. 12. Understanding Proxy Buffer Sizes
    27. Example: Configuring proxy buffering

  13. Configuring Load Balancing

    1. 1. Defining Upstream Block
    2. Example: Basic upstream block
    3. Example: Upstream with weight and failover
    4. 2. Adding Backend Servers
    5. Example: Basic Upstream Configuration
    6. Example: Upstream with Weighted Servers
    7. 3. Using Round Robin
    8. Example: Round Robin Load Balancing Configuration
    9. 4. Configuring Least Connections
    10. Example: Least Connections Configuration
    11. 5. Using IP Hash
    12. Example: Basic IP Hash Configuration
    13. 6. Implementing Hash Method
    14. Example: Using ip_hash for session persistence
    15. Example: Using hash with custom variable
    16. 7. Setting Server Weights
    17. Example: Configuring server weights in an upstream block
    18. 8. Marking Servers as Backup
    19. Example: Backup Server Configuration
    20. 9. Setting Server as Down
    21. Example: Marking a server as down in an upstream block
    22. 10. Configuring Max Fails
    23. Example: Configuring max_fails and fail_timeout
    24. 11. Enabling Slow Start
    25. Example: Configuring Slow Start for a Backend Server
    26. 12. Using Keepalive Connections
    27. Example: Configuring Keepalive in Nginx

  14. Implementing Health Checks

    1. 1. Configuring Passive Health Checks
    2. Example: Basic Passive Health Check Configuration
    3. Example: Custom URI and Method
    4. 2. Setting Fail Timeout
    5. Example: Configuring proxy_next_upstream_timeout
    6. 3. Using Active Health Checks
    7. Example: Basic Active Health Check Configuration
    8. 4. Configuring Health Check Interval
    9. Example: Setting Health Check Interval
    10. 5. Setting Health Check URI
    11. Example: Basic Health Check URI Configuration
    12. Example: Custom Health Check URI with Parameters
    13. 6. Using Match Block for Conditions
    14. Example: Match block for URI pattern
    15. Example: Match block with method and header
    16. 7. Configuring Health Check Port
    17. Example: Configuring Health Check Port
    18. 8. Understanding Health Check States
    19. Example: Health Check Configuration
    20. 9. Monitoring Upstream Health Status
    21. Example: Basic Health Check Configuration
    22. Example: Advanced Health Check with Custom Parameters
    23. 10. Implementing Custom Health Endpoints
    24. Example: Basic Health Check Endpoint
    25. Example: Health Check with Status File
    26. 11. Configuring Health Check Passes
    27. Example: Basic Health Check Configuration
    28. Example: Custom Health Check Passes
    29. 12. Using Mandatory Health Checks
    30. Example: Basic Health Check Configuration
    31. Example: Advanced Health Check with Custom URI and Timeout

  15. Configuring FastCGI (PHP)

    1. 1. Setting FastCGI Pass
    2. Example: Basic FastCGI Pass Configuration
    3. 2. Configuring FastCGI Params
    4. Example: Setting FastCGI Parameters
    5. 3. Including FastCGI Config
    6. Example: Including FastCGI Config
    7. 4. Setting Script Filename
    8. Example: Setting SCRIPT_FILENAME
    9. 5. Configuring PHP-FPM
    10. Example: Basic PHP-FPM Configuration
    11. Example: PHP-FPM with TCP Socket
    12. 6. Setting FastCGI Index
    13. Example: Setting FastCGI Index
    14. 7. Configuring FastCGI Buffering
    15. Example: Enabling FastCGI Buffering
    16. 8. Setting FastCGI Timeouts
    17. Example: Setting FastCGI Timeouts
    18. 9. Using FastCGI Cache
    19. Example: Basic FastCGI Cache Setup
    20. Example: Cache Path Configuration
    21. 10. Splitting Path Info
    22. Example: Setting up path info splitting
    23. 11. Setting FastCGI Buffer Sizes
    24. Example: Configuring FastCGI Buffer Sizes
    25. 12. Configuring FastCGI Intercept Errors
    26. Example: Enabling FastCGI Error Interception

  16. Implementing uWSGI Support (Python)

    1. 1. Setting uWSGI Pass
    2. Example: Basic uWSGI Pass Configuration
    3. 2. Configuring uWSGI Params
    4. Example: Basic uWSGI Configuration
    5. 3. Including uWSGI Config
    6. Example: Basic uWSGI Configuration
    7. 4. Using Unix Socket
    8. Example: Nginx configuration with Unix socket
    9. 5. Setting uWSGI Timeouts
    10. Example: Configuring uWSGI Timeouts
    11. 6. Configuring uWSGI Buffering
    12. Example: Enabling uWSGI Post Buffering
    13. 7. Using uWSGI Cache
    14. Example: Basic uWSGI Cache Configuration
    15. 8. Setting uWSGI Buffer Sizes
    16. Example: Configuring uWSGI Buffer Settings
    17. 9. Handling uWSGI Errors
    18. Example: Error Log Configuration
    19. Example: uWSGI Log Configuration
    20. 10. Configuring uWSGI for Django
    21. Example: Basic uWSGI Configuration for Django
    22. 11. Configuring uWSGI for Flask
    23. Example: Basic uWSGI Configuration for Flask App
    24. 12. Implementing uWSGI Cache Zones
    25. Example: Basic uWSGI Cache Configuration
    26. Example: Advanced uWSGI Cache with Locking

  17. Implementing SCGI Support

    1. 1. Setting SCGI Pass
    2. Example: Basic SCGI Pass Configuration
    3. Example: SCGI Pass with Unix Socket
    4. 2. Configuring SCGI Params
    5. Example: Basic SCGI Configuration
    6. 3. Including SCGI Config
    7. Example: Basic SCGI Configuration
    8. 4. Using TCP Socket
    9. Example: Basic SCGI Configuration with TCP Socket
    10. 5. Setting SCGI Timeouts
    11. Example: Configuring SCGI Timeouts
    12. 6. Configuring SCGI Buffering
    13. Example: SCGI Buffering Configuration
    14. 7. Setting SCGI Buffer Sizes
    15. Example: Configuring SCGI Buffer Sizes
    16. 8. Handling SCGI Errors
    17. Example: Error Page Configuration

  18. Implementing WebSocket Support

    1. 1. Configuring Proxy for WebSocket
    2. Example: Basic WebSocket proxy configuration
    3. 2. Setting Upgrade Header
    4. Example: Configuring WebSocket Upgrade Headers
    5. 3. Setting Connection Header
    6. Example: Configuring WebSocket Headers
    7. 4. Using Map for Connection
    8. Example: Setting up a map for WebSocket connections
    9. 5. Setting WebSocket Timeouts
    10. Example: Configuring WebSocket timeouts
    11. 6. Configuring WebSocket with SSL
    12. Example: Basic WebSocket over SSL Configuration
    13. 7. Load Balancing WebSockets
    14. Example: Basic WebSocket Load Balancing Configuration
    15. Load Balancing Strategies for WebSockets
    16. 8. Handling WebSocket Keepalive
    17. Example: Configuring WebSocket Keepalive
    18. 9. Debugging WebSocket Connections
    19. Example: Basic WebSocket Proxy Configuration
    20. Common Debugging Steps
    21. 10. Using WebSocket with Subprotocols
    22. Example: Configuring WebSocket with Subprotocols
    23. 11. Implementing WebSocket Ping/Pong
    24. Example: Basic WebSocket Configuration with Ping/Pong
    25. 12. Handling WebSocket Disconnections
    26. Example: Basic WebSocket Configuration with Timeout Handling

  19. Implementing SSL/TLS

    1. 1. Enabling SSL
    2. Example: Basic SSL Configuration
    3. 2. Configuring SSL Certificate
    4. Example: Basic SSL Configuration
    5. 3. Setting SSL Private Key
    6. Example: Basic SSL Configuration
    7. 4. Configuring SSL Protocols
    8. Example: Enabling TLS 1.2 and 1.3
    9. 5. Setting SSL Ciphers
    10. Example: Configuring SSL Ciphers
    11. 6. Preferring Server Ciphers
    12. Example: Setting Preferred Ciphers in Nginx
    13. 7. Enabling SSL Session Cache
    14. Example: Configuring SSL Session Cache
    15. 8. Setting Session Timeout
    16. Example: Configuring SSL Session Timeout
    17. 9. Using OCSP Stapling
    18. Example: Enabling OCSP Stapling
    19. 10. Configuring HSTS
    20. Example: Basic HSTS Configuration
    21. Example: HSTS with Preload
    22. 11. Redirecting HTTP to HTTPS
    23. Example: Basic HTTP to HTTPS Redirect
    24. 12. Using SSL with SNI
    25. Example: Basic SNI Configuration

  20. Working with Let's Encrypt

    1. 1. Installing Certbot
    2. Example: Install Certbot on Ubuntu
    3. 2. Generating Certificates
    4. Example: Requesting a certificate using certbot
    5. Summary of Certificate Generation Steps
    6. 3. Using Webroot Authentication
    7. Example: Webroot Authentication Setup
    8. 4. Using Standalone Mode
    9. Example: Issuing a certificate in standalone mode
    10. 5. Configuring Auto-renewal
    11. Example: Setting up Auto-Renewal with Certbot
    12. Auto-Renewal Best Practices
    13. 6. Setting Renewal Hooks
    14. Example: Renewal Hook for Nginx Reload
    15. 7. Managing Multiple Domains
    16. Example: Nginx Configuration for Multiple Domains
    17. Workflow: Adding New Domain to Let's Encrypt
    18. Summary: Multiple Domains with Let's Encrypt
    19. 8. Using DNS Challenge
    20. Example: DNS Challenge Configuration
    21. 9. Configuring Certificate Paths
    22. Example: Basic SSL Configuration
    23. 10. Testing Certificate Renewal
    24. Example: Simulate renewal with certbot
    25. Testing Renewal Process
    26. 11. Using Wildcard Certificates
    27. Example: Requesting Wildcard Certificate
    28. 12. Revoking Certificates
    29. Example: Revoking a Certificate

  21. Implementing Advanced SSL

    1. 1. Configuring Client Certificates
    2. Example: Basic Client Certificate Configuration
    3. 2. Verifying Client Certificates
    4. Example: Enabling Client Certificate Verification
    5. 3. Extracting Client Certificate Info
    6. Example: Configuring Client Certificate Verification
    7. 4. Using Certificate Chain
    8. Example: Configuring SSL with Certificate Chain
    9. 5. Implementing OCSP Must-Staple
    10. Example: Basic OCSP Stapling Configuration
    11. 6. Configuring SSL Session Tickets
    12. Example: Enabling SSL Session Tickets
    13. 7. Using ECDH Curves
    14. Example: Configuring ECDH Curves in Nginx
    15. 8. Implementing Certificate Pinning
    16. Example: Enabling OCSP Stapling
    17. 9. Configuring Early Data
    18. Example: Enabling Early Data
    19. 10. Implementing Encrypted Client Hello
    20. Example: Enabling ECH in Nginx
    21. 11. Using Multiple SSL Certificates
    22. Example: Configuring Multiple Certificates
    23. 12. Monitoring SSL Certificate Expiry
    24. Example: Setting up SSL with OCSP Stapling
    25. Monitoring Certificate Expiry

  22. Implementing HTTP/2

    1. 1. Enabling HTTP/2
    2. Example: Basic HTTP/2 Configuration
    3. 2. Configuring HTTP/2 Push
    4. Example: Enabling HTTP/2 Push
    5. 3. Setting HTTP/2 Max Streams
    6. Example: Configuring HTTP/2 Max Streams
    7. 4. Configuring HTTP/2 Body Preread
    8. Example: Setting HTTP/2 Body Preread Size
    9. 5. Setting HTTP/2 Timeouts
    10. Example: Configuring HTTP/2 Timeouts
    11. 6. Optimizing HTTP/2 Performance
    12. Example: Configuring HTTP/2 Performance Settings
    13. Performance Tuning Tips
    14. 7. Understanding HTTP/2 vs HTTP/1.1
    15. Example: Enabling HTTP/2 in Nginx
    16. Key Benefits of HTTP/2
    17. HTTP/1.1 vs HTTP/2
    18. 8. Implementing Server Push Preload
    19. Example: Enabling Server Push Preload
    20. 9. Configuring HTTP/2 Idle Timeout
    21. Example: Setting HTTP/2 Idle Timeout
    22. 10. Setting HTTP/2 Max Requests
    23. Example: Configuring max requests
    24. 11. Using HTTP/2 with Proxied Backends
    25. Example: Basic HTTP/2 Proxy Configuration
    26. 12. Debugging HTTP/2 Connections
    27. Example: Using curl with HTTP/2

  23. Implementing HTTP/3 and QUIC

    1. 1. Enabling HTTP/3
    2. Example: Enabling HTTP/3 in Nginx
    3. 2. Setting QUIC Parameters
    4. Example: Configuring QUIC Parameters
    5. 3. Configuring Alt-Svc Header
    6. Example: Setting Alt-Svc Header
    7. 4. Understanding QUIC vs TCP
    8. QUIC vs TCP: Key Differences
    9. Example: Enabling HTTP/3 in Nginx
    10. 5. Configuring QUIC Active Connection
    11. Example: Enabling QUIC Active Connection
    12. 6. Setting QUIC Retry
    13. Example: Enabling QUIC Retry
    14. 7. Configuring QUIC GSO
    15. Example: Enabling QUIC GSO
    16. 8. Using 0-RTT with QUIC
    17. Example: Enabling 0-RTT with QUIC
    18. 9. Debugging QUIC Connections
    19. Example: Enabling QUIC Debug Logs
    20. Debugging Workflow
    21. QUIC vs TCP Debugging
    22. 10. Understanding HTTP/3 Limitations
    23. 11. Implementing HTTP/3 Fallback
    24. Example: Basic HTTP/3 Configuration with Fallback
    25. 12. Monitoring HTTP/3 Performance
    26. Example: Enabling HTTP/3 Performance Metrics in Nginx
    27. Key Metrics to Track

  24. Configuring Proxy Cache

    1. 1. Setting Up Proxy Cache Path
    2. Example: Basic proxy_cache_path configuration
    3. Key Parameters
    4. 2. Enabling Proxy Cache
    5. Example: Basic Proxy Cache Configuration
    6. 3. Setting Cache Validity
    7. Example: Setting cache validity for different response codes
    8. 4. Configuring Cache Key
    9. Example: Custom Cache Key
    10. 5. Bypassing Cache
    11. Example: Bypass cache based on user agent
    12. 6. Setting No Cache Conditions
    13. Example: proxy_no_cache with multiple conditions
    14. 7. Using Cache Lock
    15. Example: Enabling Cache Lock
    16. 8. Setting Cache Methods
    17. Example: Enabling Cache for POST Requests
    18. 9. Adding Cache Status Header
    19. Example: Adding Cache Status Header
    20. 10. Purging Cache
    21. Example: Purging Cache by URL
    22. Example: Purging Cache with Specific Key
    23. Key Points
    24. 11. Configuring Cache Revalidation
    25. Example: Configuring Cache Revalidation
    26. 12. Setting Cache Background Update
    27. Example: Enabling Background Update

  25. Implementing Microcaching

    1. 1. Setting Short Cache Times
    2. Example: Setting cache validity to 1 minute
    3. Example: Setting cache validity for different response types
    4. 2. Caching Dynamic Content
    5. Example: Basic Dynamic Content Caching
    6. Example: Caching with Stale Content Fallback
    7. 3. Using Cache Bypass for Logged-in Users
    8. Example: Bypass cache for logged-in users
    9. Example: Using a variable to control cache bypass
    10. 4. Configuring Stale Cache
    11. Example: Stale Cache Configuration
    12. 5. Setting Cache Lock Timeout
    13. Example: Configuring Cache Lock Timeout
    14. 6. Implementing Cache Warming
    15. Example: Basic Cache Warming Configuration
    16. 7. Using Edge Side Includes
    17. Example: Basic ESI Configuration
    18. Example: ESI with Substitution
    19. ESI Use Cases
    20. 8. Configuring Slice Module
    21. Example: Basic Slice Module Configuration
    22. 9. Setting Cache Vary Headers
    23. Example: Setting Vary Header for Content Encoding
    24. 10. Monitoring Cache Hit Ratio
    25. Example: Nginx Cache Metrics Configuration
    26. Cache Hit Ratio Monitoring Best Practices
    27. 11. Implementing Cache Stampede Prevention
    28. Example: Basic Cache Stampede Prevention with Nginx
    29. Key Points for Cache Stampede Prevention
    30. 12. Configuring Cache Min Uses
    31. Example: Setting proxy_cache_min_uses

  26. Enabling Compression

    1. 1. Enabling Gzip
    2. Example: Basic Gzip Configuration
    3. 2. Setting Gzip Compression Level
    4. Example: Setting Gzip Compression Level
    5. 3. Configuring Gzip Types
    6. Example: gzip_types configuration
    7. 4. Setting Minimum Length
    8. Example: Configuring gzip_min_length
    9. 5. Enabling Gzip Vary Header
    10. Example: Enabling Gzip Vary Header
    11. 6. Configuring Gzip Buffers
    12. Example: Setting Gzip Buffers
    13. 7. Disabling Gzip for IE6
    14. Example: Disabling Gzip for IE6
    15. 8. Using Gzip Static
    16. Example: Enabling gzip_static
    17. 9. Configuring Brotli Compression
    18. Example: Basic Brotli Configuration
    19. 10. Setting Brotli Quality
    20. Example: Brotli Compression Configuration
    21. 11. Configuring Brotli Types
    22. Example: Brotli Types Configuration
    23. 12. Understanding Compression Trade-offs
    24. Compression Algorithms Comparison

  27. Configuring Access Control

    1. 1. Allowing IP Addresses
    2. Example: Allow specific IP address
    3. Example: Allow IP range using CIDR
    4. 2. Denying IP Addresses
    5. Example: Deny specific IP address
    6. Example: Deny IP range
    7. 3. Using CIDR Notation
    8. Example: Restricting Access by CIDR
    9. 4. Setting Allow/Deny Order
    10. Example: Basic allow/deny configuration
    11. Order of Processing
    12. 5. Implementing HTTP Basic Auth
    13. Example: Basic Auth Configuration
    14. 6. Setting Auth User File
    15. Example: Basic Authentication Setup
    16. 7. Creating htpasswd File
    17. Example: Creating htpasswd File
    18. Example: Adding User to Existing File
    19. 8. Using Auth Request Module
    20. Example: Basic auth request configuration
    21. Example: Setting variables from auth response
    22. 9. Configuring Satisfy Directive
    23. Example: Using
    24. 10. Restricting by User Agent
    25. Example: Restricting access by user agent
    26. Example: Allowing only specific user agents
    27. 11. Implementing Token-based Authentication
    28. Example: Basic Token Authentication Setup
    29. Example: Token Authentication with Custom Header
    30. 12. Using Subrequest Authentication
    31. Example: Basic auth_request usage
    32. Example: Setting auth headers with auth_request_set

  28. Implementing Rate Limiting

    1. 1. Defining Limit Request Zone
    2. Example: Basic rate limiting zone
    3. Example: Rate limiting with burst
    4. 2. Applying Rate Limit
    5. Example: Basic Rate Limit Configuration
    6. 3. Setting Burst Parameter
    7. Example: Configuring Burst Limit
    8. 4. Using No Delay Option
    9. Example: Using nodelay in limit_req
    10. 5. Configuring Connection Limit
    11. Example: Basic Connection Limiting
    12. Example: Burst Connection Limiting
    13. 6. Applying Connection Limit
    14. Example: Configuring Connection Limits
    15. Key Points
    16. 7. Setting Rate Limit Status
    17. Example: Configuring 429 Status Code
    18. 8. Logging Rate Limit Events
    19. Example: Configuring Log Level
    20. Example: Custom Log Format
    21. 9. Using Multiple Rate Limits
    22. Example: Applying Multiple Rate Limits
    23. 10. Excluding IPs from Rate Limiting
    24. Example: Exclude Specific IPs from Rate Limiting
    25. Key Points
    26. 11. Implementing Dynamic Rate Limits
    27. Example: Dynamic Rate Limiting Configuration
    28. 12. Using Delay Parameter
    29. Example: Configuring rate limiting with delay

  29. Configuring Bandwidth Limiting

    1. 1. Setting Download Rate Limit
    2. Example: Configuring Download Rate Limit
    3. 2. Using After Limit
    4. Example: Configuring
    5. 3. Implementing Per-connection Limits
    6. Example: Setting Per-connection Bandwidth Limits
    7. 4. Using Variables for Dynamic Limits
    8. Example: Setting Dynamic Rate Limits
    9. Example: Using Variables in Map Block
    10. 5. Configuring Upload Limits
    11. Example: Setting Upload Size Limit
    12. 6. Setting Connection-based Throttling
    13. Example: Basic Connection Throttling
    14. Example: Connection Throttling with Custom Status
    15. 7. Implementing Fair Queuing
    16. Example: Fair Queuing Configuration
    17. Key Points
    18. 8. Using Map for Rate Tiers
    19. Example: Rate Limiting with Map
    20. 9. Monitoring Bandwidth Usage
    21. Example: Setting up bandwidth tracking zone
    22. Monitoring Bandwidth Usage
    23. 10. Implementing Burst Allowance
    24. Example: Configuring Burst Allowance
    25. 11. Configuring Limits per Location
    26. Example: Setting bandwidth limits for a location block
    27. 12. Using Conditional Bandwidth Limits
    28. Example: Conditional bandwidth limit based on user agent

  30. Configuring Logging

    1. 1. Setting Access Log
    2. Example: Basic Access Log Configuration
    3. Example: Custom Log Format
    4. 2. Setting Error Log
    5. Example: Basic error log configuration
    6. Example: Multiple error logs with different levels
    7. Log Levels
    8. 3. Defining Log Format
    9. Example: Custom Log Format Definition
    10. Common Log Format Variables
    11. 4. Using JSON Log Format
    12. Example: JSON Log Format Configuration
    13. 5. Disabling Logs
    14. Example: Disabling All Logs
    15. 6. Implementing Conditional Logging
    16. Example: Conditional Logging Based on Status Code
    17. Example: Custom Log Format with Conditional Fields
    18. 7. Setting Log Buffer
    19. Example: Setting Log Buffer Size
    20. Log Buffer Configuration Summary
    21. 8. Using Syslog
    22. Example: Syslog Configuration
    23. 9. Configuring Log Rotation
    24. Example: Basic Log Format Definition
    25. Example: Log Rotation with
    26. 10. Logging to Multiple Files
    27. Example: Logging to Multiple Files with Different Formats
    28. 11. Using Custom Variables in Logs
    29. Example: Defining and Using Custom Variables
    30. 12. Implementing Structured Logging
    31. Example: JSON Log Format
    32. Example: Structured Log with Custom Fields

  31. Implementing Security Best Practices

    1. 1. Hiding Nginx Version
    2. Example: Hide Nginx Version
    3. 2. Disabling Unwanted Methods
    4. Example: Restricting HTTP Methods
    5. 3. Preventing Clickjacking
    6. Example: X-Frame-Options DENY
    7. Example: Content-Security-Policy frame-ancestors
    8. 4. Enabling XSS Protection
    9. Example: Configuring XSS Protection Headers
    10. 5. Setting Content Type Options
    11. Example: Configuring X-Content-Type-Options
    12. 6. Configuring SSL Security
    13. Example: Basic SSL Configuration
    14. 7. Implementing HSTS
    15. Example: Basic HSTS Configuration
    16. Example: HSTS with Preload
    17. 8. Restricting File Access
    18. Example: Restricting Access to .env Files
    19. Example: Restricting Access to Configuration Files
    20. Example: Rate Limiting Requests
    21. 9. Securing Admin Paths
    22. Example: Basic Auth for Admin
    23. Example: IP Restriction for Admin
    24. Example: Rate Limiting for Admin
    25. 10. Preventing Buffer Overflow
    26. Example: Configuring Buffer Limits
    27. 11. Using Secure Headers
    28. Example: Setting Secure Headers in Nginx
    29. 12. Implementing DDoS Protection
    30. Example: Basic DDoS Protection Configuration
    31. Example: Rate Limiting with Different Zones
    32. DDoS Protection Strategies

  32. Implementing Advanced Security

    1. 1. Using ModSecurity WAF Integration
    2. Example: Basic ModSecurity Configuration
    3. Example: ModSecurity Rules File
    4. ModSecurity Integration Summary
    5. 2. Implementing Request Filtering
    6. Example: Rate Limiting Configuration
    7. Example: IP-Based Access Control
    8. 3. Blocking SQL Injection
    9. Example: Basic SQL Injection Blocking
    10. 4. Preventing XSS Attacks
    11. Example: Setting Security Headers
    12. XSS Prevention Techniques
    13. 5. Using Naxsi WAF Module
    14. Example: Basic Naxsi Configuration
    15. Example: Learning Mode Configuration
    16. Key Features of Naxsi
    17. 6. Implementing IP Reputation Blocking
    18. Example: Blocking IPs from Known Malicious Countries
    19. 7. Using Security Headers Bundle
    20. Example: Basic Security Headers Configuration
    21. Security Header Best Practices
    22. 8. Configuring Bot Protection
    23. Example: Basic Bot Protection Configuration
    24. 9. Implementing Request Validation
    25. Example: Rate Limiting Configuration
    26. Example: Geo-based Access Control
    27. 10. Using Encrypted SNI
    28. Example: Basic SSL Configuration
    29. 11. Hardening Worker Process
    30. Example: Hardened worker process configuration
    31. 12. Preventing Path Traversal Attacks
    32. Example: Secure File Serving with Root
    33. Example: Preventing Path Traversal with Alias
    34. Best Practices for Path Traversal Prevention

  33. Optimizing Performance

    1. 1. Setting Worker Processes
    2. Example: Setting worker processes to auto
    3. Example: Setting worker processes to 4
    4. 2. Configuring Worker Connections
    5. Example: Basic worker_connections configuration
    6. 3. Enabling Sendfile
    7. Example: Enabling sendfile
    8. 4. Using TCP Optimizations
    9. Example: Enabling TCP optimizations
    10. 5. Configuring Keepalive
    11. Example: Basic Keepalive Configuration
    12. Example: Disabling Keepalive for Specific Browsers
    13. 6. Setting Buffer Sizes
    14. Example: Configuring Buffer Sizes
    15. 7. Enabling Open File Cache
    16. Example: Basic Open File Cache Configuration
    17. 8. Using Gzip Compression
    18. Example: Enabling Gzip Compression
    19. 9. Implementing Caching
    20. Example: Basic Caching Configuration
    21. Example: Cache Busting with Versioning
    22. 10. Optimizing SSL Performance
    23. Example: SSL Configuration
    24. 11. Using HTTP/2
    25. Example: Enabling HTTP/2 in Nginx
    26. 12. Configuring Worker Priority
    27. Example: Setting Worker Priority

  34. Tuning Kernel Parameters

    1. 1. Increasing File Descriptors
    2. Example: Increasing File Descriptors
    3. 2. Configuring Backlog Queue
    4. Example: Increasing Backlog Limits
    5. 3. Setting TCP Buffer Sizes
    6. Example: Setting TCP Buffer Sizes in sysctl.conf
    7. 4. Enabling TCP Fast Open
    8. Example: Enabling TCP Fast Open for TLS
    9. 5. Configuring Keepalive Parameters
    10. Example: Setting Keepalive Parameters
    11. 6. Setting Connection Tracking
    12. Example: Adjusting Connection Tracking Limits
    13. 7. Optimizing Memory Settings
    14. Example: Memory Optimization Configuration
    15. 8. Using AIO and DirectIO
    16. Example: Configuring AIO and DirectIO
    17. 9. Configuring Thread Pool
    18. Example: Defining a Thread Pool
    19. Example: Using the Thread Pool
    20. 10. Setting Accept Mutex
    21. Example: Enabling Accept Mutex
    22. Example: Disabling Accept Mutex
    23. 11. Configuring Multi Accept
    24. Example: Enabling multi_accept
    25. 12. Setting Worker RLimit Nofile
    26. Example: Configuring worker_rlimit_nofile

  35. Optimizing for CDN Integration

    1. 1. Setting Appropriate Cache Headers
    2. Example: Setting Cache Headers in Nginx
    3. Example: Cache Control for Dynamic Content
    4. 2. Configuring Vary Headers
    5. Example: Setting Vary Header for Compression
    6. Example: Manual Vary Header
    7. 3. Implementing Origin Shield
    8. Example: Basic Origin Shield Configuration
    9. Example: Origin Shield with Custom Cache Key
    10. 4. Using X-Accel Headers
    11. Example: Serving files via X-Accel-Redirect
    12. 5. Setting CORS for CDN
    13. Example: Configuring CORS Headers in Nginx
    14. 6. Configuring Cache Purge Endpoints
    15. Example: Basic Cache Purge Configuration
    16. 7. Using Cache Keys for CDN
    17. Example: Custom Cache Key for CDN
    18. 8. Implementing Signed URLs
    19. Example: Basic Signed URL Validation
    20. Key Considerations
    21. 9. Setting Long Expires for Static Assets
    22. Example: Setting long expiration for static assets
    23. Example: Using
    24. 10. Optimizing Image Delivery
    25. Example: Resizing Images on the Fly
    26. Example: Serving WebP Images
    27. Image Optimization Best Practices
    28. 11. Implementing Conditional GET
    29. Example: Conditional GET with try_files
    30. 12. Using CDN-specific Headers
    31. Example: Setting CDN-specific Headers

  36. Working with Nginx Modules

    1. 1. Understanding Core Modules
    2. Example: Basic HTTP module configuration
    3. 2. Using ngx_http_rewrite_module
    4. Common Use Cases
    5. 3. Using ngx_http_ssl_module
    6. Example: Basic SSL Configuration
    7. 4. Using ngx_http_gzip_module
    8. Example: Basic gzip configuration
    9. 5. Using ngx_http_proxy_module
    10. Example: Basic proxy configuration
    11. Example: Proxy with timeout settings
    12. 6. Using ngx_http_fastcgi_module
    13. Example: Basic FastCGI Configuration
    14. 7. Using ngx_http_auth_basic_module
    15. Example: Basic Authentication Setup
    16. Example: Creating htpasswd File
    17. 8. Using ngx_http_access_module
    18. Example: Basic IP Allow/Deny Rules
    19. Example: Using
    20. 9. Loading Dynamic Modules
    21. Example: Loading a Dynamic Module
    22. 10. Compiling Third-party Modules
    23. Example: Compiling a Third-party Module
    24. 11. Using ngx_http_realip_module
    25. Example: Configuring real IP handling
    26. 12. Using ngx_http_stub_status_module
    27. Example: Enabling stub_status
    28. Sample Output

  37. Working with Content Modification

    1. 1. Using Sub Filter
    2. Example: Basic sub_filter usage
    3. Example: Sub filter with multiple replacements
    4. 2. Configuring Multiple Sub Filters
    5. Example: Multiple Sub Filters Configuration
    6. 3. Setting Sub Filter Types
    7. Example: Basic sub_filter usage
    8. Example: Using sub_filter_types
    9. 4. Using Addition Module
    10. Example: Adding text to response
    11. Example: Adding HTML to response
    12. 5. Implementing SSI
    13. Example: Basic SSI Include
    14. Example: Using Variables
    15. 6. Configuring SSI Variables
    16. Example: Using SSI Variables in Content
    17. Example: Inserting Date Using SSI Variable
    18. 7. Using XSLT Module
    19. Example: Basic XSLT Transformation
    20. 8. Implementing Charset Conversion
    21. Example: Setting charset for a location
    22. Example: Using charset_map
    23. 9. Configuring Content Substitution Patterns
    24. Example: Basic content replacement
    25. Example: Substitution in specific content types
    26. 10. Filtering Response Content
    27. Example: Using sub_filter to modify content
    28. 11. Adding Headers and Footers
    29. Example: Adding a Custom Header
    30. Example: Adding Headers Conditionally
    31. 12. Modifying Upstream Responses
    32. Example: Intercepting and Modifying Error Responses
    33. Example: Modifying Response with post_action

  38. Working with Image Processing

    1. 1. Using Image Filter Module
    2. Example: Basic Image Filtering Configuration
    3. Example: Image Scaling and Rotation
    4. 2. Resizing Images
    5. Example: Resizing Images
    6. 3. Rotating Images
    7. Example: Rotating Images
    8. 4. Cropping Images
    9. Example: Cropping an Image
    10. 5. Adjusting Image Quality
    11. Example: Setting JPEG Quality
    12. Example: Setting WebP Quality
    13. 6. Setting Image Buffer Size
    14. Example: Configuring Image Buffer Size
    15. 7. Creating Thumbnails
    16. Example: Thumbnail Creation
    17. 8. Testing Image Validity
    18. Example: Testing Image Validity
    19. 9. Converting Image Formats
    20. Example: Converting JPEG to WebP
    21. 10. Configuring Sharpen
    22. Example: Basic Sharpen Configuration
    23. 11. Setting Interlace Mode
    24. Example: Enabling Interlace Mode
    25. 12. Handling Image Errors
    26. Example: Custom Error Pages for Images

  39. Working with Nginx Streams (TCP/UDP)

    1. 1. Configuring Stream Block
    2. Example: Basic Stream Configuration
    3. 2. Implementing TCP Load Balancing
    4. Example: Basic TCP Load Balancing Configuration
    5. Example: TCP Load Balancing with Sticky Sessions
    6. Example: TCP Load Balancing with Health Checks
    7. 3. Implementing UDP Load Balancing
    8. Example: Basic UDP Load Balancing Configuration
    9. Example: UDP Load Balancing with Weighted Servers
    10. 4. Setting Stream Proxy
    11. Example: Basic Stream Proxy Configuration
    12. 5. Configuring Stream SSL
    13. Example: Basic SSL Stream Configuration
    14. 6. Using SNI Routing
    15. Example: Basic SNI-based TCP Stream Configuration
    16. 7. Setting Stream Access Control
    17. Example: Basic Stream Access Control
    18. 8. Configuring Stream Logging
    19. Example: Basic Stream Logging Configuration
    20. 9. Implementing Health Checks
    21. Example: Basic TCP Health Check Configuration
    22. Example: UDP Health Check with Custom Timeout
    23. Health Check Best Practices
    24. 10. Setting Stream Timeouts
    25. Example: Configuring Stream Timeouts
    26. 11. Using Stream Map
    27. Example: Basic Stream Map Usage
    28. 12. Implementing Stream Rate Limiting
    29. Example: Limiting Connections per IP
    30. Example: Rate Limiting Requests

  40. Configuring Mail Proxy

    1. 1. Enabling Mail Module
    2. Example: Enabling Mail Module in Nginx Configuration
    3. 2. Configuring SMTP Proxy
    4. Example: Basic SMTP Proxy Configuration
    5. Example: SMTP Proxy with SSL
    6. Example: SMTP Proxy with Authentication
    7. 3. Configuring IMAP Proxy
    8. Example: Basic IMAP Proxy Configuration
    9. 4. Configuring POP3 Proxy
    10. Example: Basic POP3 Proxy Configuration
    11. 5. Setting Auth HTTP Backend
    12. Example: Basic Auth HTTP Configuration
    13. 6. Configuring SSL for Mail
    14. Example: Basic SSL Configuration for Mail Proxy
    15. 7. Setting Mail Timeouts
    16. Example: Configuring Mail Proxy Timeouts
    17. 8. Using STARTTLS
    18. Example: Enabling STARTTLS in Nginx Mail Proxy
    19. 9. Configuring Mail Server Pools
    20. Example: Basic Mail Server Pool Configuration
    21. 10. Logging Mail Proxy Activity
    22. Example: Configuring Mail Proxy Logging
    23. Mail Proxy Logging Configuration Summary
    24. 11. Implementing Mail Routing
    25. Example: Basic Mail Routing Configuration
    26. Example: IMAP Mail Routing with Protocol Support
    27. 12. Handling Mail Authentication Failures
    28. Example: Configuring Authentication with HTTP

  41. Working with GeoIP

    1. 1. Installing GeoIP Module
    2. Example: Compile Nginx with GeoIP Module
    3. 2. Loading GeoIP Database
    4. Example: Loading GeoIP Database
    5. 3. Using GeoIP Variables
    6. Example: Setting a variable based on country
    7. 4. Implementing Geo-blocking
    8. Example: Blocking Access from Specific Countries
    9. 5. Redirecting by Location
    10. Example: Redirect based on country code
    11. 6. Setting Language by Country
    12. Example: Setting Language Based on Country
    13. 7. Using GeoIP2 Module
    14. Example: Setting up GeoIP2 Module
    15. GeoIP2 Module Summary
    16. 8. Configuring MaxMind Databases
    17. Example: Setting up MaxMind Country Database
    18. 9. Logging GeoIP Data
    19. Example: Logging GeoIP in Access Log
    20. 10. Using GeoIP with Map Directive
    21. Example: Setting up GeoIP map directive
    22. Example: Using the mapped variable in a location block
    23. 11. Implementing Regional Content Delivery
    24. Example: Serving Content Based on Country
    25. 12. Caching GeoIP Lookups
    26. Example: Caching GeoIP in Nginx

  42. Implementing A/B Testing

    1. 1. Using Split Clients
    2. Example: Basic Split Client Configuration
    3. 2. Distributing Traffic
    4. Example: Using ip_hash for A/B Testing
    5. 3. Setting Cookie-based Routing
    6. Example: Setting a Cookie for A/B Testing
    7. 4. Using Header-based Routing
    8. Example: Route by User-Agent Header
    9. Header-based Routing Configuration
    10. 5. Implementing Feature Flags
    11. Example: Feature Flag Configuration
    12. Feature Flag Use Cases
    13. 6. Routing to Multiple Upstreams
    14. Example: Load Balancing Across Multiple Upstreams
    15. Example: Using Sticky Sessions with Upstreams
    16. 7. Tracking A/B Test Results
    17. Example: Logging A/B Test Events
    18. Key Metrics to Track
    19. 8. Using Variables for Variants
    20. Example: Setting and Using Variables
    21. 9. Implementing Canary Deployments
    22. Example: Canary Deployment with Weighted Distribution
    23. Canary Deployment Strategy
    24. 10. Rolling Out Changes Gradually
    25. Example: Gradual Rollout with Weighted Distribution
    26. 11. Persisting User Assignment
    27. Example: Setting a Cookie for A/B Test Assignment
    28. Example: Retrieving Assignment from Cookie
    29. 12. Measuring A/B Test Metrics
    30. Example: Conversion Rate Calculation in Nginx
    31. Key Metrics Summary

  43. Working with Request Processing

    1. 1. Understanding Request Processing Phases
    2. Example: Basic Request Flow Configuration
    3. 2. Using Post Read Phase
    4. Example: post_action directive usage
    5. Example: post_action_if directive usage
    6. 3. Using Server Rewrite Phase
    7. Example: Basic Rewrite Rule
    8. Example: Rewrite with Permanent Redirect
    9. 4. Using Find Config Phase
    10. Example: Enabling Find Config Phase
    11. 5. Using Rewrite Phase
    12. Rewrite Phase Workflow
    13. 6. Using Post Rewrite Phase
    14. Example: Setting a Post-Action
    15. Example: Conditional Post-Action
    16. 7. Using Preaccess Phase
    17. Example: Using access_by_lua to check a header
    18. 8. Using Access Phase
    19. Example: Basic access_log configuration
    20. Example: Custom log format
    21. 9. Using Post Access Phase
    22. Example: Setting a Post-Action
    23. Example: Conditional Post-Action
    24. 10. Using Content Phase
    25. Example: Serving Static Files
    26. Example: Custom Error Page
    27. 11. Using Log Phase
    28. Example: Custom Log Format
    29. Example: Error Log Level
    30. 12. Understanding Phase Handlers
    31. Example: Configuring Rewrite and Access Phase Handlers

  44. Implementing API Gateway Patterns

    1. 1. Routing API Requests
    2. Example: Basic API Route
    3. Example: Rewrite and Forward
    4. 2. Implementing API Versioning
    5. Example: URL Path Versioning
    6. 3. Rate Limiting API Endpoints
    7. Example: Basic Rate Limiting Configuration
    8. Example: Rate Limiting with Burst and Delay
    9. Rate Limiting Configuration Summary
    10. 4. Authenticating API Requests
    11. Example: JWT Authentication Setup
    12. 5. Implementing API Key Validation
    13. Example: Basic API Key Validation Setup
    14. Example: Validating API Key from Header
    15. 6. Configuring Request Transformation
    16. Example: Transforming Request Headers
    17. 7. Implementing Response Transformation
    18. Example: Transforming Response Headers
    19. Example: Rewriting URI for Response Transformation
    20. 8. Handling CORS for APIs
    21. Example: Basic CORS Configuration
    22. Example: Handling Preflight Requests
    23. 9. Implementing Request Routing by Header
    24. Example: Route by User-Agent Header
    25. Example: Using Map for Header-Based Routing
    26. 10. Using Upstream Groups for Microservices
    27. Example: Load Balancing with Upstream Groups
    28. Upstream Group Configuration Summary
    29. 11. Implementing Circuit Breaker
    30. Example: Basic Circuit Breaker Configuration
    31. Key Features of Circuit Breaker in Nginx
    32. 12. Logging API Metrics
    33. Example: Custom Log Format for API Metrics
    34. Example: Using Custom Log Format
    35. Key Metrics to Track
    36. Steps to Implement API Metrics Logging

  45. Monitoring and Status

    1. 1. Enabling Stub Status
    2. Example: Enabling Stub Status
    3. 2. Understanding Status Metrics
    4. Example: Enabling stub_status
    5. 3. Using Access Logs for Monitoring
    6. Example: Custom Log Format
    7. Example: Log Rotation with logrotate
    8. Key Points for Log Monitoring
    9. 4. Parsing Nginx Logs
    10. Example: Log Format Configuration
    11. Example: Log Parsing with Python
    12. 5. Integrating with Prometheus
    13. Example: Basic Prometheus Integration
    14. Key Metrics Exposed
    15. 6. Integrating with Grafana Dashboards
    16. Example: Nginx Exporter Configuration
    17. Example: Grafana Dashboard JSON
    18. Comparison: Nginx Exporter vs InfluxDB
    19. 7. Using Third-party Status Modules
    20. Example: Enabling Virtual Host Traffic Status
    21. 8. Monitoring Upstream Health
    22. Example: Basic upstream health check configuration
    23. Example: Advanced upstream health check with custom parameters
    24. Upstream Health Check Configuration Summary
    25. 9. Tracking Response Times
    26. Example: Configuring response time logging
    27. Response Time Metrics
    28. 10. Monitoring SSL Certificate Expiry
    29. Example: Check Certificate Expiry via Command Line
    30. Example: Set Up a Cron Job to Monitor Certificates
    31. 11. Setting Up Alerts
    32. Example: Basic Alert Configuration
    33. Example: Alert Threshold Configuration
    34. 12. Implementing Real-time Metrics
    35. Example: Configuring Prometheus Exporter
    36. Example: Using OpenTelemetry Collector
    37. Real-time Metrics Overview

  46. Implementing Observability

    1. 1. Configuring OpenTelemetry Integration
    2. Example: Basic OpenTelemetry Configuration
    3. 2. Implementing Distributed Tracing
    4. Example: Basic OpenTracing Configuration
    5. Tracing Integration Options
    6. Distributed Tracing Options in Nginx
    7. 3. Adding Trace Headers
    8. Example: Adding Trace Headers to Nginx
    9. 4. Using Jaeger for Tracing
    10. Example: Basic Jaeger Tracing Configuration
    11. 5. Integrating with Zipkin
    12. Example: Nginx Configuration for Zipkin Integration
    13. 6. Configuring Span Context Propagation
    14. Example: Enabling Span Context Propagation
    15. 7. Setting Up Log Correlation
    16. Example: Log Format with Trace ID
    17. Workflow: Enabling Structured Logging in Nginx
    18. 8. Implementing Request Flow Tracking
    19. Example: Custom Log Format with Trace ID
    20. Example: Access Log with Request ID
    21. Key Points for Request Flow Tracking
    22. 9. Using OpenTracing Module
    23. Example: Basic OpenTracing Configuration
    24. 10. Monitoring Latency Distributions
    25. Example: Logging Latency with Custom Format
    26. Latency Monitoring Best Practices
    27. 11. Configuring Trace Sampling
    28. Example: Setting Trace Sampling Ratio
    29. 12. Exporting Metrics to Backends
    30. Example: Prometheus Exporter Configuration

  47. Debugging Nginx

    1. 1. Testing Configuration
    2. Example: Testing Nginx Configuration
    3. 2. Enabling Debug Log
    4. Example: Enabling Debug Log
    5. 3. Using Rewrite Log
    6. Example: Enabling Rewrite Log
    7. 4. Checking Error Logs
    8. Example: Viewing Nginx Error Logs
    9. Example: Filtering Logs by Time
    10. 5. Debugging SSL Issues
    11. Example: SSL debug logging
    12. Common SSL Debugging Steps
    13. 6. Testing with Curl
    14. Example: Basic curl request to Nginx
    15. Example: Simulate a POST request
    16. 7. Using Nginx Debug Build
    17. Example: Enabling debug logging in Nginx
    18. 8. Analyzing Core Dumps
    19. Example: Analyzing Core Dump with GDB
    20. 9. Debugging Proxy Issues
    21. Example: Enable Detailed Proxy Logging
    22. Common Proxy Debugging Steps
    23. 10. Using tcpdump for Network Analysis
    24. Example: Capture Nginx Traffic
    25. 11. Debugging Location Matching
    26. Example: Debugging Location Matching
    27. 12. Using Echo Module for Testing
    28. Example: Basic Echo Module Usage

  48. Troubleshooting Common Issues

    1. 1. Resolving 502 Bad Gateway
    2. Example: Nginx config with timeout adjustments
    3. 2. Fixing 504 Gateway Timeout
    4. Example: Increasing proxy timeout values
    5. 3. Debugging 413 Request Entity Too Large
    6. Example: Increasing body size limit
    7. 4. Resolving Configuration Conflicts
    8. Example: Resolving Duplicate Server Blocks
    9. 5. Fixing Permission Denied Errors
    10. Example: Setting Correct Permissions
    11. 6. Debugging SSL Handshake Failures
    12. Example: Enabling SSL debug logging
    13. Example: Checking SSL certificate chain
    14. 7. Resolving DNS Resolution Issues
    15. Example: Configuring DNS resolver
    16. 8. Fixing WebSocket Connection Drops
    17. Example: Nginx config for WebSocket keep-alive
    18. 9. Debugging Redirect Loops
    19. Example: Redirect Loop Configuration
    20. Debugging Steps
    21. 10. Resolving Upstream Connection Refused
    22. Example: Basic Upstream Configuration
    23. 11. Fixing 400 Bad Request Errors
    24. Example: Configuring Client Max Body Size
    25. Example: Logging Request Details
    26. 12. Troubleshooting Slow Connections
    27. Example: Enabling sendfile for faster file delivery
    28. Common Slow Connection Fixes

  49. Working with Containers and Orchestration

    1. 1. Running Nginx in Docker
    2. Example: Basic Nginx Container
    3. Example: Custom Nginx Configuration
    4. 2. Creating Custom Nginx Image
    5. Example: Basic Dockerfile for Nginx
    6. Example: Multi-stage Build for Nginx
    7. 3. Mounting Configuration
    8. Example: Mounting Configuration in Docker
    9. 4. Using Environment Variables
    10. Example: Setting Environment Variables in Docker
    11. Example: Using Environment Variables in Nginx Config
    12. 5. Configuring Health Checks
    13. Example: Basic Health Check Configuration
    14. Example: Advanced Health Check with Custom Path and Timeout
    15. 6. Deploying on Kubernetes
    16. Example: Ingress Configuration
    17. Example: Service Configuration
    18. 7. Using Nginx Ingress Controller
    19. Example: Basic Ingress Configuration
    20. Example: Ingress with TLS
    21. Key Features
    22. 8. Configuring ConfigMaps
    23. Example: Mounting ConfigMap in Nginx Deployment
    24. 9. Implementing Rolling Updates
    25. Example: Nginx Config for Rolling Updates
    26. Rolling Update Strategy
    27. 10. Setting Resource Limits
    28. Example: Rate Limiting Configuration
    29. Example: Connection Limiting Configuration
    30. 11. Using Nginx in Docker Compose
    31. Example: Basic Nginx Docker Compose Setup
    32. Example: Nginx with Reverse Proxy Configuration
    33. Key Points for Nginx in Docker Compose
    34. 12. Implementing Sidecar Patterns
    35. Example: Sidecar Configuration in Kubernetes
    36. Sidecar Benefits

  50. Implementing High Availability

    1. 1. Configuring Nginx Active-Passive
    2. Example: Active-Passive Configuration
    3. 2. Implementing Active-Active Setup
    4. Example: Active-Active Configuration
    5. 3. Using Virtual IP
    6. Example: Virtual IP Configuration
    7. 4. Configuring Health Check Scripts
    8. Example: Health Check Configuration
    9. 5. Implementing Session Persistence
    10. Example: Session Persistence Configuration
    11. 6. Using DNS Round Robin
    12. Example: DNS Round Robin Configuration
    13. 7. Configuring Upstream Retry
    14. Example: Upstream Retry Configuration
    15. 8. Implementing Circuit Breaker Pattern
    16. Example: Circuit Breaker Configuration
    17. 9. Using Zone Sync for Cluster State
    18. Example: Zone Sync Configuration
    19. 10. Monitoring Failover Events
    20. Example: Failover Monitoring Configuration
    21. 11. Implementing Graceful Degradation
    22. Example: Graceful Degradation Configuration
    23. 12. Configuring Connection Draining
    24. Example: Connection Draining Configuration

  51. Implementing Service Mesh Integration

    1. 1. Using Nginx as Sidecar Proxy
    2. Example: Basic Sidecar Configuration
    3. 2. Configuring mTLS
    4. Example: mTLS Configuration in Nginx
    5. 3. Implementing Service Discovery
    6. Example: Service Discovery with Consul
    7. 4. Using Consul Template Integration
    8. Example: Consul Template Configuration
    9. Example: Consul Template File (app.ctmpl)
    10. 5. Configuring Dynamic Upstream Updates
    11. Example: Basic Upstream Configuration
    12. Example: Using Keepalive Connections
    13. Dynamic Upstream Update Considerations
    14. 6. Implementing Traffic Shadowing
    15. Example: Shadowing traffic to a secondary service
    16. Key Considerations for Traffic Shadowing
    17. 7. Using Nginx with Istio
    18. Example: Ingress with Istio integration
    19. 8. Configuring OpenTracing Integration
    20. Example: Jaeger Tracer Configuration
    21. Example: Nginx Configuration with OpenTracing
    22. 9. Implementing Request Tracing
    23. Example: Basic OpenTracing Configuration
    24. Example: Propagating Trace Context
    25. Key Concepts
    26. 10. Using Jaeger for Distributed Tracing
    27. Example: Configuring Jaeger Tracing in Nginx
    28. 11. Implementing Traffic Mirroring
    29. Example: Mirroring Traffic to a Logging Service
    30. 12. Configuring Circuit Breakers
    31. Example: Basic Circuit Breaker Configuration

  52. Migrating and Upgrading Nginx

    1. 1. Planning Nginx Version Upgrades
    2. Upgrade Planning Steps
    3. 2. Testing Configuration Compatibility
    4. Example: Testing Configuration
    5. Compatibility Testing Steps
    6. 3. Performing Zero-downtime Upgrades
    7. Example: Zero-downtime upgrade command
    8. 4. Migrating Configuration Between Servers
    9. Example: Securely copying configuration files
    10. 5. Converting Apache to Nginx Configuration
    11. Example: Basic Apache to Nginx Conversion
    12. Example: Equivalent Nginx Configuration
    13. Key Differences in Configuration Syntax
    14. 6. Handling Deprecated Directives
    15. Example: Migrating from
    16. 7. Rolling Back Failed Upgrades
    17. Example: Reverting Nginx Configuration After Failed Upgrade
    18. 8. Upgrading Dynamic Modules
    19. Example: Recompiling Dynamic Module
    20. 9. Migrating SSL Certificates
    21. 10. Testing Upgrade Impact
    22. Example: Simulate upgrade with config test
    23. Example: Check module compatibility
    24. Upgrade Testing Approaches
    25. 11. Documenting Configuration Changes
    26. Example: Logging Configuration Changes
    27. Best Practices for Configuration Documentation
    28. 12. Implementing Blue-Green Deployments
    29. Example: Blue-Green Deployment Configuration
    30. Blue-Green Deployment Workflow