How Can I Avoid `H11._util.LocalProtocolError` When Making Downstream HTTP Requests in a Concurrent FastAPI/Uvicorn Application?

Handling Downstream HTTP Requests in Uvicorn/FastAPI

When building an API endpoint using FastAPI/Uvicorn, it's common to make downstream HTTP requests. However, when handling multiple concurrent requests, developers may encounter an error:

H11._util.LocalProtocolError: can't handle event type ConnectionClosed when role=SERVER and state=SEND_RESPONSE

This error occurs because FastAPI's default request session is not fully thread-safe. To overcome this challenge, we need to adopt an alternative approach.

Using Httpx for Asynchronous HTTP Requests

One solution is to use the httpx library, which provides an async API. Instead of requests.Session(), we can use httpx.AsyncClient(). This client allows for concurrent requests to the same host, as the underlying TCP connection is reused.

In FastAPI, we can define our lifespan handler to initialize the AsyncClient on startup and close it on shutdown. For instance:

@asynccontextmanager
async def lifespan(app: FastAPI):
    async with httpx.AsyncClient() as client:
        yield {'client': client}  # Add the client to the app state

In our endpoints, we can access the client using request.state.client. We can make a downstream request as follows:

@app.get('/')
async def home(request: Request):
    client = request.state.client
    req = client.build_request('GET', 'https://www.example.com')
    r = await client.send(req, stream=True)
    return StreamingResponse(r.aiter_raw(), background=BackgroundTask(r.aclose))

Streaming vs. Non-streaming Responses

We can send the downstream response to the client in different ways. If we want to stream the response, we can create a StreamingResponse that uses a generator to asynchronously loop through the response data. Otherwise, we can use r.json(), PlainTextResponse, or a custom Response.

Benefits of using Httpx

Using httpx offers several benefits:

• Async API for efficient handling of concurrent requests.
• Persistent connection pool for improved performance.
• Control over connection pool size.
• Easy integration with FastAPI's lifespan handlers and endpoints.

By leveraging httpx, developers can effectively make downstream HTTP requests within their FastAPI/Uvicorn applications without encountering thread safety issues. This ensures reliable and scalable API behavior.

The above is the detailed content of How Can I Avoid `H11._util.LocalProtocolError` When Making Downstream HTTP Requests in a Concurrent FastAPI/Uvicorn Application?. For more information, please follow other related articles on the PHP Chinese website!