Kuinka toteuttaa käyttäjien rekisteröinti ja autentikointi FastAPI-sovelluksessa

Käyttäjien rekisteröinti ja autentikointi ovat keskeisiä osia nykyaikaisissa sovelluksissa, erityisesti SaaS (Software as a Service) -sovelluksissa. Tässä luvussa käsitellään, kuinka voit luoda turvallisen käyttäjien rekisteröintijärjestelmän FastAPI-sovelluksessa, käyttäen tehokkaita menetelmiä kuten OAuth2, JWT-tunnuksia ja monivaiheista tunnistautumista (MFA). Näiden menetelmien avulla pystyt luomaan järjestelmiä, jotka eivät vain rekisteröi ja todenna käyttäjiä, mutta myös suojaavat sovelluksesi monilta hyökkäysmuodoilta.

Käyttäjien rekisteröinti voidaan toteuttaa käyttämällä SQL-pohjaista tietokantaa, kuten SQLite, ja SQLAlchemy-kirjastoa tietokannan yhteyksien hallintaan. Käyttäjärekisteröintijärjestelmän luomiseksi tarvitset seuraavat vaiheet:

1. Tietokannan luominen ja käyttäjämallin määrittäminen: Luo käyttäjät-taulu, joka sisältää kentät, kuten id, käyttäjätunnus, sähköpostiosoite ja hajautettu salasana. Tämän jälkeen määritä yhteys FastAPI-sovelluksesi ja tietokannan välillä. Tämä voidaan tehdä SQLAlchemy-kirjaston avulla.

2. Käyttäjän lisääminen tietokantaan: Käytämme bcrypt-pakettia salasanojen hajauttamiseen. Tämä vaihe varmistaa, että salasana tallennetaan turvallisesti eikä sitä koskaan tallenneta sellaisenaan. Salasana muunnetaan yksilölliseksi ja palauttamaton tulos ennen tietokantaan tallentamista.

   python
   Copy code
   from passlib.context import CryptContext
   pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
   def add_user(session: Session, username: str, password: str, email: str) -> User | None:
       hashed_password = pwd_context.hash(password)
       db_user = User(username=username, email=email, hashed_password=hashed_password)
       session.add(db_user)
       try:
           session.commit()
           session.refresh(db_user)
       except IntegrityError:
           session.rollback()
           return None
       return db_user
   

3. Käyttäjien rekisteröinti FastAPI-pohjaisessa sovelluksessa: Rekisteröintiprosessi määritellään API-pisteessä (/register/user), joka vastaanottaa JSON-objektin, joka sisältää käyttäjätunnuksen, sähköpostiosoitteen ja salasanan. API-piste tarkistaa, onko käyttäjätunnus tai sähköpostiosoite jo olemassa, ja jos ei, lisää käyttäjän tietokantaan.

   python
   Copy code
   @app.post("/register/user", status_code=status.HTTP_201_CREATED)
   def register(user: UserCreateBody, session: Session = Depends(get_session)) -> dict[str, UserCreateResponse]:
       user = add_user(session=session, **user.model_dump())
       if not user:
           raise HTTPException(status.HTTP_409_CONFLICT, "Käyttäjätunnus tai sähköpostiosoite on jo käytössä")
   
       return {"message": "Käyttäjä luotu", "user": UserCreateResponse(username=user.username, email=user.email)}
   
   

Tämä perusrekisteröintimekanismi mahdollistaa käyttäjien luomisen ja tallentamisen tietokantaan, mutta se ei vielä riitä suojaamaan sovellustasi. On tärkeää huomioida seuraavat seikat ja parannukset, jotka voivat lisätä sovelluksesi turvallisuutta ja käytettävyyttä:

• Salasanojen käsittely ja suojelu: On erittäin tärkeää käyttää vahvoja salasanan suojausmenetelmiä, kuten bcrypt, koska heikommat menetelmät voivat altistaa sovelluksen tietomurroille. Lisäksi, vaikka bcrypt on turvallinen, on suositeltavaa käyttää myös muita turvakerroksia, kuten salasanan suuruuden tarkistusta ja salasanan voiman analysointia.

• OAuth2 ja JWT: OAuth2 ja JWT (JSON Web Token) tarjoavat tehokkaita keinoja käyttäjän autentikointiin ja autorisointiin. OAuth2:ta käytetään usein ulkoisten palveluiden, kuten Google tai GitHub, kautta tapahtuvaan kirjautumiseen. JWT puolestaan mahdollistaa turvallisen käyttäjän tunnistamisen ilman, että käyttäjän täytyy joka kerta syöttää tunnuksia.

• Monivaiheinen tunnistautuminen (MFA): MFA lisää lisäkerroksen turvallisuuteen. Vaikka perinteinen käyttäjätunnus ja salasana voivat olla riittäviä monissa tapauksissa, MFA varmistaa, että käyttäjä on todella se, joka hän väittää olevansa. Tämä voidaan toteuttaa esimerkiksi lähettämällä kertakäyttöisiä koodeja tekstiviestillä tai sähköpostilla.

• Roolipohjainen pääsynhallinta (RBAC): Käyttäjien pääsy sovelluksen eri osiin voidaan rajoittaa roolipohjaisella pääsynhallinnalla. Tämä tarkoittaa sitä, että eri käyttäjäryhmillä voi olla erilaiset oikeudet sovelluksen toimintoihin. Tämän avulla voidaan estää ei-toivottu pääsy herkkään dataan tai toimintoihin.

• Kolmannen osapuolen autentikointi: Kolmannen osapuolen kirjautumispalvelut, kuten GitHub, voivat yksinkertaistaa käyttäjien kirjautumisprosessia ja parantaa käyttäjäkokemusta. Kolmannen osapuolen palvelut voivat myös tarjota lisää suojaa, koska ne käyttävät omia, erittäin turvallisia autentikointiprosessejaan.

• API-avaimet ja sessiot: API-avaimien käyttö auttaa suojaamaan sovelluksen rajapintoja. Sessioiden hallinta on myös tärkeää, koska se varmistaa, että käyttäjä on kirjautunut sisään ennen kuin hän saa käyttää suojattuja resursseja. On tärkeää varmistaa, että sessioiden käsittely on turvallista, ja käyttää tarvittaessa suojattuja evästeitä.

• Tietoturva ja yhteensopivuus säädöksien kanssa: Käyttäjien henkilökohtaiset tiedot, kuten sähköpostiosoitteet ja salasanat, tulee aina tallentaa turvallisesti ja GDPR:n tai muiden tietosuojalakien mukaisesti. Hajautusmenetelmien, kuten bcryptin, käyttö auttaa varmistamaan, että tiedot ovat suojassa.

Miten taustatehtävät toteutetaan FastAPI-sovelluksessa tehokkaasti?

FastAPI mahdollistaa kevyiden ja ei-estävien taustatehtävien suorittamisen helposti osana HTTP-pyyntöjä. Näin voidaan säilyttää palvelun nopea vasteaika, vaikka tietyt toiminnot, kuten tietojen tallennus ulkoiseen järjestelmään, suoritettaisiin vasta pyynnön jälkeen. Tämä lähestymistapa perustuu Pythonin asyncio-moduulin hyödyntämiseen ja taustatehtävien rekisteröintiin BackgroundTasks-olion kautta.

Ensimmäiseksi luodaan background_tasks.py-moduuli, johon kirjoitetaan asynkroninen funktio. Tämä funktio ottaa vastaan merkkijonon, tulostaa sen lokiin, odottaa kaksi sekuntia ilman, että sovellus estyy, ja ilmoittaa lopuksi onnistuneesta tallennuksesta:

python
Copy code
import asyncio
import logging
logger = logging.getLogger("uvicorn.error")

async def store_query_to_external_db(message: str):

    logger.info(f"Storing message '{message}'.")
    await asyncio.sleep(2)
    logger.info(f"Message '{message}' stored!")

Seuraavaksi tämä funktio otetaan käyttöön osana FastAPI-reititystä. main.py-moduulissa muokataan /v2/trips/{category}-päätepistettä siten, että siihen lisätään parametrina BackgroundTasks, ja taustatehtävä rekisteröidään suoritetavaksi kun pyyntö on käsitelty:

python
Copy code
from fastapi import BackgroundTasks

@app.get("/v2/trips/{category}")
def get_trips_by_category(
    background_tasks: BackgroundTasks,
    category: Annotated[select_category, Depends()],
    discount_applicable: Annotated[
        bool, Depends(check_coupon_validity)
    ],
):
    category = category.replace("-", " ").title()
    message = f"You requested {category} trips."
    if discount_applicable:
        message += "\n. The coupon code is valid! You will get a discount!"
    background_tasks.add_task(
        store_query_to_external_db, message
    )
    logger.info("Query sent to background task, end of request.")
    return message

Tällä tavalla tallennus ei hidasta vastauksen muodostamista asiakkaalle, vaan suoritetaan taustalla, hyödyntäen ei-estävää tapahtumasilmukkaa. Tämä malli skaalautuu hyvin niin kauan kuin taustatehtävät pysyvät kevyinä ja lyhytkestoisina.

Taustatehtävät toteutetaan tässä FastAPI:n sisäisellä BackgroundTasks-luokalla, joka toimii saumattomasti HTTP-pyyntöjen yhteydessä. Kun pyyntö saapuu, tehtävä lisätään jonoon, ja se suoritetaan myöhemmin asynkronisesti osana samaa prosessia. Tämä on erityisen hyödyllistä lyhyissä I/O-sidonnaisissa tehtävissä, kuten lokituksen, notifikaatioiden tai yksinkertaisten tietojen tallennuksen tapauksessa.

Kuitenkin jos taustatehtävä on laskennallisesti raskas, pitkäkestoinen tai kriittinen, on suositeltavaa hyödyntää erillistä tehtävien hallintajärjestelmää kuten Celeryä. Tällöin tehtävät siirtyvät erilliseen prosessiin tai koneeseen, mikä suojaa FastAPI-palvelua hidastumiselta tai virheiltä. Lisäksi tällainen ratkaisu mahdollistaa tehtävien uudelleenyrittämisen epäonnistumisen sattuessa ja skaalautuvan tehtäväjonon hallinnan.

On tärkeää ymmärtää, että vaikka FastAPI mahdollistaa yksinkertaiset taustatehtävät natiivisti, se ei ole täysimittainen työnvälitysalusta. Sovelluskehittäjän on arvioitava, missä vaiheessa tehtävän monimutkaisuus tai palvelun kuormitus vaatii siirtymistä robustimpaan arkkitehtuuriin. Tässä vaiheessa tehtävänjonoja ja työnvälityspalveluita, kuten Redis-taustaisia Celery-ratkaisuja, voidaan hyödyntää hallitusti, varmistaen palvelun suorituskyvyn ja luotettavuuden säilyminen.