Administração de Sistemas

Nginx e Reverse Proxy no Linux: Configuração Completa

setembro 1, 2026 · 17 min de leitura · Luiz Seabra

Nginx como Reverse Proxy

Introdução

O Nginx (Engine X) é, sem dúvida, o servidor web e proxy reverso mais amplamente utilizado no mundo moderno de infraestrutura. Sua arquitetura event-driven, assíncrona e non-blocking permite lidar com dezenas de milhares de conexões simultâneas com uma fração da memória e CPU necessárias por servidores baseados em thread-per-connection como o Apache HTTPD.

Como Reverse Proxy, o Nginx atua como a “porta de entrada” única para todo o tráfego externo, desacoplando clientes dos servidores de aplicação (upstreams). Isso habilita funcionalidades críticas: terminação SSL/TLS, balanceamento de carga, cache de conteúdo estático/dinâmico, compressão, rate limiting, WAF básico e observabilidade centralizada.

Este guia abrange desde a instalação e conceitos fundamentais até configurações avançadas de produção, incluindo um laboratório reproduzível com Docker e bare metal.

O que você vai aprender

• Diferença entre Forward Proxy e Reverse Proxy.
• Arquitetura event-driven do Nginx (Master/Worker processes).
• Diretivas essenciais: proxy_pass, upstream, proxy_set_header, proxy_buffering.
• Terminação SSL/TLS com certificados Let’s Encrypt e certificados auto-assinados para lab.
• Algoritmos de balanceamento: Round Robin, Least Connections, IP Hash, Least Time.
• Cache de resposta (proxy_cache) e microcaching para picos de tráfego.
• Rate Limiting (limit_req_zone) e conexões (limit_conn_zone).
• Headers de segurança: HSTS, CSP, X-Frame-Options, Referrer-Policy.
• Health checks passivos e ativos (proxy_next_upstream, health_check).
• Logging estruturado (JSON) para integração com ELK/Loki.
• Laboratório: 3 containers de aplicação + Nginx proxy com Docker Compose.
• Troubleshooting avançado e hardening.

Pré‑requisitos

• Linux (Ubuntu 22.04+, Debian 12, RHEL 9, Alpine).
• Docker 24+ e Docker Compose v2 (para laboratório containerizado).
• Ou instalação bare metal: nginx (mainline/stable) via repositório oficial.
• Conhecimento básico de HTTP, DNS, TLS e YAML.
• Domínio real (para Let’s Encrypt) ou entradas /etc/hosts para laboratório local.

Conceitos fundamentais

Forward Proxy vs Reverse Proxy

FORWARD PROXY (Cliente → Proxy → Internet)          REVERSE PROXY (Internet → Proxy → Backends)
+--------+     +--------+     +--------+             +--------+     +--------+     +--------+
| Client | --> | Proxy  | --> | Target |             | Client | --> | Proxy  | --> | App 1  |
+--------+     +--------+     +--------+             +--------+     +--------+     +--------+
                                                      |                  |         |
                                                      |                  +---------+
                                                      |                         |
                                                      v                         v
                                                +--------+               +--------+
                                                | App 2  |               | App 3  |
                                                +--------+               +--------+

Preparação do ambiente

Opção A: Instalação Bare Metal (Ubuntu/Debian)

# Adicionar repositório oficial Nginx (mainline = mais recente)
sudo apt update
sudo apt install -y curl gnupg2 ca-certificates lsb-release ubuntu-keyring
curl -fsSL https://nginx.org/keys/nginx_signing.key | sudo gpg --dearmor -o /usr/share/keyrings/nginx-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] http://nginx.org/packages/mainline/ubuntu $(lsb_release -cs) nginx" | sudo tee /etc/apt/sources.list.d/nginx.list
sudo apt update
sudo apt install -y nginx
sudo systemctl enable --now nginx

Opção B: Docker (recomendado para laboratório)

mkdir -p ~/lab-nginx-proxy/{conf.d,certs,html,logs}
cd ~/lab-nginx-proxy

Tutorial passo a passo

1. Estrutura de configuração recomendada

