Jak połączyć FastAPI z MySQL? Przykłady i konfiguracja krok po kroku

Witaj w artykule, który pomoże Ci połączyć FastAPI z MySQL! Jeśli zastanawiasz się, jak zbudować wydajną aplikację internetową, która będzie korzystać z bazy danych MySQL, to dobrze trafiłeś. FastAPI to jeden z najnowszych i najwydajniejszych frameworków do tworzenia API w Pythonie, a MySQL to jedna z najbardziej popularnych relacyjnych baz danych. Dziś pokażemy Ci, jak w łatwy sposób połączyć te dwie technologie, aby stworzyć szybkie, skalowalne i bezpieczne aplikacje webowe.

Dlaczego FastAPI i MySQL?

Zanim przejdziemy do samego procesu konfiguracji, warto wyjaśnić, dlaczego warto wybrać właśnie FastAPI i MySQL do budowy aplikacji. FastAPI jest wyjątkowy, ponieważ oferuje błyskawiczne ładowanie aplikacji, automatyczne generowanie dokumentacji API oraz wsparcie dla asynchronicznych operacji, co sprawia, że jest idealnym rozwiązaniem dla nowoczesnych aplikacji webowych.

MySQL, z drugiej strony, to klasyczna relacyjna baza danych, która od lat cieszy się ogromną popularnością. Charakteryzuje się stabilnością, skalowalnością oraz dużą liczbą narzędzi wspierających jej użytkowanie. Dla wielu programistów połączenie FastAPI z MySQL to idealne rozwiązanie, które pozwala na szybkie tworzenie i skalowanie aplikacji webowych.

Jak skonfigurować FastAPI z MySQL?

Aby połączyć FastAPI z MySQL, będziesz potrzebować kilku rzeczy:

• Python 3.x – FastAPI działa na Pythonie, więc musisz mieć go zainstalowanego na swoim komputerze.
• MySQL – Potrzebujesz działającej instancji bazy danych MySQL. Możesz zainstalować ją lokalnie lub skorzystać z chmurowych rozwiązań jak AWS RDS, Google Cloud SQL czy Azure Database for MySQL.
• SQLAlchemy – Jest to popularna biblioteka ORM (Object-Relational Mapping) dla Pythona, która ułatwia interakcję z bazą danych MySQL.
• AsyncMySQL – Jeśli chcesz korzystać z asynchronicznych zapytań, polecamy bibliotekę asyncmy, która wspiera asynchroniczne połączenia z MySQL.

Po zainstalowaniu wymaganych narzędzi, przejdźmy do konfiguracji. Załóżmy, że mamy już działającą bazę danych MySQL, a naszym celem jest stworzenie prostego API do zarządzania użytkownikami.

Krok 1: Instalacja niezbędnych bibliotek

Zacznijmy od zainstalowania wymaganych bibliotek. Otwórz terminal i zainstaluj poniższe pakiety:

pip install fastapi[all] sqlalchemy asyncmy mysql-connector-python

Te biblioteki pozwolą Ci na integrację FastAPI z MySQL i korzystanie z asynchronicznych zapytań do bazy danych.

Krok 2: Tworzenie modelu bazy danych

W FastAPI często używa się SQLAlchemy do tworzenia modeli bazy danych. Poniżej przedstawiamy przykład modelu dla tabeli "users" w MySQL:

from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.sql import func

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(50))
    email = Column(String(100), unique=True)
    created_at = Column(DateTime(timezone=True), server_default=func.now())

W powyższym przykładzie stworzyliśmy klasę "User", która odpowiada tabeli "users" w naszej bazie danych. Każdy użytkownik ma ID, imię, adres e-mail oraz datę utworzenia konta.

Krok 3: Konfiguracja połączenia z bazą danych

Aby połączyć się z naszą bazą danych MySQL, musimy skonfigurować odpowiednie połączenie w FastAPI. W tym celu stworzymy plik konfiguracyjny, który będzie zarządzać połączeniem do bazy:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine

DATABASE_URL = "mysql+asyncmy://user:password@localhost/mydatabase"

engine = create_async_engine(DATABASE_URL, echo=True)
SessionLocal = sessionmaker(
    bind=engine,
    class_=AsyncSession,
    autocommit=False,
    autoflush=False,
)

async def get_db():
    async with SessionLocal() as session:
        yield session

W tym kodzie ustawiamy odpowiednią URL bazy danych MySQL (tutaj zakładając, że nasza baza znajduje się na localhost) i tworzymy sesję, której będziemy używać do komunikacji z bazą.

Krok 4: Tworzenie pierwszego endpointu

Teraz, gdy mamy już wszystko skonfigurowane, możemy przejść do tworzenia naszego API. Poniżej przykład prostego endpointu do dodawania użytkowników do bazy:

from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.future import select
from sqlalchemy.orm import Session

app = FastAPI()

@app.post("/users/")
async def create_user(name: str, email: str, db: Session = Depends(get_db)):
    user = User(name=name, email=email)
    db.add(user)
    await db.commit()
    return {"id": user.id, "name": user.name, "email": user.email}

W tym kodzie tworzymy endpoint, który przyjmuje dane (imię i e-mail) i zapisuje je do bazy danych. Warto zauważyć, że używamy asynchronicznych operacji do pracy z bazą, co pozwala na efektywne zarządzanie zapytaniami w aplikacjach webowych.

Krok 5: Testowanie aplikacji

Po zakończeniu konfiguracji i stworzeniu endpointu możemy uruchomić naszą aplikację za pomocą poniższego polecenia:

uvicorn main:app --reload

Po uruchomieniu aplikacji, możesz przetestować swój API za pomocą narzędzi takich jak Postman lub cURL, wykonując zapytanie POST do endpointu /users/ z danymi JSON, na przykład:

{
  "name": "Jan Kowalski",
  "email": "jan.kowalski@example.com"
}

Jeśli wszystko jest skonfigurowane poprawnie, użytkownik zostanie dodany do bazy danych, a odpowiedź będzie zawierać dane nowo utworzonego użytkownika.

Podsumowanie

Połączenie FastAPI z MySQL to doskonały wybór, jeśli chcesz tworzyć szybkie, skalowalne aplikacje webowe z relacyjną bazą danych. W tym artykule pokazaliśmy, jak skonfigurować środowisko, stworzyć modele danych i połączyć się z bazą MySQL. Dzięki asynchronicznym zapytaniom, Twoja aplikacja będzie działać wydajnie, a obsługa dużej liczby użytkowników stanie się łatwiejsza. Mam nadzieję, że ten artykuł pomógł Ci w rozpoczęciu pracy z FastAPI i MySQL. Powodzenia!