FastAPI for maker-prosjekter: Bygg APIer raskt

Har du en Raspberry Pi eller ESP32 som logger sensordata, men lei av å lese av terminalen hver gang? Med FastAPI kan du bygge et skikkelig REST API på under en time – og plutselig kan du styre og overvåke maker-prosjektet ditt fra mobilen, nettleseren eller et annet program. La oss se på hvordan vi setter dette opp fra bunnen av.

FastAPI har blitt en favoritt blant Python-utviklere de siste årene, og av gode grunner. Det er raskt (bygget på Starlette og Pydantic), det gir deg automatisk API-dokumentasjon, og syntaksen er ren nok til at du kan gå fra idé til fungerende endepunkt på minutter. For maker-prosjekter er dette gull verdt – enten du styrer en robotarm, logger temperaturdata eller vil ha en dashboard-app for hydroponisystemet ditt.

Hva du trenger:

• En datamaskin eller Raspberry Pi med Python 3.9 eller nyere
• Terminaltilgang (SSH fungerer fint mot Raspberry Pi)
• En sensor eller aktuator du vil styre (f.eks. DHT22-sensor, servomotor eller relé)
• Valgfritt: en ESP32 eller Arduino for å teste websocket-kommunikasjon mot en mikrokontroller
• Grunnleggende kjennskap til Python og HTTP-forespørsler

Installasjon

Vi starter med et rent miljø. Det er lurt å bruke et virtuelt miljø slik at avhengighetene dine ikke kolliderer med andre Python-prosjekter på maskinen.

1. Opprett en prosjektmappe og gå inn i den:
   mkdir maker-api && cd maker-api
2. Lag et virtuelt miljø:
   python3 -m venv venv
3. Aktiver det:
   source venv/bin/activate (Linux/Mac) eller venv\Scripts\activate (Windows)
4. Installer FastAPI og en ASGI-server:
   pip install fastapi uvicorn[standard]

Uvicorn er serveren som faktisk kjører applikasjonen din – FastAPI er rammeverket, men det trenger en ASGI-server for å håndtere selve nettverkstrafikken.

Tips: Legg alltid til pip freeze > requirements.txt etter installasjon. Da kan du gjenskape miljøet på Raspberry Pi-en senere med én kommando.

Ditt første endepunkt

Nå skal vi lage en minimal applikasjon. Opprett en fil kalt main.py:

from fastapi import FastAPI

app = FastAPI(title="Maker API")

@app.get("/")
def root():
    return {"status": "online", "prosjekt": "RoboNordic Maker API"}

Start serveren med:

uvicorn main:app --reload --host 0.0.0.0 --port 8000

--reload gjør at serveren restarter automatisk når du endrer kode – praktisk under utvikling, men fjern den i produksjon. --host 0.0.0.0 gjør API-et tilgjengelig fra andre enheter på nettverket, noe som er essensielt hvis du skal nå det fra mobilen.

Naviger til http://localhost:8000/docs i nettleseren. Her får du automatisk generert, interaktiv dokumentasjon (Swagger UI) der du kan teste endepunktene direkte – uten å skrive en eneste linje frontend-kode.

Sensordata-API

Det virkelig nyttige starter når vi kobler API-et mot faktisk maskinvare. La oss anta at du har en DHT22-sensor koblet til en Raspberry Pi og leser temperatur og luftfuktighet.

from fastapi import FastAPI
from pydantic import BaseModel
import random  # erstatt med ekte sensorbibliotek

app = FastAPI()

class SensorData(BaseModel):
    temperatur: float
    luftfuktighet: float

@app.get("/sensor", response_model=SensorData)
def les_sensor():
    # I praksis: bruk f.eks. adafruit_dht-biblioteket
    return SensorData(
        temperatur=round(random.uniform(18, 24), 1),
        luftfuktighet=round(random.uniform(40, 60), 1)
    )

Legg merke til response_model – dette er Pydantic i aksjon. FastAPI validerer automatisk at responsen matcher modellen, og du får riktig datatype hver gang uten manuell sjekking.

Vil du også styre noe, for eksempel slå på en vifte via et relé? Da bruker vi POST i stedet for GET:

class ReleKommando(BaseModel):
    slaa_paa: bool

@app.post("/rele")
def styr_rele(kommando: ReleKommando):
    # GPIO.output(PIN, kommando.slaa_paa)
    return {"rele_status": "på" if kommando.slaa_paa else "av"}

Tips: Bruk alltid Pydantic-modeller for input, selv i små prosjekter. Det sparer deg for timevis feilsøking når noen (kanskje deg selv) sender feil datatype fra frontend.

Websockets for sanntidsdata

REST-endepunkter er flotte for enkeltoppdateringer, men hvis du vil strømme sensordata kontinuerlig – for eksempel til et live dashboard – trenger du websockets. Forskjellen er at websockets holder forbindelsen åpen, slik at data kan sendes begge veier uten at klienten må spørre på nytt hele tiden.

from fastapi import FastAPI, WebSocket
import asyncio
import random

app = FastAPI()

@app.websocket("/ws/sensor")
async def sensor_stream(websocket: WebSocket):
    await websocket.accept()
    try:
        while True:
            data = {
                "temperatur": round(random.uniform(18, 24), 1),
                "luftfuktighet": round(random.uniform(40, 60), 1)
            }
            await websocket.send_json(data)
            await asyncio.sleep(2)
    except Exception:
        await websocket.close()

Denne løkken sender oppdaterte sensorverdier hvert annet sekund til enhver klient som kobler seg til /ws/sensor. På frontend-siden kan du koble deg til med vanlig JavaScript:

const socket = new WebSocket("ws://raspberrypi.local:8000/ws/sensor");
socket.onmessage = (event) => {
    const data = JSON.parse(event.data);
    console.log(data.temperatur, data.luftfuktighet);
};

Tips: Websockets krever asynkron kode (async/await). Bland aldri blokkerende operasjoner som time.sleep() inn i en websocket-løkke – bruk asyncio.sleep() i stedet, ellers fryser hele serveren.

Deploy: fra utviklingsmaskin til produksjon

Når API-et fungerer lokalt, vil du sannsynligvis ha det kjørende permanent på Raspberry Pi-en eller en server. Her er tre praktiske steg:

1. Kjør uten –reload

I produksjon dropper du reload-flagget og kan legge til flere arbeidsprosesser for bedre ytelse: uvicorn main:app --host 0.0.0.0 --port 8000 --workers 2

2. Bruk systemd for autostart

På Raspberry Pi vil du at API-et starter automatisk ved oppstart. Lag en systemd-tjenestefil under /etc/systemd/system/makerapi.service som kaller uvicorn-kommandoen din, og aktiver med systemctl enable makerapi.

3. Sett en reverse proxy foran (valgfritt)

Vil du ha HTTPS og et pent domenenavn, kan du sette Nginx foran FastAPI-applikasjonen som reverse proxy. Dette er spesielt aktuelt hvis API-et skal være tilgjengelig fra internett, ikke bare lokalnettet.

Tips: Skal API-et kun styre prosjekter hjemme, hold det på lokalnettet og unngå å eksponere det direkte mot internett uten autentisering. Legg gjerne til en enkel API-nøkkel via FastAPI sine Depends-mekanismer for et minimum av sikkerhet.

Vanlige feil

• Glemmer –host 0.0.0.0: Uten dette er API-et kun tilgjengelig fra localhost, og du får ikke kontakt fra mobilen eller andre enheter på nettverket.
• Blokkerende kode i async-funksjoner: Bruk av time.sleep() eller tunge synkrone GPIO-kall inne i en async def-funksjon kan fryse hele serveren for alle tilkoblede klienter.
• Manglende validering av input: Å ta imot rådata uten Pydantic-modeller fører fort til kryptiske feil når noen sender feil datatype eller manglende felt.
• Feil CORS-oppsett: Hvis frontend kjører på en annen port eller domene, må du legge til CORSMiddleware – ellers blokkerer nettleseren forespørslene.
• Kjører reload i produksjon: Dette gir unødvendig overhead og kan føre til uventede restarter under drift.

FastAPI gir deg et solid fundament for å bygge alt fra enkle sensorloggere til fullverdige kontrollpaneler for hjemmelagde roboter. Kombinasjonen av automatisk dokumentasjon, typesikkerhet via Pydantic og støtte for websockets gjør det til et naturlig valg når maker-prosjektet ditt skal ut på nettet. Neste steg er kanskje å koble API-et til en database for historikk, eller bygge en enkel webapp som visualiserer sensordataene i sanntid – begge deler er rett rundt hjørnet når grunnmuren først er på plass.

Kilder: Offisiell FastAPI-dokumentasjon (fastapi.tiangolo.com) og Uvicorn-dokumentasjon (uvicorn.org).