Root path is applied 2 times when using root_path

[mindej]

Here is error:

Python 3.7.8
fastapi 0.63.0

Run configuration:
uvicorn.run("app:app", host="0.0.0.0", port=port, reload=True)

I think the error is in the path here is console log:
127.0.0.1:54913 - "GET /api/v1/api/v1/openapi.json HTTP/1.1" 404 Not Found
Here is double path: /api/v1/api/v1/

Doc path is wrong http://localhost:8080/docs I expect it to be: http://localhost:8080/api/v1/docs

Here is the test code to reproduce 'test_app.py' file:

import uvicorn
import json
from fastapi import FastAPI, APIRouter, Response
from fastapi.responses import RedirectResponse

app = FastAPI(title="Root path test", root_path="/api/v1")

@app.post("/test-call ", tags=["test"])
def ping():
    return Response(
        json.dumps(dict(ping='pong')), 
        headers={'Content-Type':'application/json'})

@app.get("/")
def read_typer():
    return RedirectResponse('/docs')


if __name__ == "__main__":
    uvicorn.run("test_app:app", host="0.0.0.0", port=8080, reload=True)

[ycd]

Can you share your proxy settings?

[mindej]

I do not have a proxy. It is a local server. You can run it and test it locally.

Please run a file to reproduce: python3.7 test_app.py

[insomnes]

@mindej root_path is designated for behind the proxy cases, where you have something like NGINX, which publishes your web server with some prefix, like "/api/v1":
https://fastapi.tiangolo.com/advanced/behind-a-proxy/?h=root_#about-root_path
Maybe Router and prefix can help you achieve what you want:
https://fastapi.tiangolo.com/tutorial/bigger-applications/

[jintolonappan]

@mindej Are you trying to prefix all your end points with /api/v1?
If thats the case, I do not think the FastAPI() supports it. You may need to include it in each Router()

[krishnardt]

temp = APIRouter()
app = FastAPI()
app.include_router(temp, prefix='/api/v1')

this might help you.

if you require the path should be api/v1/docs, then you can update in the docs_url parameter of fastapi.

docs_url='/api/v1/docs',
redoc_url='/api/v1/redoc',

[NicolasRondon]

Like krishnardt says You can change the docs ulr. Documentation

[zxl777]

I also found this double bug. I followed the https://fastapi.tiangolo.com/advanced/behind-a-proxy operation, but did not succeed.

I think there should be a bug, please test it.

[ycd]

This is the expected behaviour, not a bug.

[intangir]

im seeing similar irritating issues with both lambdas served over an api gatewith with a prefix path

and locally, using both root_path and a router with a prefix

reading the EXACT DOCS from here https://fastapi.tiangolo.com/advanced/behind-a-proxy/ and setting up the root_path..

also using router it isn't working..

it always just serves things up as if the entire path is always the entire path regardless..

its incredibly infuriating reading doc after doc after doc and following all the the instructures verbatim and not a damn new thing making a damn bit of difference in how its served..

then finding people with the exact same issue being told 'expected behavior not a bug'

then what are these worthless features for? how should they work?

[insomnes]

Maybe i totally miss your point, but here are details about my suggestiions.

Router

If you need to place some family of handler with same prefix with direct publishing with your web server, you will need APIRouter:

from fastapi import FastAPI
from fastapi.routing import APIRouter


prefix_router = APIRouter()


@prefix_router.get("/path")
def handler():
    return "Hello world!"


app = FastAPI()
app.include_router(
    prefix_router,
    prefix="/prefix"
)

===>

http http://127.0.0.1:8000/prefix/path
HTTP/1.1 200 OK
content-length: 14
content-type: application/json
date: Mon, 10 May 2021 10:46:09 GMT
server: uvicorn

"Hello world!"

Docs at http://127.0.0.1:8000/docs

Root path

If you need to PUBLISH your app via some proxy with some ADDED prefix, you should use root_path:

