Home / Nginx / Nginx Upstream Timed Out

Nginx

Nginx Upstream Timed Out

Fix upstream timed out errors when backend servers don't respond within timeout limits

Published: Nov 19, 20257 min readBy FixWikiHub Editorial Team

Abstract illustration for a troubleshooting knowledge base category.

Introduction

Nginx is successfully forwarding requests to the upstream backend server, but the backend is not responding within the configured timeout period. The request times out and Nginx returns an error to the client. This typically happens with slow backends, long-running processes, or overloaded servers.

Symptoms

```bash $ tail -f /var/log/nginx/error.log 2024/01/01 12:00:00 [error] upstream timed out (110: Connection timed out) while reading response header from upstream, client: 192.168.1.1, server: example.com, request: "GET /api/data HTTP/1.1", upstream: "http://127.0.0.1:3000/api/data"

$ curl http://localhost/api/data <html> <head><title>504 Gateway Time-out</title></head> <body> <center><h1>504 Gateway Time-out</h1></center> </body> </html>

# Sometimes 502 instead HTTP/1.1 502 Bad Gateway # With log: upstream prematurely closed connection

# Browser shows: # 504 Gateway Time-out # nginx ```

Common Causes

1.Slow backend processing: Backend takes longer than timeout to respond
2.Backend overloaded: Server under heavy load, queuing requests
3.Long-running operations: Database queries, file processing, API calls
4.Default timeout too short: 60 seconds may not be enough
5.Backend hanging: Application stuck or deadlocked
6.Network latency: Slow connection between Nginx and backend
7.Connection pool exhausted: No available backend connections
8.Backend crashed during request: Process died mid-response

Step-by-Step Fix

1.Check logs for specific error messages
2.Verify configuration settings
3.Test network connectivity
4.Review recent changes
5.Apply corrective action
6.Verify the fix

Step 1: Identify the Timeout Type

Different timeout errors indicate different issues:

```bash # Check error logs grep "timed out" /var/log/nginx/error.log

# Types of timeout errors: # (110: Connection timed out) - Cannot connect to upstream # (110: Connection timed out) while reading - Upstream not responding # (110: Connection timed out) while sending - Upstream not receiving

# Check current timeout settings grep -r "timeout" /etc/nginx/ | grep proxy nginx -T 2>/dev/null | grep timeout ```

Step 2: Check Backend Performance

Verify backend response times:

```bash # Test backend directly time curl http://127.0.0.1:3000/api/data

# Check backend logs tail -f /var/log/app/error.log

# Check backend process status ps aux | grep node ps aux | grep python systemctl status php-fpm

# Monitor backend resources top -p $(pgrep -f "node server") htop

# Check database connections # For PostgreSQL psql -c "SELECT count(*) FROM pg_stat_activity;" # For MySQL mysql -e "SHOW PROCESSLIST;" ```

Step 3: Increase Proxy Timeouts

Adjust timeout settings in Nginx:

```nginx location /api { proxy_pass http://backend;

# Connection timeout (time to establish connection) proxy_connect_timeout 300s;

# Read timeout (time to wait for response) proxy_read_timeout 300s;

# Send timeout (time to send request to upstream) proxy_send_timeout 300s;

# For very long operations proxy_read_timeout 600s; # 10 minutes } ```

Timeout recommendations: ```nginx # Fast APIs (< 5 seconds response) proxy_read_timeout 30s; proxy_connect_timeout 10s;

# Normal APIs (5-30 seconds) proxy_read_timeout 60s; proxy_connect_timeout 30s;

# Long operations (database queries, file processing) proxy_read_timeout 300s; proxy_connect_timeout 60s;

# Very long operations (reports, exports) proxy_read_timeout 600s; ```

Step 4: Configure Upstream Timeouts

Set timeouts in upstream block:

```nginx upstream backend { server 127.0.0.1:3000;

# Keepalive connections keepalive 32; keepalive_timeout 60s; keepalive_requests 100; }

server { location / { proxy_pass http://backend; proxy_http_version 1.1; proxy_set_header Connection "";

proxy_connect_timeout 60s; proxy_read_timeout 300s; } } ```

Step 5: Fix Slow Backend Operations

Optimize backend performance:

```bash # Identify slow operations # Check application logs for slow queries tail -f /var/log/app/slow.log

# Profile backend # Node.js node --prof server.js # Python python -m cProfile app.py

# Database optimization # Add indexes CREATE INDEX idx_column ON table(column);

# Use connection pooling # In app configuration pool_size: 10 max_overflow: 20

# Cache expensive operations # Implement Redis caching ```

Backend timeout configuration: ```javascript // Node.js Express app.use('/api/data', (req, res) => { req.setTimeout(300000); // 5 minutes res.setTimeout(300000); });

// Set server timeout server.timeout = 300000; ```

python

# Python Flask
@app.route('/api/data')
def data():
    # Increase timeout for this route
    return Response(generate_data(), direct_passthrough=True)

Step 6: Configure Nginx Error Handling

Handle timeouts gracefully:

```nginx location /api { proxy_pass http://backend; proxy_read_timeout 300s;

# What to do on upstream failure proxy_next_upstream error timeout http_502 http_503 http_504; proxy_next_upstream_tries 3; proxy_next_upstream_timeout 60s;

# Custom error page error_page 504 = @timeout; }

location @timeout { default_type application/json; return 504 '{"error": "Request timed out", "retry": true}'; } ```

Step 7: Add Upstream Health Checks

Monitor backend health:

```nginx upstream backend { server 127.0.0.1:3000 max_fails=5 fail_timeout=30s; server 127.0.0.1:3001 max_fails=5 fail_timeout=30s backup;

# Fail tracking # max_fails: Number of failed requests before marking down # fail_timeout: Time to wait before retrying }

location / { proxy_pass http://backend;

# Passive health check proxy_next_upstream error timeout; } ```

For active health checks (Nginx Plus or with module): ```nginx upstream backend { zone backend 64k;

server 127.0.0.1:3000;

health_check interval=5s fails=3 passes=2; health_check_timeout 5s; } ```

Step 8: Implement Request Caching

Cache responses to reduce timeout risk:

```nginx # Cache configuration proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=api_cache:10m max_size=100m inactive=60m;

location /api { proxy_pass http://backend; proxy_read_timeout 300s;

# Enable caching proxy_cache api_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;

# Serve stale cache on timeout proxy_cache_use_stale timeout;

add_header X-Cache-Status $upstream_cache_status; } ```

Step 9: Use Streaming for Long Responses

Stream large responses:

```nginx location /api/export { proxy_pass http://backend;

# Disable buffering for streaming proxy_buffering off;

# Or minimal buffering proxy_buffer_size 4k; proxy_buffers 4 4k;

# Longer timeout for exports proxy_read_timeout 600s; } ```

Step 10: Monitor Timeout Metrics

Track timeout occurrences:

```nginx # Add custom log format log_format timed '$remote_addr - $remote_user [$time_local] ' '"$request" $status $body_bytes_sent ' '"$http_referer" "$http_user_agent" ' 'rt=$request_time uct="$upstream_connect_time" ' 'uht="$upstream_header_time" urt="$upstream_response_time"';

access_log /var/log/nginx/access.log timed; ```

```bash # Analyze slow requests awk '$14 > 30' /var/log/nginx/access.log # Requests > 30s

# Check upstream response times cat /var/log/nginx/access.log | grep -E "urt=[0-9]{3,}"

# Monitor in real-time tail -f /var/log/nginx/access.log | awk '{print $14}' ```

Verification

Confirm timeouts are resolved:

```bash # Test slow endpoint time curl http://localhost/api/data # Should complete within timeout

# Check error logs for timeouts grep "timed out" /var/log/nginx/error.log | tail -20 # Should see no new timeout errors

# Monitor response times tail -f /var/log/nginx/access.log

# Test multiple requests for i in {1..5}; do echo "Request $i:" time curl -s http://localhost/api/data > /dev/null done

# Check upstream status curl http://localhost/nginx_status

# Verify configuration sudo nginx -t ```

Requests should now complete successfully without 504 timeout errors.

[Nginx troubleshooting: Fix Lambda Permission Denied - Complete ](fix-lambda-permission-denied)
[Nginx web server troubleshooting: Fix Client Max Body Size Large Upload Nginx Issue ](client-max-body-size-large-upload-nginx)
[Fix Apache 502 Proxy Error](fix-apache-502-proxy-error)
[Fix Apache LogLevel Core Debug Configuration](fix-apache-loglevel-core-debug)
[Fix Cloudflare 502 Bad Gateway Error](fix-cloudflare-502-bad-gateway)

