Vi börjar med att gå igenom FastAPI:s viktigaste funktioner och centrala användningsområden. Sedan kör vi vår första applikation och testar den! Avslutningsvis går vi igenom hur GET- och POST-operationer fungerar med förfrågningsparametrar och bygger och testar de endpointerna.

Varför FastAPI?

Första applikationen

FastAPI vs. Django

GET-operationer

Hello world

Hej vem?

POST-operationer

Pydantic-modell

POST-operation i praktiken

Grunderna i FastAPI

Vi börjar med att lära oss hur man stöder PUT- och DELETE-operationer i FastAPI. Sedan går vi igenom hur man hanterar olika typer av fel och alltid returnerar en lämplig statuskod i svaret. Avslutningsvis lär vi oss att använda async för att möjliggöra parallella förfrågningar som klarar högre belastning.

PUT- och DELETE-operationer

PUT-operationen i praktiken

DELETE-operationen i praktiken

Hantera fel

Klassificering av statuskoder

Hantera ett klientfel

Använda async för samtidiga uppgifter

När ska man använda async?

Asynkron DELETE-operation

Avancerade ämnen i FastAPI

Vi börjar med att lära oss skriva systemtester för att validera enskilda FastAPI-endpoints. Sedan bygger vi ett komplett JSON CRUD API för att hantera objektlivscykler över HTTP. Avslutningsvis lär vi oss att testa hur olika endpoints i applikationen fungerar tillsammans med manuella funktionstester.

Automatiserad testning med FastAPI

Alternativ

Enhetstester

Systemtester

Enhetstester vs. systemtester

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {"scissors": Item(name="scissors", quantity=100)}


@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]

# Import TestClient
from fastapi.testclient import ____
from main import app

# Create test client with application context
client = TestClient(____)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": ____}

# Import TestClient
from fastapi.testclient import TestClient
from main import app

# Create test client with application context
client = TestClient(app)

def test_main():
    response = client.get("/items?name=scissors")
    assert response.status_code == 200
    assert response.json() == {"name": "scissors",
                               "quantity": 100}

Systemtest

Bygga ett JSON CRUD API

Create

Read

Update

HTTP-operationer och CRUD-steg

Svar på DELETE-operation

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.____("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.____("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    return items[name]  
  
@app.____("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=____, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional

# define model Item
class Item(BaseModel):
    name: str
    quantity: Optional[int] = 0

app = FastAPI()

items = {}


@app.post("/items")
def create(item: Item):
    name = item.name
    if name in items:
        raise HTTPException(status_code=409, detail="Item exists")
    items[name] = item
    return {"message": f"Added {name} to items."}
  
@app.get("/items")
def read(name: str):
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    return items[name]  
  
@app.put("/items")
def update(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    items[name] = item
    return {"message": f"Updated {name}."}
  
@app.delete("/items")
def delete(item: Item):
    name = item.name
    if name not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    del items[name]
    return {"message": f"Deleted {name}."}

Komplett JSON CRUD-API

Skriva ett manuellt funktionstest

Funktionstester

Systemtester vs. funktionstester

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == ____
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?____=____")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == ____

# Delete item "rock"
r = requests.delete(ENDPOINT, json={____: ____})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == ____

print("Test complete.")

import requests

ENDPOINT = "http://localhost:8000/items"

# Create item "rock" without providing quantity
r = requests.post(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Added rock to items."

# Verify that item "rock" has quantity 0
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 0

# Update item "rock" with quantity 100
r = requests.put(ENDPOINT, json={"name": "rock", "quantity": 100})
assert r.status_code == 200
assert r.json()["message"] == "Updated rock."

# Verify that item "rock" has quantity 100
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 200
assert r.json()["quantity"] == 100

# Delete item "rock"
r = requests.delete(ENDPOINT, json={"name": "rock"})
assert r.status_code == 200
assert r.json()["message"] == "Deleted rock."

# Verify that item "rock" does not exist
r = requests.get(ENDPOINT + "?name=rock")
assert r.status_code == 404

print("Test complete.")

Funktionellt test

Avslutning

Bygga och testa ett JSON CRUD API

Den här kursen lär dig att bygga produktionsklara webbapplikationer med FastAPI, ett populärt Python-ramverk för att skapa API:er. Du lär dig att hantera alla fyra HTTP-operationer, definiera scheman för förfrågningar och svar, validera API-förfrågningar och returnera lämpliga HTTP-statuskoder. Kursen täcker även asynkron kodexekvering för bättre prestanda. I slutet av kursen bygger du ett CRUD-API och testar arbetsflöden med Pythons requests-modul. Kursen riktar sig till erfarna Python-programmerare och ger dig verktygen för att hantera data med FastAPI – en solid grund för att bygga robusta datahanteringspipelines och pipelines för att driftsätta ML-modeller.

<h2>Introduktion till FastAPI och dess användningsområden</h2> API:er används ofta för att hantera data på webben, och FastAPI är ett populärt nytt webbframework för att bygga API:er med Python. Data- och maskininlärningsingenjörer använder FastAPI för att bygga applikationer som fungerar som kontextmedvetna datatransaktioner och pipelines på webben.<br><br> <h2>Bygg produktionsklara webbapplikationer med FastAPI</h2> I den här kursen lär du dig att bygga produktionsklara webbapplikationer genom att utnyttja dina Python-kunskaper med ramverket FastAPI. I slutet kommer du att förstå de viktigaste användningsområdena för FastAPI i relation till andra Python-webbramverk. Du lär dig att bygga API:er med alla fyra typerna av HTTP-operationer och definiera scheman för förfrågningar och svar. Dessutom kommer du att validera API-förfrågningar, svara med lämpliga HTTP-statuskoder och meddelanden samt köra kod asynkront för att förbättra applikationens prestanda. Ett praktiskt projekt guidar dig genom att bygga ett klassiskt CRUD-API (Create, Read, Update, Delete) och testa arbetsflöden med Python-modulen requests.<br><br> <h2>Kursmål och målgrupp</h2> Den här kursen är utformad för erfarna Python-programmerare som vill bygga webbapplikationer som hanterar data med FastAPI. När du har slutfört den här kursen har du den grund som behövs för att skapa FastAPI-projekt som lämpar sig för datastyrning med hög genomströmning och pipelines för modellservering inom ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Bygg robusta API:er med FastAPI, hantera HTTP, validering och asynkron körning för effektiva pipelines.

Introduktion till FastAPI

Bygg robusta, produktionsklara API:er med FastAPI och bemästra HTTP-operationer, validering och async-exekvering för effektiva data- och ML-pipelines.


Komplett JSON CRUD-API

Introduktion till FastAPI

Interaktiv övning med praktiskt arbete