from fastapi import FastAPI

app = FastAPI(root_path="/prefix")


@app.get("/path")
def handler():
    return "Hello world!"

Going directly to app docs at http://127.0.0.1:8000/docs will show error:

Going through proxy like traefik in docs in which you PUBLISHED your server with some prefix will help.
Publishing config for traefik (kinda same as FastAPI mentioned docs shows):
traefik.toml

[entryPoints]
  [entryPoints.http]
    address = ":9999"

[providers]
  [providers.file]
    filename = "routes.toml"

routes.toml

[http]
  [http.middlewares]

    [http.middlewares.api-stripprefix.stripPrefix]
      prefixes = ["/prefix"]

  [http.routers]

    [http.routers.app-http]
      entryPoints = ["http"]
      service = "app"
      rule = "PathPrefix(`/prefix`)"
      middlewares = ["api-stripprefix"]

  [http.services]

    [http.services.app]
      [http.services.app.loadBalancer]
        [[http.services.app.loadBalancer.servers]]
          url = "http://127.0.0.1:8000"

Request through traefik:

http http://127.0.0.1:9999/prefix/path 
HTTP/1.1 200 OK
Content-Length: 14
Content-Type: application/json
Date: Mon, 10 May 2021 10:59:41 GMT
Server: uvicorn

"Hello world!"

Docs through traefik at http://127.0.0.1:9999/prefix/docs

[chirag4semandex]

This thread gave me some hints. I found one missing link that helped me solved the openapi.json ( not_found ) issue. Here is what worked for me

I am using nginx as proxy server and FastAPI with Uvicorn. FastAPI and Uvicorn both have the root_path property and they both need to be set for nginx proxy to work properly.

For the openapi.json issue, we need to pass servers property in the FastAPI pointing to the proxy URL.

Here is the sample code for app

from pydantic import BaseSettings

class Settings(BaseSettings):
    app_dir: Path = Path(__file__).parents[1]
    base_path: str = "/app"


settings = Settings()


def create_app():
   app = FastAPI(
        title="MY_APP",
        servers=[{"url": settings.base_path}],
        root_path=settings.base_path,
    )
    return app


if __name__ == "__main__":
    uvicorn.run("app:create_app", host="0.0.0.0", port=8000, root_path=settings.base_path)

Here is a sample code for nginx setup

server {
    listen       443 ssl;
    server_name  localhost;
    ssl_certificate <YOUR_CERT_LOC>;
    ssl_certificate_key <YOUR_KEY_LOC>;

    location /app {
        rewrite ^/app/(.*)$ /$1 break;
        proxy_pass http://<APP_SERVICE_NAME>:<APP_LOCAL_PORT>/app;
    }
}

[santibreo]

I have not been able to make a working configuration similar to yours, and I think that FastAPI's root_path behaviour is odd.
I think the expected behaviour of FastAPI users:

• Use ApiRouter with some prefix when you want to "group" endpoints under a specific path beginning
• Use the FastAPI root_path argument when you are accessing the application behind a proxy using that path in the URL

The code from this repo easily checks all the things I am talking about. It must be as easy to run as cloning it and running docker compose up --build. I do not incorporate it into this comment to avoid making it even longer.

My FastAPI application has four things:

1. A root_path defined as /fastapi
2. A sub-application mounted at /app_mount/ path
3. A static files application mounted at /static/ path (with just a test image inside)
4. An APIRouter included in the main application under the prefix /app_router

By running this application with the following code:

    uvicorn.run(
        "__main__:app",
        host="0.0.0.0",
        port=40001,
        reload=True,
        #  root_path=app.root_path  # More on this later
    )

We find the following situation:

1. ☑ All the paths created with request.url_for(...) are prefixed by the root_path. Correct because this method is used to redirect or render URLs in templates, so this way, both will work when working behind a proxy
2. ❓All the paths work. NOT Correct because the root_path is going to be removed from the URLs when calling the proxy
3. ❓The main application and the APIRouter are served through the path that starts without the root_path and the path that starts with the root_path. NOT Correct because root_path might be duplicating your endpoints unnecessarily
4. ❓Both mounted applications are only served through the path that starts with the root_path. NOT Correct (same as 2.)

When running a proxy that redirects calls to the running application, you find the following situation:

• ☑ All the calls (when they reach the application) have the root_path removed from the URL. Correct because this is how a proxy is supposed to work
• ☑ Only the APIRouter paths work.
• ☠ None of the mounted applications work. as their endpoints are only reachable with root_path prefix.

Things I do not understand:

• Why are mounted applications only accessible to paths prefixed with root_path?
• How do you refer to API endpoints in the front when working behind a proxy?

I think the following schema is relatively straightforward and must be kept in mind when implementing the "composition" of applications:

Finally, as a comment, I would like more detail in the documentation about how FastAPI deals with APIRouter vs. Mounted Applications. Also, I think there are sentences in the documentation that should be avoided, like this one, because when that is not the reality, they feel quite awkward and feed users' frustration.

If you can answer my questions or provide some help, that would be greatly appreciated.

[felipe-trindade-neurotech]

I am also facing this problem. In my case, I'm using the proxy available in the AWS API Gateway, and it seems that I can only display the Swagger UI (or Redoc) locally or in the deployed API. I can't display both using the same code because of this duplication problem when using root_path. Did anyone figure it out?

[ningaro]

Awesome! It`s realy works great!

This thread gave me some hints. I found one missing link that helped me solved the openapi.json ( not_found ) issue. Here is what worked for me

I am using nginx as proxy server and FastAPI with Uvicorn. FastAPI and Uvicorn both have the root_path property and they both need to be set for nginx proxy to work properly.

For the openapi.json issue, we need to pass servers property in the FastAPI pointing to the proxy URL.

Here is the sample code for app

from pydantic import BaseSettings

class Settings(BaseSettings):
    app_dir: Path = Path(__file__).parents[1]
    base_path: str = "/app"


settings = Settings()


def create_app():
   app = FastAPI(
        title="MY_APP",
        servers=[{"url": settings.base_path}],
        root_path=settings.base_path,
    )
    return app


if __name__ == "__main__":
    uvicorn.run("app:create_app", host="0.0.0.0", port=8000, root_path=settings.base_path)

Here is a sample code for nginx setup

server {
    listen       443 ssl;
    server_name  localhost;
    ssl_certificate <YOUR_CERT_LOC>;
    ssl_certificate_key <YOUR_KEY_LOC>;

    location /app {
        rewrite ^/app/(.*)$ /$1 break;
        proxy_pass http://<APP_SERVICE_NAME>:<APP_LOCAL_PORT>/app;
    }
}

Awesome! It`s realy works great!

[pjwerneck]

FWIW, I was having the same problem on AWS Lambda+API Gateway when the root_path didn't start with /.

If I used root_path = "development" the docs endpoint would look up for the json file at development/development/openapi.json instead. Changing it to root_path = "/development" solved the problem.

[mattiaciollaro]

I wanted to confirm that I ran into the exactly same issue described by @pjwerneck. My context was exactly the same: API Gateway acting as a proxy and FastAPI configured in Lambda. In my case the additional piece of URL was the default stage name (prod) introduced by API Gateway.

I originally included root_path="prod" and I had no problem getting the openapi.json spec file. But I would see the duplicated root_path in all requests for docs or redoc instead.

Following the advice above (thanks for it @pjwerneck!), I then prepended / to the root_path value (root_path="prod" -> root_path="/prod") and the problem was solved. I could reach also docs and redoc without issues.

I doubt that the sensitivity to the leading slash is intended behavior for the root_path parameter... This does feel more like a bug.

[SKalt]

I experienced the double-root-path problem on an AWS Lambda + API Gateway with a custom domain with configured base path. Ensuring fastapi's root_path started with a / failed to prevent double-root-paths appearing in my access logs. What fixed my problem was passing fastapi's root path as Mangum's aws_api_gateway_root_path argument.

[ademoverflow]

@SKalt you made my day ! Actually the argument is named api_gateway_base_path, and in my specific case (Cloudront -> /api -> API Gateway -> Lambda -> Mangum -> FastAPI), it does the job perfectly !

[Christovftw]

Putting FastAPI behind an API Gateway/proxy/load balancer has been a huge chore for me and I'm not sure what the answer is for making this easier to understand but throwing this in for potential future travellers. I think the complication comes from cloud based gateways and us not being in direct control of their entire configuration. YMMV with this but this is what worked for me, I hope it helps someone!

My scenario is:

• FastAPI running in a custom docker container based on ubuntu
• Uvicorn running the ASGI server
• The container is deployed to google cloud run via terraform
• The cloud run is an 'internal only' cloud run that sits behind a Google Load Balancer
• The load balancer has a custom DNS setup so the IP of said DNS goes to customurl.com
• The load balancer then has a path match setup so if someone goes to customurl.com/myapi they are directed to the cloud run

The reason for the load balancer is so we can implement cloud armor (IP allowlisting for our use case primarily) against the cloud run container.

The config that worked for me was in the Dockerfile was:
CMD uvicorn api_main:app --host 0.0.0.0 --port 5000
Note that there's no root-path there.

inside my api_main.py is:
app = FastAPI(docs_url=None, redoc_url=None)
This is the "main" app, underneath there are two sub-apps:
app.mount(f"/myapi/v1", app_v1)
app.mount(f"/myapi/v2", app_v2)

These two sub-apps are defined with the FastAPI class:

app_v1 = FastAPI(
    docs_url="/docs", 
    redoc_url=None,
    openapi_url='/openapi.json',
    version='1.0'
    )

Both app_v1 and app_v2 are defined in this way, but have marginally different config like names and the version number. Notably, there is no root_path here either.

I have some routers setup and they are included like this:

from .routers import helloworld
app_v1.include_router(helloworld.router, include_in_schema=True)
app_v2.include_router(helloworld.router, include_in_schema=True)

This includes the router in app_v1 and app_v2, but note that it uses the same router for both, allowing you to serve the same content for both endpoints with one codebase to maintain should only one part of your app have changed between v1 and v2: You can keep the parts that haven't changed consistent. Notably there is no prefix here.

Now, when testing locally these addresses all work:
127.0.0.1:5000/myapi/v1 - gives me a hello world
127.0.0.1:5000/myapi/v1/docs - shows me the v1 docs
127.0.0.1:5000/myapi/v2 - gives me a hello world
127.0.0.1:5000/myapi/v2/docs - shows me the v2 docs

But more importantly when I deploy this to cloud run I can use the same paths with a new custom url:
customurl.com/myapi/v1 - gives me a hello world
customurl.com/myapi/v1/docs - shows me the v1 docs
customurl.com/myapi/v2 - gives me a hello world
customurl.com/myapi/v2/docs - shows me the v2 docs

This is a very basic working example using the above config

from fastapi import FastAPI

# define the main app that will have sub-apps mounted underneath it 
# this is done so we can have different versions of the api sub-mounted underneath
app = FastAPI(docs_url=None, redoc_url=None)

# set the api prefix, this should be the same as whatever the load balancer in front of it is set to
api_prefix = 'myapi'

# define the FastAPI app v1 and some options to go with it
# note that we don't set a root_path here or set the version paths (e.g. /v1), these are set in the top level app mount
app_v1 = FastAPI(
    docs_url=f"/docs", 
    redoc_url=None,
    openapi_url=f'/openapi.json',
    version='1.0',
    summary="this is version 1 of the app"
    )