Was this guide helpful?

Related search paths

People also search for

If the symptom is close but not identical, these search paths usually surface the right neighboring fixes faster than scrolling the full archive.

Nginx Upstream Timed Out Nginx Upstream Timed Out Nginx Nginx Upstream Timed Out troubleshooting Nginx Upstream Timed Out fix Fix upstream timed out errors when backend servers don't respond within timeout limits Nginx Fix upstream timed out errors when backend servers don't respond within timeout limits

Explore Related Topics

Browse Guides from Other Categories

Discover troubleshooting guides from related categories to expand your knowledge.

FAQ

Nginx Troubleshooting FAQs

Common questions about troubleshooting and preventing similar issues

How do I know if this nginx-errors troubleshooting guide applies to my situation?

This guide is designed for nginx-errors issues. If you're experiencing similar symptoms described in the article, follow the step-by-step instructions. Start with the most common causes and work through the diagnostic process.

Is it safe to follow these nginx-errors troubleshooting steps?

Yes, all steps are designed to be safe and non-destructive. We recommend creating backups before making significant changes and testing each step before proceeding to the next.

How long does it typically take to resolve this type of nginx-errors issue?

Most nginx-errors issues can be resolved within 30 minutes to 2 hours, depending on the complexity and root cause. Follow the troubleshooting flow to identify and fix the problem efficiently.

How can I prevent this nginx-errors issue from happening again?

Regular maintenance, monitoring, and following best practices for nginx-errors configuration can help prevent recurrence. Consider implementing automated checks and alerts for early detection.

Written by

FixWikiHub Editorial Team

Our editorial team consists of experienced DevOps engineers, systems administrators, and cloud architects with hands-on experience in production environments across AWS, Azure, GCP, and on-premises infrastructure.

Every guide undergoes technical review for accuracy and is updated when software versions, commands, or best practices change.

Last updated: Nov 19, 2025

About our team

Important Notice

Disclaimer & Safety Guidelines

The troubleshooting steps in this guide are provided for educational and informational purposes. Before applying any changes to production systems:

Test in a staging environment first — Always verify commands and configurations in a non-production environment before deploying to live systems.
Create backups — Ensure you have current backups of databases, configurations, and critical files before making changes.
Understand the impact — Review how each step may affect your specific environment, dependencies, and users.
Consult official documentation — This guide supplements, but does not replace, official vendor documentation and best practices.

FixWikiHub is not responsible for any damages arising from the use of this content. See our Terms of Use for more information.

Resources

Official Documentation & Further Reading

For authoritative information, consult the official documentation for the technologies discussed in this guide. Our troubleshooting content supplements, but does not replace, vendor documentation.

AWS Documentation — Official Amazon Web Services guides and API references
Kubernetes Documentation — Official Kubernetes documentation
Nginx Documentation — Official Nginx web server documentation
Apache Documentation — Official Apache HTTP Server documentation
Docker Documentation — Official Docker container documentation

Nginx Upstream Timed Out

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Identify the Timeout Type

Step 2: Check Backend Performance

Step 3: Increase Proxy Timeouts

Step 4: Configure Upstream Timeouts

Step 5: Fix Slow Backend Operations

Step 6: Configure Nginx Error Handling

Step 7: Add Upstream Health Checks

Step 8: Implement Request Caching

Step 9: Use Streaming for Long Responses

Step 10: Monitor Timeout Metrics

Verification

People also search for

Browse Guides from Other Categories

WordPress

SSL

DNS

Nginx Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading

Nginx Upstream Timed Out

Introduction

Symptoms

Common Causes

Step-by-Step Fix

Step 1: Identify the Timeout Type

Step 2: Check Backend Performance

Step 3: Increase Proxy Timeouts

Step 4: Configure Upstream Timeouts

Step 5: Fix Slow Backend Operations

Step 6: Configure Nginx Error Handling

Step 7: Add Upstream Health Checks

Step 8: Implement Request Caching

Step 9: Use Streaming for Long Responses

Step 10: Monitor Timeout Metrics

Verification

Related Articles

People also search for

Share this guide

More Nginx Troubleshooting Guides

Browse Guides from Other Categories

Nginx Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading