Implementera en API-gateway med FastAPI
Lär er bygga en API-gateway med FastAPI för att routa anrop och sammanställa svar från flera mikrotjänster.
Implementera en API-gateway med FastAPI är en gratis lektion i Bootcamp i backendutveckling med FastAPI på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med FastAPI, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.
Vad är en API Gateway?
Föreställ dig att dina mikrotjänster är olika butiker i ett köpcentrum. En API Gateway fungerar ungefär som köpcentrets huvudentré eller informationsdisk.
- Den är en gemensam ingång för alla klientanrop.
- Den dirigerar anrop till rätt backendtjänst.
- Den kan kombinera svar från flera tjänster.
- Den hanterar gemensamma uppgifter som autentisering eller loggning.
Detta håller klientapparna enklare och låter backendtjänsterna fokusera på sina uppgifter.
Varför FastAPI för en gateway?
FastAPI är ett utmärkt val för att bygga en API Gateway tack vare sina moderna funktioner:
- Asynkront: Det kan hantera många anrop samtidigt utan blockering, vilket passar perfekt för proxying.
- Hög prestanda: Det bygger på Starlette och Pydantic och är mycket snabbt.
- Enkel routning: FastAPIs intuitiva routning gör det enkelt att dirigera anrop.
- Dependency Injection: Hjälper till att hantera gemensamma resurser och logik effektivt.
Det fungerar som en lättviktig och kraftfull reverse proxy.
Grundidén: Proxying av anrop
En API Gateways huvudsakliga uppgift är att fungera som en proxy. Det innebär att den tar emot ett anrop från en klient, vidarebefordrar det till en backendtjänst och sedan skickar backendtjänstens svar tillbaka till klienten.
Vi använder biblioteket httpx i Python för att göra asynkrona HTTP-anrop till våra backendtjänster från vår FastAPI-gateway.
Kontrollera först att du har installerat httpx: pip install httpx
Grundläggande proxy för GET-anrop
Vi skapar en enkel FastAPI-gateway som proxar ett GET-anrop till ett offentligt dummy-API. Vår gateway-slutpunkt /proxy-todo hämtar en todo-post från jsonplaceholder.typicode.com.
import httpx
from fastapi import FastAPI
import uvicorn
app = FastAPI()
BACKEND_SERVICE_URL = "https://jsonplaceholder.typicode.com/todos/1"
@app.get("/proxy-todo")
async def proxy_todo_item():
async with httpx.AsyncClient() as client:
response = await client.get(BACKEND_SERVICE_URL)
response.raise_for_status() # Raises HTTPStatusError for 4xx/5xx responses
return response.json()
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)Vidarebefordra sökvägsparametrar
Backendtjänster behöver ofta dynamiska data i sina URL:er, så kallade sökvägsparametrar. Din API Gateway måste fånga upp dessa parametrar från klientens anrop och vidarebefordra dem till rätt backend-URL.
Här proxar vi anrop till /proxy-todos/{todo_id} och skickar todo_id till backend.
import httpx
from fastapi import FastAPI
import uvicorn
app = FastAPI()
BACKEND_BASE_URL = "https://jsonplaceholder.typicode.com"
@app.get("/proxy-todos/{todo_id}")
async def proxy_todo_item_by_id(todo_id: int):
async with httpx.AsyncClient() as client:
backend_url = f"{BACKEND_BASE_URL}/todos/{todo_id}"
response = await client.get(backend_url)
response.raise_for_status()
return response.json()
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)Hantera POST/PUT-begärandekroppar
För anrop som POST eller PUT skickar klienter data i begärandekroppen. Din API Gateway måste ta emot denna kropp och vidarebefordra den till backendtjänsten. FastAPIs Request-objekt ger oss åtkomst till den råa begärandekroppen.
Vi använder request.json() för att hämta JSON-kroppen och skicka den till httpx.
import httpx
from fastapi import FastAPI, Request
import uvicorn
app = FastAPI()
BACKEND_POST_URL = "https://jsonplaceholder.typicode.com/posts"
@app.post("/proxy-post")
async def proxy_create_post(request: Request):
body = await request.json() # Get the raw JSON body from the client
async with httpx.AsyncClient() as client:
# Forward the body to the backend service
response = await client.post(BACKEND_POST_URL, json=body)
response.raise_for_status()
return response.json()
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)Sammanfoga flera svar
En kraftfull funktion hos en API Gateway är svarssammanslagning. Det innebär att gatewayen kan anropa flera backendtjänster, kombinera deras individuella svar och returnera ett enda enhetligt svar till klienten.
Det minskar antalet anrop som klienten behöver göra, förenklar logiken på klientsidan och kan förbättra prestandan.
Exempel: Sammanfogning av användare och beställningar
Vi tittar på ett exempel där vår gateway hämtar användaruppgifter från en backend och sedan en lista med todo-poster för användaren från en annan, och sammanfogar dem till ett enda svar.
import httpx
from fastapi import FastAPI
import uvicorn
app = FastAPI()
BACKEND_USERS_URL = "https://jsonplaceholder.typicode.com/users"
BACKEND_TODOS_URL = "https://jsonplaceholder.typicode.com/todos"
@app.get("/user-with-todos/{user_id}")
async def get_user_with_todos(user_id: int):
async with httpx.AsyncClient() as client:
# Fetch user details
user_response = await client.get(f"{BACKEND_USERS_URL}/{user_id}")
user_response.raise_for_status()
user_data = user_response.json()
# Fetch todos for that user
todos_response = await client.get(f"{BACKEND_TODOS_URL}?userId={user_id}")
todos_response.raise_for_status()
todos_data = todos_response.json()
# Combine the data before returning
user_data["todos"] = todos_data
return user_data
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)Övergripande funktioner i gatewayen
Förutom routning och sammanfogning passar API Gateways perfekt för att hantera övergripande funktioner. Det är funktioner som behövs av många tjänster men som inte utgör en central del av någon enskild tjänsts affärslogik.
- Autentisering och auktorisering: Validera token en gång i gatewayen.
- Loggning och övervakning: Centraliserad loggning av anrop.
- Begränsning av anropsfrekvens: Skydda backendtjänster mot överbelastning.
- Cachning: Lagra vanliga svar i cache för snabbare leverans.
Detta avlastar de enskilda mikrotjänsterna.
Kontroll av gatewayfördelar
Vilka av följande är viktiga fördelar med att använda en API Gateway i en mikrotjänstarkitektur?
Sammanfattning: API Gateway med FastAPI
Du har lärt dig att bygga en kraftfull API Gateway med FastAPI!
- Vi förstod vad en API Gateway är och vilka fördelar den har.
- Vi använde FastAPIs asynkrona funktioner för effektiv proxying.
- Vi implementerade vidarebefordran av grundläggande GET-anrop, sökvägsparametrar och POST-kroppar.
- Vi utforskade hur svar från flera backendtjänster kan sammanfogas.
- Du såg också hur gateways centraliserar övergripande funktioner.
FastAPI erbjuder en robust och högpresterande grund för din mikrotjänstingång!
Lär dig Bootcamp i backendutveckling med FastAPI med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 21
- Lektioner
- 84
Vanliga frågor
Är lektionen ”Implementera en API-gateway med FastAPI” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Bootcamp i backendutveckling med FastAPI, inklusive ”Implementera en API-gateway med FastAPI”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.
Vad lär jag mig i ”Implementera en API-gateway med FastAPI”?
Lär er bygga en API-gateway med FastAPI för att routa anrop och sammanställa svar från flera mikrotjänster. Ni övar på Bootcamp i backendutveckling med FastAPI med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med FastAPI?
Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med FastAPI på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Implementera en API-gateway med FastAPI”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med FastAPI-lektionen?
Ja. Varje Bootcamp i backendutveckling med FastAPI-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Utforma en mikrotjänstarkitektur
- Kommunikation mellan tjänster
- Implementera en API-gateway med FastAPI
- Tjänsteidentifiering och hälsokontroller