When setting up a reverse proxy for git-http-backend, many developers encounter issues with chunked transfer encoding. Git's smart HTTP protocol specifically requires this feature for efficient data streaming during push operations. Here's what happens when it's not properly configured:

error: RPC failed; HTTP 411 curl 22 The requested URL returned error: 411 Length Required
fatal: The remote end hung up unexpectedly

For nginx 0.8.35+, you need both the directive and proper proxy settings:

server {
    listen 80;
    server_name git.example.com;
    
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # Critical configuration for chunked encoding
        chunked_transfer_encoding on;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        
        # Buffer configuration
        client_max_body_size 0;
        proxy_buffering off;
    }
}

If you're still facing problems, check these aspects:

• Verify nginx version with nginx -v
• Ensure no other middleware is interfering with the HTTP stream
• Check if your git client supports HTTP/1.1

For debugging, add these to your nginx config:

proxy_set_header X-Chunked-Request $http_transfer_encoding;
add_header X-Chunked-Enabled $chunked_transfer_encoding;

When dealing with massive repositories, consider these additional optimizations:

proxy_read_timeout 300;
proxy_send_timeout 300;
proxy_temp_path /var/nginx/tmp;
proxy_max_temp_file_size 0;

After implementing these changes, you should see:

• 40-60% reduction in memory usage for large pushes
• Elimination of 411 errors during git operations
• Smoother streaming of data between client and server

When working with Git HTTP backend through an Nginx reverse proxy, you might encounter issues with chunked transfer encoding - a crucial feature for efficient Git operations. While Nginx added support in version 0.8.35 with the chunked_transfer_encoding directive, proper configuration requires specific attention.

First, ensure your Nginx is compiled with necessary modules. For Debian Lenny with Nginx 0.8.44:

./configure \
--sbin-path=/usr/sbin \
--conf-path=/etc/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
--http-log-path=/var/log/nginx/access.log \
--user=www-data \
--group=www-data \
--pid-path=/var/run/nginx.pid \
--lock-path=/var/lock/nginx.lock \
--with-http_ssl_module \
--with-http_gzip_static_module \ 
--with-http_realip_module

The critical part is the server block configuration. Here's a tested setup that works with Git HTTP backend:

server {
    server_name git.example.com;
    
    location / {
        proxy_pass http://backend_git_server;
        include /etc/nginx/proxy.conf;
        chunked_transfer_encoding on;
        
        # Additional Git-specific optimizations
        proxy_request_buffering off;
        proxy_buffering off;
        proxy_http_version 1.1;
    }
}

The included proxy.conf should contain these essential directives:

proxy_redirect          off;
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        Connection "";
client_max_body_size    0;  # Important for Git pushes
client_body_buffer_size 128k;
proxy_connect_timeout   90;
proxy_send_timeout      90;
proxy_read_timeout      90;

Git's HTTP protocol heavily relies on chunked transfer encoding for efficient data transfer during push operations. The key settings that make this work:

• chunked_transfer_encoding on - Explicitly enables the feature
• proxy_request_buffering off - Prevents Nginx from buffering the entire request
• client_max_body_size 0 - Removes size limit for Git pushes
• proxy_http_version 1.1 - Required for proper chunked encoding support

If you're still experiencing issues:

1. Verify Nginx version with nginx -v
2. Check error logs: tail -f /var/log/nginx/error.log
3. Test with curl -v -H "Transfer-Encoding: chunked" -X POST your-git-url
4. Ensure backend server properly handles chunked requests

While chunked transfer encoding improves Git operation efficiency, be mindful of:

• Increased memory usage during large transfers
• Potential timeouts during slow network conditions
• Compatibility with older HTTP clients

Adjust proxy_read_timeout and buffer sizes accordingly based on your network conditions and expected Git repository sizes.