/etc/nginx/
├── nginx.conf                 # Configuração global
├── conf.d/
│   ├── 00-default-upstreams.conf
│   ├── 01-ssl-params.conf
│   ├── 02-rate-limits.conf
│   ├── 10-app-example.conf    # Virtual host da aplicação
│   └── 99-security-headers.conf
├── sites-available/           # (Opcional, estilo Debian)
└── sites-enabled/             # Symlinks para sites-available

2. nginx.conf — Configuração global otimizada

user www-data;
worker_processes auto;                    # 1 worker por CPU core
worker_rlimit_nofile 65535;               # Limite de file descriptors
pid /run/nginx.pid;

events {
    worker_connections 4096;              # Max conexões por worker
    multi_accept on;                      # Aceita múltiplas conexões de uma vez
    use epoll;                            # Linux kernel event mechanism
}

http {
    # --- Basic Settings ---
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    server_tokens off;                    # Esconde versão do Nginx
    client_max_body_size 50M;             # Limite upload

    # --- MIME & Compression ---
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 5;
    gzip_min_length 1000;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

    # --- Logging JSON para ELK/Loki ---
    log_format json_analytics escape=json
        '{ "time": "$time_iso8601", "remote_addr": "$remote_addr", '
        '"request": "$request", "status": $status, "body_bytes_sent": $body_bytes_sent, '
        '"request_time": $request_time, "upstream_addr": "$upstream_addr", '
        '"upstream_response_time": "$upstream_response_time", '
        '"http_referrer": "$http_referer", "http_user_agent": "$http_user_agent" }';

    access_log /var/log/nginx/access.log json_analytics;
    error_log /var/log/nginx/error.log warn;

    # --- Buffering & Timeouts ---
    proxy_buffering on;
    proxy_buffer_size 8k;
    proxy_buffers 8 16k;
    proxy_busy_buffers_size 32k;
    proxy_read_timeout 90s;
    proxy_send_timeout 90s;
    proxy_connect_timeout 10s;

    # --- Include modular configs ---
    include /etc/nginx/conf.d/*.conf;
}

3. conf.d/01-ssl-params.conf — Parâmetros TLS modernos (Mozilla Intermediate)

# TLS Configuration
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_prefer_server_ciphers off;
ssl_session_cache shared:SSL:10m;
ssl_session_timeout 10m;
ssl_session_tickets off;

# OCSP Stapling
ssl_stapling on;
ssl_stapling_verify on;
resolver 1.1.1.1 8.8.8.8 valid=300s;
resolver_timeout 5s;

# DH Parameters (gerar com: openssl dhparam -out /etc/nginx/certs/dhparam.pem 2048)
# ssl_dhparam /etc/nginx/certs/dhparam.pem;

4. conf.d/02-rate-limits.conf — Proteção contra abuso

# Rate Limiting Zones (definidas no http context)
limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;      # 10 req/s por IP
limit_req_zone $binary_remote_addr zone=login_limit:10m rate=1r/s;     # 1 req/s para login
limit_conn_zone $binary_remote_addr zone=conn_limit:10m;               # Max 20 conexões simultâneas
limit_conn conn_limit 20;

# Burst handling (permite rajadas curtas)
# limit_req zone=api_limit burst=20 nodelay;

5. conf.d/00-default-upstreams.conf — Definição de backends

# Backend Application Servers
upstream app_backend {
    # Round Robin (padrão)
    server 10.10.50.10:8000 max_fails=3 fail_timeout=30s;
    server 10.10.50.11:8000 max_fails=3 fail_timeout=30s;
    server 10.10.50.12:8000 max_fails=3 fail_timeout=30s;

    # Keep-alive connections para upstreams (economia de handshake)
    keepalive 32;
}

# Backend com Least Connections (para cargas desbalanceadas)
upstream app_backend_lc {
    least_conn;
    server 10.10.50.10:8000 weight=3 max_fails=3 fail_timeout=30s;
    server 10.10.50.11:8000 weight=2 max_fails=3 fail_timeout=30s;
    server 10.10.50.12:8000 weight=1 max_fails=3 fail_timeout=30s;
    keepalive 32;
}

# Backend com IP Hash (session affinity / sticky sessions)
upstream app_backend_sticky {
    ip_hash;
    server 10.10.50.10:8000 max_fails=3 fail_timeout=30s;
    server 10.10.50.11:8000 max_fails=3 fail_timeout=30s;
    keepalive 32;
}

6. conf.d/10-app-example.conf — Virtual Host completo

# Redirect HTTP -> HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name app.example.com www.app.example.com;

    # ACME Challenge para Let's Encrypt
    location /.well-known/acme-challenge/ {
        root /var/www/letsencrypt;
    }

    # Redirect tudo mais para HTTPS
    location / {
        return 301 https://$host$request_uri;
    }
}

# HTTPS Server
server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name app.example.com www.app.example.com;

    # Certificados (Let's Encrypt ou self-signed para lab)
    ssl_certificate /etc/nginx/certs/app.example.com/fullchain.pem;
    ssl_certificate_key /etc/nginx/certs/app.example.com/privkey.pem;
    include /etc/nginx/conf.d/01-ssl-params.conf;

    # Security Headers
    include /etc/nginx/conf.d/99-security-headers.conf;

    # Logging específico deste vhost
    access_log /var/log/nginx/app.example.com.access.log json_analytics;
    error_log /var/log/nginx/app.example.com.error.log;

    # --- Static Files (servidos diretamente pelo Nginx) ---
    location /static/ {
        alias /var/www/app/static/;
        expires 1y;
        add_header Cache-Control "public, immutable";
        access_log off;
    }

    location /media/ {
        alias /var/www/app/media/;
        expires 30d;
        add_header Cache-Control "public";
    }

    # --- API com Rate Limiting Específico ---
    location /api/ {
        limit_req zone=api_limit burst=20 nodelay;
        limit_req_status 429;

        proxy_pass http://app_backend;
        include /etc/nginx/conf.d/proxy-params.conf;
    }

    # --- Login com Rate Limiting Restritivo ---
    location /api/auth/login {
        limit_req zone=login_limit burst=5 nodelay;
        limit_req_status 429;

        proxy_pass http://app_backend;
        include /etc/nginx/conf.d/proxy-params.conf;
    }

    # --- Health Check Endpoint (sem rate limit, sem log) ---
    location /healthz {
        access_log off;
        proxy_pass http://app_backend/healthz;
        include /etc/nginx/conf.d/proxy-params.conf;
    }

    # --- Proxy Pass Principal (Catch-all) ---
    location / {
        proxy_pass http://app_backend;
        include /etc/nginx/conf.d/proxy-params.conf;
    }
}

7. conf.d/proxy-params.conf — Parâmetros de proxy reutilizáveis

# Headers passados para o backend
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Forwarded-Host $host;
proxy_set_header X-Forwarded-Port $server_port;

# WebSocket Support
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";

# Timeouts
proxy_connect_timeout 10s;
proxy_send_timeout 90s;
proxy_read_timeout 90s;

# Buffering
proxy_buffering on;
proxy_buffer_size 8k;
proxy_buffers 8 16k;

# Failover / Health Check Passivo
proxy_next_upstream error timeout http_500 http_502 http_503 http_504;
proxy_next_upstream_tries 3;
proxy_next_upstream_timeout 30s;

# Redirects: reescreve Location headers do backend
proxy_redirect off;

8. conf.d/99-security-headers.conf — Cabeçalhos de segurança

# HSTS (apenas em HTTPS)
add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;

# Content Security Policy (ajuste conforme sua aplicação)
add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline' https://cdn.example.com; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data: https:; connect-src 'self' https://api.example.com; frame-ancestors 'none'; base-uri 'self'; form-action 'self';" always;

# Outros headers
add_header X-Frame-Options "DENY" always;
add_header X-Content-Type-Options "nosniff" always;
add_header Referrer-Policy "strict-origin-when-cross-origin" always;
add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Resource-Policy "same-origin" always;

# Remove headers que vazam informação
proxy_hide_header X-Powered-By;
proxy_hide_header Server;

9. Geração de certificados para laboratório (Self-Signed)

mkdir -p ~/lab-nginx-proxy/certs/app.example.com

# Gerar certificado auto-assinado válido por 365 dias
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout ~/lab-nginx-proxy/certs/app.example.com/privkey.pem \
  -out ~/lab-nginx-proxy/certs/app.example.com/fullchain.pem \
  -subj "/CN=app.example.com" \
  -addext "subjectAltName=DNS:app.example.com,DNS:www.app.example.com"

# Gerar dhparam (pode demorar)
openssl dhparam -out ~/lab-nginx-proxy/certs/dhparam.pem 2048

Laboratório reproduzível com Docker Compose

Estrutura do laboratório:
– nginx-proxy: Reverse proxy Nginx
– app-1, app-2, app-3: 3 instâncias de uma aplicação Python/Go/Node simples
– Redis: Para demonstrar cache compartilhado (opcional)

docker-compose.yml

version: '3.8'

services:
  nginx-proxy:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./conf.d:/etc/nginx/conf.d:ro
      - ./certs:/etc/nginx/certs:ro
      - ./html:/var/www:ro
      - ./logs:/var/log/nginx
    networks:
      - lab-net
    depends_on:
      - app-1
      - app-2
      - app-3
    restart: unless-stopped

  app-1:
    image: python:3.11-alpine
    container_name: app-1
    command: >
      sh -c "pip install flask gunicorn && 
      python3 -c '
      from flask import Flask, jsonify, request
      import os, socket
      app = Flask(__name__)
      @app.route(\"/\")
      def index():
          return jsonify(host=socket.gethostname(), ip=request.remote_addr, 
                         headers=dict(request.headers), 
                         env=dict(os.environ))
      @app.route(\"/healthz\")
      def health(): return jsonify(status=\"ok\")
      app.run(host=\"0.0.0.0\", port=8000)
      '"
    networks:
      - lab-net
    environment:
      - INSTANCE=app-1
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

  app-2:
    image: python:3.11-alpine
    container_name: app-2
    command: >
      sh -c "pip install flask gunicorn && 
      python3 -c '
      from flask import Flask, jsonify, request
      import os, socket
      app = Flask(__name__)
      @app.route(\"/\")
      def index():
          return jsonify(host=socket.gethostname(), ip=request.remote_addr,
                         headers=dict(request.headers), env=dict(os.environ))
      @app.route(\"/healthz\")
      def health(): return jsonify(status=\"ok\")
      app.run(host=\"0.0.0.0\", port=8000)
      '"
    networks:
      - lab-net
    environment:
      - INSTANCE=app-2
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

  app-3:
    image: python:3.11-alpine
    container_name: app-3
    command: >
      sh -c "pip install flask gunicorn && 
      python3 -c '
      from flask import Flask, jsonify, request
      import os, socket
      app = Flask(__name__)
      @app.route(\"/\")
      def index():
          return jsonify(host=socket.gethostname(), ip=request.remote_addr,
                         headers=dict(request.headers), env=dict(os.environ))
      @app.route(\"/healthz\")
      def health(): return jsonify(status=\"ok\")
      app.run(host=\"0.0.0.0\", port=8000)
      '"
    networks:
      - lab-net
    environment:
      - INSTANCE=app-3
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 256M

networks:
  lab-net:
    driver: bridge
    ipam:
      config:
        - subnet: 10.10.50.0/24

conf.d/00-default-upstreams.conf (ajustado para Docker DNS)

upstream app_backend {
    # Docker DNS resolve nomes de serviço
    server app-1:8000 max_fails=3 fail_timeout=10s;
    server app-2:8000 max_fails=3 fail_timeout=10s;
    server app-3:8000 max_fails=3 fail_timeout=10s;
    keepalive 32;
}

Execução do laboratório

cd ~/lab-nginx-proxy
docker compose up -d --build

# Verificar logs
docker compose logs -f nginx-proxy

# Testar
curl -k https://localhost/healthz
curl -k https://localhost/
curl -k https://localhost/api/test

Resultado esperado: Respostas JSON alternando entre app-1, app-2, app-3 (Round Robin).

Teste de Failover

# Derrubar uma instância
docker compose stop app-2

# Testar novamente - deve responder apenas app-1 e app-3
for i in {1..10}; do curl -sk https://localhost/ | jq .host; done

Configuração avançada: Cache (proxy_cache)

# No http context (nginx.conf ou conf.d/03-cache.conf)
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=app_cache:100m 
                 max_size=1g inactive=60m use_temp_path=off;

# No server/location
location /api/public/ {
    proxy_cache app_cache;
    proxy_cache_valid 200 302 10m;
    proxy_cache_valid 404 1m;
    proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
    proxy_cache_lock on;
    proxy_cache_background_update on;
    add_header X-Cache-Status $upstream_cache_status;
    proxy_pass http://app_backend;
    include /etc/nginx/conf.d/proxy-params.conf;
}

Microcaching (para picos de tráfego extremo)

location / {
    proxy_cache app_cache;
    proxy_cache_valid 200 1s;           # Cache por apenas 1 segundo!
    proxy_cache_use_stale updating;
    proxy_cache_lock on;
    proxy_pass http://app_backend;
    include /etc/nginx/conf.d/proxy-params.conf;
}

Troubleshooting avançado

Debugging commands

# Testar configuração
nginx -t

# Verificar sintaxe e dump config resolvida
nginx -T

# Recarregar sem downtime
nginx -s reload

# Debug de conexão upstream
curl -v http://localhost/ --resolve app.example.com:443:127.0.0.1

# Analisar tempo de resposta por upstream
awk '$9 ~ /upstream_response_time/ {print $9}' /var/log/nginx/access.log

# Verificar conexões ativas
watch -n 1 'ss -tulnp | grep nginx'

Segurança (Hardening)

• server_tokens off: Remove versão do Nginx dos headers e páginas de erro.
• TLS 1.2/1.3 apenas: Desabilita TLS 1.0/1.1 e SSL.
• Cipher suites modernas: Use perfil Mozilla Intermediate ou Modern.
• OCSP Stapling: Reduz latência de validação de certificado.
• HSTS com preload: Força HTTPS no navegador.
• CSP restritivo: Mitiga XSS; teste em Report-Only antes.
• Rate Limiting: Protege contra brute force e DDoS de camada 7.
• Limit Request Body: client_max_body_size previne upload bombs.
• Disable directory listing: autoindex off (padrão).
• Run as non-root: No Docker, use user: "101:101" (UID do usuário nginx no Alpine).
• Read-only root filesystem: read_only: true no Docker Compose + volumes temporários.

# Docker Compose security hardening
services:
  nginx-proxy:
    security_opt:
      - no-new-privileges:true
    read_only: true
    tmpfs:
      - /var/cache/nginx
      - /var/run
      - /tmp
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
      - CHOWN
      - SETGID
      - SETUID

Boas práticas

Tabela Comparativa: Algoritmos de Balanceamento

Conclusão

O Nginx como reverse proxy é a espinha dorsal de arquiteturas modernas: desacopla clientes de serviços, centraliza segurança e observabilidade, e fornece performance excepcional. Dominar suas diretivas de proxy, upstreams, SSL, cache e rate limiting permite construir sistemas resilientes, escaláveis e seguros — seja em bare metal, VMs, Docker ou Kubernetes.

Perguntas Frequentes (FAQ)

Q1: Nginx Open Source vs Nginx Plus — vale a pena pagar?
R: Para 95% dos casos, a versão OSS é suficiente. O Plus adiciona health checks ativos avançados, dynamic reconfiguration via API, session persistence (sticky cookies), JWT validation e suporte comercial. Em Kubernetes, o Ingress NGINX Controller (OSS) já cobre a maioria das necessidades.

Q2: Como fazer zero-downtime reload do Nginx?
R: nginx -s reload envia sinal HUP ao master process; workers antigos terminam conexões atuais (graceful shutdown) enquanto novos workers iniciam com a nova config. Garanta worker_shutdown_timeout adequado.

Q3: Posso usar Nginx para proxy de bancos de dados (PostgreSQL/MySQL)?
R: Sim, via stream {} block (TCP/UDP proxy). Mas para DB, considere PgBouncer (PostgreSQL) ou ProxySQL (MySQL) que entendem o protocolo e fazem pooling de conexões real.

Q4: Como debugar proxy_pass com variáveis?
R: Variáveis em proxy_pass desabilitam resolução de upstream no parse time. Use resolver e force set $upstream http://backend; + proxy_pass $upstream;. Verifique com proxy_intercept_errors on e error_page.

Próximo passo

Agora que você domina Nginx E Reverse Proxy, o próximo passo lógico da nossa trilha de aprendizado é continuar desenvolvendo suas habilidades.

→ Continue: Traefik com Docker

Artigos relacionados

Estes artigos complementam o conteúdo apresentado:

• Nginx