# define the FastAPI app v2 and some options to go with it
app_v2 = FastAPI(
    docs_url=f"/docs", 
    redoc_url=None,
    openapi_url=f'/openapi.json',
    version='2.0',
    summary="this is version 2 of the app"
    )

# mount the sub-apps under the main app using the api_prefix
app.mount(f"/{api_prefix}/v1", app_v1)
app.mount(f"/{api_prefix}/v2", app_v2)

# import some routers to use and include them with the mounted apps
from routers import helloworld
app_v1.include_router(helloworld.router, include_in_schema=True)
app_v2.include_router(helloworld.router, include_in_schema=True)

And here's the basic hello world router that lives in routers/helloworld.py if anyone wants it for testing:

from fastapi.responses import JSONResponse
from fastapi import APIRouter, Request

router = APIRouter()

@router.get("/")
def helloworld(request: Request):
    return JSONResponse(content={"message":"Welcome to the API", "root_path":request.scope.get("root_path")}, status_code=200)

You'll get a response from the hello world endpoint like this:
{"message":"Welcome to the API","root_path":"/myapi/v1"}

[devraj]

I have spent some significant time trying to solve this as well. My setup has ALB forwarding requests to an EKS which runs FasAPI (and a Remix based front end). As we've all discovered ALB does not behave as a reverse proxy and forwards the requests in it's entirety (and does not strip the prefix, in my case /api). Problems I found while attempting to get FastAPI working with ALB:

• The /api prefix is forwarded not stripped
• Swagger UI fails to find openapi.json
• The try it out interfaces prefix /api a second time

I went through various iterations of my solution and finally settled on, a root router that prefixes everything else with a /api all other routers are included on the router_root:

from fastapi import APIRouter
from .auth import router as router_auth

router_root = APIRouter(prefix="/api")

router_root.include_router(
    router_auth,
)

The FastAPI app has three parameters provided for it all to work behind the ALB:

• openapi_url to make openapi.json be available at /api/openapi.json
• docs_url to make Swagger docs be available at /api/docs
• in swagger_ui_parameters overriding the api parameter to point to openapi.json at /api/openapi.json if you leave this out then the SwaggerUI appends a second /api on the url it tries to fetch

from fastapi import (
    FastAPI,
    Request,
    status,
    WebSocket,
)

from .routers import router_root

app = FastAPI(
    title=__title__,
    version=__version__,
    root_path="/api",
    root_path_in_servers=False,
    openapi_url="/api/openapi.json",  # Adds prefix for AWS loadbalancer
    description=settings.api_router.__doc__,
    docs_url="/api/docs",  # Adding prefix for AWS load balancer
    redoc_url=None,  # Decided not to serve these docs
    terms_of_service=settings.api_router.terms_of_service,
    contact=settings.api_router.contact,
    openapi_tags=settings.api_router.open_api_tags,
    generate_unique_id_function=generate_operation_id,
    swagger_ui_parameters={
        "url": "/api/openapi.json"  # To cater for AWS Loadbalancer not stripping prefix
    }
)

app.include_router(router_root)

If you are after the entire python project, it's available here on Github.

Note: the above changes are not in that repository as we typically don't use AWS.

[aidanrussell]

I just wanted to add my own use case here as another breadcrumb for the next person as I could see from this page that it must be the same issue, but none of the proposed solutions quite worked exactly as I needed. My use case is I am testing a FastAPI app on AWS Sagemaker including running with Uvicorn (hence, this isn't the production solution but a test case). For reasons I don't claim to understand, the right combination of parameters included a leading slash to openapi_url but removed from swagger_ui_parameters:

app = FastAPI(
    openapi_url='/proxy/openapi.json',  # for AWS Sagemaker
    swagger_ui_parameters={
        "url": "proxy/openapi.json"  # for AWS Sagemaker
    },
)