We beginnen met de belangrijkste functies en kerngebruikstoepassingen van FastAPI. Daarna draaien we onze eerste applicatie en testen we die! Tot slot duiken we in de details van GET- en POST-bewerkingen met request-parameters en bouwen en testen we die endpoints.

Waarom FastAPI?

Eerste applicatie

FastAPI vs. Django

GET-bewerkingen

Hallo wereld

Hallo wie?

POST-bewerkingen

Pydantic-model

POST-operatie in de praktijk

FastAPI: de basis

We beginnen met het ondersteunen van PUT- en DELETE-bewerkingen in FastAPI. Daarna leren we hoe je verschillende soorten fouten afhandelt en altijd een passende statuscode in de response terugstuurt. Tot slot laten we zien hoe je async gebruikt om gelijktijdige requests mogelijk te maken die hogere workloads aankunnen.

PUT- en DELETE-bewerkingen

PUT-operatie in de praktijk

DELETE-operatie in de praktijk

Fouten afhandelen

Classificatie van statuscodes

Een clientfout afhandelen

Async gebruiken voor gelijktijdig werk

Wanneer gebruik je async?

Asynchrone DELETE-operatie

FastAPI: geavanceerde onderwerpen

We beginnen met het schrijven van systeemtests om afzonderlijke FastAPI-endpoints te valideren. Vervolgens bouwen we een complete JSON CRUD-API om objectlevenscycli via HTTP te beheren. Tot slot leren we hoe je verschillende applicatie-endpoints samen test met handmatige functionele tests.

Geautomatiseerd testen met FastAPI

Opties

Unit tests

Systeemtests

Unit tests vs. systeemtests

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}

Systeemtest

Een JSON CRUD-API bouwen

Create

Read

Update

HTTP-bewerkingen & CRUD-stappen

Respons op DELETE-operatie

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}."}

Volledige JSON CRUD-API

Een handmatige functionele test schrijven

Functionele tests

Systeemtests vs. functionele tests

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.")

Functionele test

Afronding

Een JSON CRUD-API bouwen en testen

In deze cursus leer je productieklare webapplicaties bouwen met FastAPI, een populair Python-framework voor het maken van API's. Je leert alle vier de HTTP-bewerkingen afhandelen, request- en response-schema's definiëren, API-verzoeken valideren en de juiste HTTP-statuscodes teruggeven. Je behandelt ook asynchrone code-uitvoering om de prestaties te verbeteren, en aan het einde bouw je een CRUD-API en test je workflows met de requests-module van Python. Deze cursus is bedoeld voor ervaren Python-programmeurs en geeft je de vaardigheden om data te beheren met FastAPI, zodat je robuuste datapijplijnen en pipelines voor het uitserveren van ML-modellen kunt bouwen.

<h2>Inleiding tot FastAPI en zijn toepassingen</h2> API's worden vaak gebruikt om gegevens op het web te beheren, en FastAPI is een populair nieuw webframework voor het bouwen van API's met Python. Data- en machine learning-ingenieurs gebruiken FastAPI om apps te maken die als contextbewuste datatransacties en pijplijnen op het web werken.<br><br> <h2>Productieklaar webapplicaties bouwen met FastAPI</h2> In deze cursus leer je hoe je met je Python-vaardigheden en het FastAPI-framework webapplicaties van productiekwaliteit kunt bouwen. Aan het einde begrijp je de belangrijkste toepassingen van FastAPI in vergelijking met andere Python-webframeworks. Je leert API's bouwen met alle vier soorten HTTP-bewerkingen en request- en response-schema's definiëren. Daarnaast valideer je API-verzoeken, reageer je met de juiste HTTP-statuscodes en -berichten en voer je code asynchroon uit om de prestaties van de app te verbeteren. Een praktisch project helpt je bij het bouwen van een klassieke CRUD-API (Create, Read, Update, Delete) en het testen van workflows met behulp van de requests-module van Python.<br><br> <h2>Cursusdoelen en voor wie is het bedoeld</h2> Deze cursus is bedoeld voor ervaren Python-programmeurs die webapplicaties willen bouwen die gegevens beheren met FastAPI. Na het afronden van deze cursus heb je de basis die je nodig hebt om FastAPI-projecten te maken die geschikt zijn voor het beheren van grote hoeveelheden data en ML-model-serving-pijplijnen.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Bouw robuuste, productieklare API's met FastAPI, beheers HTTP, validatie en async voor efficiënte pipelines.

Afronding

Create Your Free Account