Can fastapi proxy another site as a response to the request?

[hkhk366]

This may be a silly question. Can fastapi proxy another site as a response to the request?

I did some research. All pages I found are Nginx reverse proxy fastapi. I already did that to solve the SSL problem.

My system workflow:

RedirectResponse is a rewrite, not a proxy.
Static Files are for local files.
HTMLResponse is for static HTML.

Can you give me some tips on how to proxy another site in fastapi? Thank you.

[eelkeh]

I have the same issue! Did you find a solution?

[mickeypash]

This is not quite working but it might be a start?

from fastapi import FastAPI, Response
import requests

app = FastAPI()

def _proxy(*args, **kwargs):
    t_resp = requests.request(
        method="GET",
        url="https://google.com/",
        allow_redirects=False)

    response = Response(content=t_resp.contents, status_code=t_resp.status_code)
    return response

@app.get("/")
def proxy():
    return _proxy()

[thomascrha]

How would I allow any path to be resolved by the proxy ? With flask you can do something like this

from flask import Flask
from requests import get

app = Flask('__main__')
SITE_NAME = 'https://google.com/'

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def proxy(path):
  return get(f'{SITE_NAME}{path}').content

app.run(host='0.0.0.0', port=8080)

Can I allow wildcard paths with fastAPI ?

[eelkeh]

Any change that anyone made progress with this? I'm still looking for a solution

[jtbaker]

@eelkeh @thomas-maschler I just ran into this myself and found it was covered in the docs here referencing accessing a file system. A proxy should resolve the path same way.

from fastapi import FastAPI

app = FastAPI()


@app.get("/files/{file_path:path}")
async def read_file(file_path: str):
    return {"file_path": file_path}

so my proxy use case will look like:

@app.get(“/tiles/{path:path}”)
async def tile_request(path: str, response: Response):
    async with httpx.AsyncClient() as client:
        proxy = await client.get(f“http://containername:7800/{path}”)
    response.body = proxy.content
    response.status_code = proxy.status_code
    return response

[morty29]

For larger file and smaller memory footprint you can stream the file like this as described in httpx docs here:

client = AsyncClient(base_url=f'http://containername:7800/')

@app.get(“/tiles/{path:path}”)
async def tile_request(path: str):
    req = client.build_request("GET", path)
    r = await client.send(req, stream=True)
    return StreamingResponse(
        r.aiter_raw(),
        background=BackgroundTask(r.aclose),
        headers=r.headers
   )

[aebrahim]

I found this thread, and I thought I'd add my complete example in case someone else stumbles across it:

from starlette.requests import Request
from starlette.responses import StreamingResponse
from starlette.background import BackgroundTask

import httpx

client = httpx.AsyncClient(base_url="http://containername:7800/")

async def _reverse_proxy(request: Request):
    url = httpx.URL(path=request.url.path,
                    query=request.url.query.encode("utf-8"))
    rp_req = client.build_request(request.method, url,
                                  headers=request.headers.raw,
                                  content=await request.body())
    rp_resp = await client.send(rp_req, stream=True)
    return StreamingResponse(
        rp_resp.aiter_raw(),
        status_code=rp_resp.status_code,
        headers=rp_resp.headers,
        background=BackgroundTask(rp_resp.aclose),
    )

app.add_route("/titles/{path:path}",
              _reverse_proxy, ["GET", "POST"])

[xifarm]

thanks.

client.send(rp_req, stream=True) is good.

by the way:
client.stream and return by StreamingResponse will issue: stream is close bug.

[papb]

Hello @aebrahim and others, what if the request we want to proxy is streaming a lot of data as input? The solution by @aebrahim waits for all the request input to arrive first, and then will end up sending it all at once to the target server, am I right? If yes, do you have any idea on how to update the solution to better cover this case as well? Thank you very much!!

Also, any reason for using only GET and POST? Is it safe to assume that all other existing HTTP methods will work too?

[papb]

Also, in my opinion, this issue should be reopened and considered a feature request.

[mglowinski93]

@aebrahim
It's a nice solution:)

Have you tried to make it work also with html page with static files?

[JarroVGIT]

Hello @aebrahim and others, what if the request we want to proxy is streaming a lot of data as input? The solution by @aebrahim waits for all the request input to arrive first, and then will end up sending it all at once to the target server, am I right?

No, this is not correct. It provides an generator that is passed to the StreamingResponse. As it receives a chunk of data, it will pass that chunk of data through to your client.

Update: I was incorrect.

[papb]

Hello @aebrahim and others, what if the request we want to proxy is streaming a lot of data as input? The solution by @aebrahim waits for all the request input to arrive first, and then will end up sending it all at once to the target server, am I right?

No, this is not correct. It provides an generator that is passed to the StreamingResponse. As it receives a chunk of data, it will pass that chunk of data through to your client.

@JarroVGIT are you sure? I think you're confusing input with output. I agree that their solution correctly streams the output of the target server (e.g. for downloading a large file from the target server). That's where the StreamingResponse comes in. However, I don't see anything that would do the same for the request (i.e. there's nothing like a StreamingRequest in their solution. Rather, what I see is an await request.body() which indicates what I said, that all the input is awaited before doing anything else.

[JarroVGIT]

The rp_resp is not yet fully loaded. Then, the streaming response is created with a generator, created from the rp_resp object (which starts the stream).

I am not sure where you see await request.body()?

My bad, sorry.

[morty29]

@papb I think streaming requests on httpx doc is what you are looking for. Meaning just remove the await from the assignment of content parameter in build request call in @aebrahim's answer and you are good

[papb]

@JarroVGIT await request.body() is definitely there, just look again maybe :)

@morty29 oh cool, thanks, I will try that.

[JarroVGIT]

@JarroVGIT await request.body() is definitely there, just look again maybe :)

@morty29 oh cool, thanks, I will try that.

Whelp, you are right, my apologies!

[JarroVGIT]

@papb does the large request come in with uploaded files or with just a huge request body?

[papb]

@JarroVGIT No problem :) Thank you for all the attention so far.

@papb does the large request come in with uploaded files or with just a huge request body?

I don't have a specific request in mind, so please assume that both cases may happen. My goal is to understand how to make the best possible reverse-proxy-like API handler in FastAPI. The solution by @aebrahim covered all cases I could think of except for requests with nontrivial inputs (such as a huge request body), so that's why I asked about that.

By the way I saw you recommending just using a real reverse proxy in a comment for another issue, and for my use case I am currently doing just that (using mitmproxy), but I found it cumbersome to have something else running along FastAPI (since I need more things than just a reverse-proxy). I feel that the suggestion by @morty29 probably works, I just haven't had the time to try it out yet.

[sykire]

To pass incoming request streaming data just pass request.stream() as content=

from starlette.requests import Request
from starlette.responses import StreamingResponse
from starlette.background import BackgroundTask

import httpx

client = httpx.AsyncClient(base_url="http://containername:7800/")

async def _reverse_proxy(request: Request):
    url = httpx.URL(path=request.url.path,
                    query=request.url.query.encode("utf-8"))
    rp_req = client.build_request(request.method, url,
                                  headers=request.headers.raw,
                                  content=request.stream())
    rp_resp = await client.send(rp_req, stream=True)
    return StreamingResponse(
        rp_resp.aiter_raw(),
        status_code=rp_resp.status_code,
        headers=rp_resp.headers,
        background=BackgroundTask(rp_resp.aclose),
    )

app.add_route("/titles/{path:path}",
              _reverse_proxy, ["GET", "POST"])

[WSH032]

@mishrakeshav

What if I want to pass the request to a external domain, like "https://example.com/"
I tried using this the same code, but getting 404 error.
As, in the example we are passing the request to a container which is in the same machine.

headers=request.headers.raw,

Refer to https://developer.mozilla.org/docs/Web/HTTP/Headers/Host

The key reason is that you passed unmodified headers, in which the host field is your Starlette server address instead of the host of https://example.com/.

As a result, https://example.com/ rejected your request.

You can modified the header in this way:
https://github.com/WSH032/fastapi-proxy-lib/blob/ea58f66bcce5fdfa9a30ed992a3acbb2d34e23b5/src/fastapi_proxy_lib/core/_tool.py#L452-L457

[MattPChoy]

I've attempted to implement this, proxying a react-vite frontend and have encountered the following errors in the console:

I have tried to modify by adding the MIME type to the header but still is unsuccessful.

async def _reverse_proxy(request: Request):
    url = httpx.URL(path=request.url.path, query=request.url.query.encode('utf-8'))
    rp_req = client.build_request(request.method, url, headers=request.headers.raw, content=request.stream())
    rp_resp = await client.send(rp_req, stream=True)

    headers = rp_resp.headers
    # Check if the response Content-Type is application/json and override it if necessary
    if headers.get("Content-Type", "").startswith("application/json") and not (request.url.path.endswith(".json") or request.url.path.endswith(".tsx")):
        headers["Content-Type"] = "text/plain"

    return StreamingResponse(
        rp_resp.aiter_raw(),
        status_code=rp_resp.status_code,
        headers=rp_resp.headers,
        background=BackgroundTask(rp_resp.aclose),
    )

[monchin]

Hello @sykire , I tried your code and it works in many scenes. But when I tried it on uploading files, it failed. My code is

from fastapi import FastAPI, File, Request, UploadFile
from pydantic import BaseModel
import httpx
aclient = httpx.AsyncClient()

class FileReq(BaseModel):
    file_loc: str
    need_proxy: bool
app = FastAPI()

@app.post("/upload")
async def upload_file(request: Request, file_req:FileReq, file:UploadFile=File(...)):
    if file_req.need_proxy:
        return await _reverse_proxy(request)
    # Do something

But when I want to upload a file with need_proxy=True, I got 500 Internal Server Error and RuntimeError: Stream consumed. I guess it's because the UploadFile parameter. Do you know how to solve it?

[sykire]

Yes, I think is because of the FileUpload, I'm not using FastAPI right now but I'll assume there is behavior on the framework that consumes the stream before passing to the proxy. It could be better to pass the request as raw as possible, trying to circumvent the framework.

After my response I tested more and got to the realization that using FastAPI or even Python is not a good decision, it could be useful for a quick development environment, but for any other case is better to use a proper reverse proxy like NGINX, traefik, Caddy or others.

[monchin]

Thank you for your kind reply! I'll try passing the request as raw.

[ljleb]

Is there any straightforward way to also reverse proxy any websocket routes, any static files, any resource, any route, through a particular base route for another server? For example, METHOD protocol://myproxy.example.com/other-server/... proxies to METHOD protocol://my-private-server.example.com/..., where METHOD is any method, and protocol is any protocol. Or do I have to add an additional special case for websockets for example?

[ljleb]

For context, this is my use case: ModelSurge/sd-webui-comfyui#82 (comment)
comfyui is a web user interface that relies on websockets, among other technologies. I want to create a proxy in the main server that serves as a middle man between comfyui and iframes in the applcation, so that users don't have to create 2 reverse proxies to use the extension online, for example in google colab.

[MRigal]

Here is another unanswered discussion (although aimed around a middleware) about how to achieve this for websocket also #9609

[ljleb]

FWIW I got it to work here a while ago: https://github.com/ModelSurge/sd-webui-comfyui/blob/2e274444c47e68c3ab73d38f6dd626a61d5a1780/lib_comfyui/webui/reverse_proxy.py#L70

[MRigal]

Thanks @ljleb ! I had to add subprotocols support to make it work for me, but this helped a lot! :-)

[gjmhmm8]

I am using the reverse_proxy function from [this comment] to proxy video urls in my fastapi app.
However, when I try to use it to proxy a video url, I get a lot of warnings like this:
WARNING:asyncio:socket.send() raised exception.
code：
@app.head("/proxy={url_path:path}", dependencies=[Depends(login_check)])
@app.get("/proxy={url_path:path}", dependencies=[Depends(login_check)])
async def reverse_proxy(url_path: str):
# Adapted from: #1788
url = httpx.URL(url_path)
headers = {}
if Context.hf_token is not None:
headers["Authorization"] = f"Bearer {Context.hf_token}"
rp_req = client.build_request("GET", url, headers=headers)
rp_resp = await client.send(rp_req, stream=True)
return StreamingResponse(
rp_resp.aiter_raw(),
status_code=rp_resp.status_code,
headers=rp_resp.headers, # type: ignore
background=BackgroundTask(rp_resp.aclose),
)

[WSH032]

Hi, every one here.

I encountered this issue a month ago. Then, I developed https://github.com/WSH032/fastapi-proxy-lib for it.

I implemented HTTP proxy based on the previous answers. Thanks to everyone!

I also implemented WebSocket proxy.

Hope it's helpful for newcomers to this.

---

from fastapi_proxy_lib.fastapi.app import reverse_http_app

app = reverse_http_app(base_url="http://www.example.com/foo/")

[MRigal]

Hi Good Job @WSH032 !

I went another way using python websockets rather than httpx-ws, so I won't be using your library. But you made a nice piece of software!

[WSH032]

Thanks !

To support the ecosystem of httpx.AsyncClient and implement lossless forwarding of headers, body, etc,
I chose httpx-ws as the backend.

If only need a simple WebSocket forwarding, python-websockets is also a good choice.

In any case, very glad to know that you resolved your issue.

[gjmhmm8]

Hi, I’m a user of your fastapi-proxy-lib and I really appreciate your work. I have a suggestion for improving the library. I think it would be useful to add a ProxyResponse class that can handle the response from the proxy server and provide some methods to access the status code, headers, and body of the response. This way, the user can easily manipulate the response data and return it to the client. I have written a detailed document on how to implement this class and what benefits it can bring. You can find it here: [ProxyResponse document]. I hope you will consider my suggestion and let me know what you think. Thank you for your time and effort.