How To Configure Nginx Server Blocks on Fedora 42

Nginx server blocks allow you to host multiple websites on a single server, similar to Apache’s virtual hosts but with Nginx’s performance-oriented architecture. Whether you’re setting up a development environment or deploying production websites, properly configured server blocks ensure efficient resource utilization while maintaining site isolation. This comprehensive guide explores the process of configuring Nginx server blocks on Fedora 42, from installation to advanced configurations and troubleshooting.

Table of Contents

Prerequisites

Before diving into Nginx server block configuration, ensure your system meets the necessary requirements and is properly prepared.

System Requirements

For optimal Nginx performance on Fedora 42, your system should have:

Minimum 512MB RAM (1GB or more recommended for production environments)
At least 10GB disk space for the system, logs, and website files
Root or sudo privileges for installation and configuration tasks

Checking for Conflicting Web Servers

Nginx and Apache cannot simultaneously listen on the same ports. Check if Apache or another web server is running:

# Check if Apache is running
sudo systemctl status httpd

# Stop Apache if it's running
sudo systemctl stop httpd
sudo systemctl disable httpd

You can also use sudo fuser -k 80/tcp and sudo fuser -k 443/tcp to release any processes binding to web ports.

Updating Your Fedora System

Ensure your Fedora 42 system is up-to-date before proceeding:

sudo dnf upgrade --refresh
sudo reboot

A system reboot after major updates ensures all changes take effect properly.

Installing Nginx on Fedora 42

There are two primary methods for installing Nginx on Fedora 42: using the DNF package manager or compiling from source.

Installing via DNF Package Manager

The simplest approach is using Fedora’s official repositories:

sudo dnf install nginx

After installation, verify with:

nginx -v

Managing the Nginx Service

Fedora 42 uses systemd for service management. Here are essential commands:

# Start Nginx
sudo systemctl start nginx

# Stop Nginx
sudo systemctl stop nginx

# Restart Nginx
sudo systemctl restart nginx

# Reload configuration without downtime
sudo systemctl reload nginx

# Enable Nginx to start at boot
sudo systemctl enable nginx

# Check Nginx status
sudo systemctl status nginx

Always test your configuration before applying changes:

sudo nginx -t

Understanding Nginx Configuration Structure

Before working with server blocks, you should understand how Nginx configurations are organized.

Main Configuration File

The primary configuration file is located at /etc/nginx/nginx.conf. This file contains global settings and includes other configuration files:

user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log;
pid /var/run/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    
    # Other settings...
    
    include /etc/nginx/conf.d/*.conf;
}

Configuration Hierarchy

Nginx uses a hierarchical structure:

Main context: Global settings
Events context: Connection processing
HTTP context: Web server and proxy settings
Server context: Virtual host settings
Location context: URI path handling

Modular Configuration Approach

The line include /etc/nginx/conf.d/*.conf; tells Nginx to include all .conf files from the /etc/nginx/conf.d/ directory. This modular approach lets you manage each server block in its own file.

Configuring Firewall for Nginx

Fedora 42 uses firewalld as its default firewall. For your Nginx server to be accessible, you need to configure it properly.

Using Firewalld on Fedora 42

Open HTTP and HTTPS ports:

# Open HTTP port (80)
sudo firewall-cmd --permanent --add-service=http

# Open HTTPS port (443)
sudo firewall-cmd --permanent --add-service=https

# Reload firewall to apply changes
sudo firewall-cmd --reload

Verifying Firewall Configuration

Confirm your changes were applied:

# List allowed services
sudo firewall-cmd --list-services

# Get detailed information
sudo firewall-cmd --list-all

The output should include “http” and “https” among the enabled services.

Server Blocks Concept and Structure

Server blocks are Nginx’s way of hosting multiple websites on a single server.

What Are Server Blocks?

Server blocks define how Nginx should process requests for specific domains. Each block configures settings for a domain or subdomain.

A server block is a configuration unit that defines:

Which ports to listen on
Which domain names to respond to
Where website files are stored
How to handle different URL paths
Error handling configurations

Name-based vs. IP-based Virtual Hosting

Nginx supports two virtual hosting types:

Name-based hosting: Multiple domains share the same IP address
IP-based hosting: Each website has a dedicated IP address

Name-based hosting is more common as it conserves limited IP addresses.

How Nginx Processes Requests

When a request arrives, Nginx follows these steps to determine which server block handles it:

Match the IP address and port
Find a server block with a matching server_name
If multiple blocks match, select the most specific one
If no name matches, use the default server for that IP:port combination

Directory Structure Setup

Before creating server blocks, establish an organized directory structure for your websites.

Creating Website Document Root Directories

Each website should have its own document root:

# Create directory for your website
sudo mkdir -p /var/www/html/example.com

# Set appropriate ownership
sudo chown -R $USER:nginx /var/www/html/example.com

# Set permissions
sudo chmod -R 750 /var/www/html/example.com

Setting Appropriate Permissions

Security is crucial for web hosting. Set proper ownership and permissions to ensure Nginx can access files while maintaining security.

On Fedora 42, the recommended ownership is root:nginx for content directories:

sudo chown -R root:nginx /var/www/html
sudo chmod -R 750 /var/www/html

Creating Basic Server Block Configurations

Now let’s create server block configurations for your websites.

Using /etc/nginx/conf.d/ Directory

On Fedora 42, the recommended approach is to create configuration files in the /etc/nginx/conf.d/ directory with a .conf extension:

sudo nano /etc/nginx/conf.d/example.com.conf

Essential Server Block Directives

Add the following configuration to your file:

server {
    listen 80;
    server_name example.com www.example.com;
    
    root /var/www/html/example.com;
    index index.html index.htm;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

Key directives explained:

listen: Specifies port(s) Nginx listens on
server_name: Defines domain names this block responds to
root: Specifies document root directory
index: Lists files to use as directory indexes
location: Configures how to handle specific URI patterns
try_files: Tries to serve files in order until one is found

Sites-Available/Sites-Enabled Structure Alternative

Some administrators prefer the Apache-style approach:

# Create directory structure
sudo mkdir -p /etc/nginx/sites-available /etc/nginx/sites-enabled

# Create configuration in sites-available
sudo nano /etc/nginx/sites-available/example.com

# Create symbolic link to enable site
sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/

This approach requires adding an include directive to nginx.conf:

include /etc/nginx/sites-enabled/*;

Step-by-Step Server Block Implementation

Let’s implement a complete server block configuration.

Creating a Complete Server Block Configuration

First, create a sample HTML file for testing:

echo "<html><body><h1>Welcome to example.com</h1></body></html>" > /var/www/html/example.com/index.html

Then, create the server block configuration:

server {
    listen 80;
    listen [::]:80;
    
    server_name example.com www.example.com;
    root /var/www/html/example.com;
    
    index index.html index.htm;
    
    location / {
        try_files $uri $uri/ =404;
    }
    
    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;
    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

Multiple Domain Support

To handle multiple domains in one server block:

server {
    listen 80;
    server_name example.com www.example.com example.org www.example.org;
    
    # Rest of configuration...
}

IPv6 Configuration

Modern server blocks should support IPv6:

server {
    listen 80;
    listen [::]:80;
    
    # Rest of configuration...
}

Testing and Activating Configurations

After creating your configuration, test and apply it:

# Test configuration
sudo nginx -t

# If successful, reload Nginx
sudo systemctl reload nginx

SELinux Configuration for Nginx

Fedora 42 uses SELinux by default, which requires proper configuration for Nginx.

Understanding SELinux Contexts

SELinux enforces access controls based on file contexts. For Nginx to access web content, files must have the correct context type, typically httpd_sys_content_t.

Setting Correct File Contexts

To set the correct context for web files:

# Set context for web content
sudo semanage fcontext -a -t httpd_sys_content_t "/var/www/html(/.*)?"

# Apply the context
sudo restorecon -Rv /var/www/html

Verifying Contexts

Check that contexts were applied correctly:

ls -Z /var/www/html

You should see system_u:object_r:httpd_sys_content_t:s0 as the context.

Troubleshooting SELinux Permission Issues

If Nginx can’t access files despite correct file permissions, SELinux might be blocking access:

# Check SELinux logs for denials
sudo ausearch -m avc -ts recent

# Temporarily set SELinux to permissive mode for testing
sudo setenforce 0

# After testing, re-enable enforcing mode
sudo setenforce 1

If Nginx works in permissive mode but not enforcing mode, you need to adjust your SELinux policies.

Advanced Server Block Configurations

Once basic server blocks are working, implement more advanced features.

HTTPS/SSL Configuration Basics

To secure your website with HTTPS:

server {
    listen 443 ssl;
    listen [::]:443 ssl;
    
    server_name example.com www.example.com;
    
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    ssl_protocols TLSv1.2 TLSv1.3;
    
    # Rest of configuration...
}

Implementing URL Rewrites and Redirects

To redirect HTTP to HTTPS:

server {
    listen 80;
    server_name example.com www.example.com;
    return 301 https://$host$request_uri;
}

PHP Processing Configuration

To handle PHP files:

location ~ \.php$ {
    fastcgi_pass unix:/var/run/php-fpm/www.sock;
    fastcgi_index index.php;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    include fastcgi_params;
}

If PHP-FPM isn’t running, you might encounter a 502 Bad Gateway error.

Load Balancing Between Multiple Backends

For load balancing across multiple servers:

upstream backend_servers {
    server 192.168.1.101:8080;
    server 192.168.1.102:8080;
}

server {
    listen 80;
    server_name example.com;
    
    location / {
        proxy_pass http://backend_servers;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Troubleshooting Server Blocks

Even with careful configuration, issues can arise. Here’s how to diagnose and resolve common problems.

Common Configuration Errors

Syntax errors: Always run nginx -t before applying changes
Port conflicts: Ensure no other service uses the same port
Permission issues: Check file permissions and SELinux contexts
Incorrect server names: Verify domain names in server_name directive

Using Nginx Error Logs

Nginx logs provide valuable troubleshooting information:

# View error logs
sudo tail -f /var/log/nginx/error.log

# View access logs
sudo tail -f /var/log/nginx/access.log

Testing Configurations Before Deployment

Always test your configurations before applying them:

sudo nginx -t

This command checks for syntax errors without applying changes.

Addressing Permission Problems

For permission-related issues:

Check file ownership: ls -la /var/www/html
Verify SELinux contexts: ls -Z /var/www/html
For PHP issues, ensure the socket file permissions are correct

Performance Optimization

Optimize your Nginx server blocks for better performance.

Caching Strategies for Static Content

Implement browser caching for static assets:

location ~* \.(jpg|jpeg|png|gif|ico|css|js)$ {
    expires 30d;
    add_header Cache-Control "public, no-transform";
}

Enabling Compression

Reduce bandwidth usage with compression:

gzip on;
gzip_comp_level 5;
gzip_min_length 256;
gzip_proxied any;
gzip_types application/javascript application/json text/css text/plain;

Worker Process Tuning

Optimize worker processes based on your CPU cores:

worker_processes auto;  # Or set to CPU core count
worker_rlimit_nofile 65535;

Buffer Size Adjustments

Adjust buffer sizes for different traffic patterns:

client_body_buffer_size 10K;
client_header_buffer_size 1k;
client_max_body_size 8m;

Congratulations! You have successfully set up Nginx server blocks. Thanks for using this tutorial to configure Nginx server blocks on your Fedora 42 Linux system. For additional or useful information, we recommend you check the official Nginx website.

VPS Manage Service Offer

If you don’t have time to do all of this stuff, or if this is not your area of expertise, we offer a service to do “VPS Manage Service Offer”, starting from $10 (Paypal payment). Please contact us to get the best deal!