基礎から学ぶPython入門 90日コース | データベース・Web API - Day 71:FastAPI × SQLite

Python 90日で身につけるPython
スポンサーリンク
スポンサーリンク
  1. Python実践レベルになるまでの最短90日ロードマップ Day 71:FastAPI × SQLiteでデータを保存するAPIを作る
  2. Day 71のゴール
  3. 前回との違いを整理する
  4. 最初に、アプリ全体の流れを理解する
    1. SQLiteファイルを、APIの利用者へ直接渡すわけではありません
  5. 今回作るAPIの仕様
    1. 更新は、前回と同じくPUTの置き換えです
  6. ファイルを役割ごとに分ける
    1. 最初は、同じフォルダへ並べます
  7. 実行環境を準備する
  8. データベース接続を作る
    1. EngineとSessionを区別する
    2. database.py
    3. 接続先のパスを明確にする理由
    4. yieldは、使う前と使ったあとの処理を分けます
  9. 保存するテーブルを定義する
    1. models.py
  10. APIの入力と出力を定義する
    1. 入力チェックとDB制約は、どちらも用意します
    2. schemas.py
    3. モデルを分けると、何がわかりやすくなるのでしょうか
  11. APIの入口とCRUDを実装する
    1. 起動時にテーブルを用意する
    2. main.py
  12. 起動してAPIへアクセスする
  13. Create:商品を登録する
    1. 登録処理の中で、何が起きたのでしょうか
  14. Read:一覧と詳細を取得する
    1. 一覧を取得する
    2. 取得件数を指定する
    3. 商品を1件取得する
  15. Update:商品情報を置き換える
    1. 省略項目に注意します
  16. Delete:商品を削除する
  17. 最重要:再起動後もデータが残ることを確認する
    1. 「再起動すると消えた」ときは、保存先を確認します
  18. PythonでCRUDをまとめて確認する
  19. トランザクションの境界を深く理解する
    1. なぜ、取得もsession.beginで囲むのでしょうか
  20. SQLite接続で勘違いしやすいこと
    1. check_same_thread=Falseは、安全を自動保証する設定ではありません
    2. 待ち時間を増やせば、同時更新問題が全部解決するわけではありません
    3. async defに変更すれば、自動で非同期DB接続になるわけではありません
  21. create_allは、データベース構造の更新機能ではありません
  22. 入力エラーと、保存先の障害を分ける
  23. 安全に発展させるための確認事項
  24. 動作確認チェックリスト
  25. Day 71の仕上げ課題
  26. Day 71のまとめ

Python実践レベルになるまでの最短90日ロードマップ Day 71:FastAPI × SQLiteでデータを保存するAPIを作る

Day 71では、FastAPIとSQLiteの接続を整理し、データを継続して保存できるCRUD APIを制作します。前回もSQLiteへ保存するAPIを作りましたが、今回は一歩進めて、API・データベース接続・保存用モデル・入力と出力のモデルを分け、仕組みを説明できる構成に整えます。

題材は、引き続き商品管理です。新しい機能を大量に追加するよりも、「リクエストが来てからデータが保存されるまで」「処理が失敗したとき」「再起動したあと」の動きを、確実に理解することを目指します。

Day 71のゴール

  • FastAPIとSQLiteの間で、どのように処理が流れるか説明できるようになります。
  • データベース接続の設定を、専用ファイルへ分けます。
  • リクエストごとにSessionを用意し、処理後に閉じる構成を作ります。
  • 商品を登録・取得・更新・削除するAPIを実装します。
  • 入力検証と、データベース制約の役割を区別します。
  • サーバーを再起動しても、保存済みの商品が残ることを確認します。

前回との違いを整理する

前回のDay 70では、全体を見渡しやすいように、主な処理を1つのファイルへまとめました。

今回は同じ商品管理を、役割ごとに分けます。

観点Day 70Day 71
学習の中心CRUD APIを一通り動かしますAPIとDB接続の責任を整理します
ファイル構成主に1ファイルです役割ごとに分けます
保存先SQLiteファイルです新しい専用SQLiteファイルです
確認することCRUDが動くことです接続・確定・後片付け・永続保存です
到達点動くAPIを作ります保守しやすい形で作り直します

同じ処理を、責任の分かれた構成へ整理することも、実践的な学習です。

今回は過去のデータベースを書き換えず、新しいフォルダと新しいDBファイルを使います。

最初に、アプリ全体の流れを理解する

商品登録を例にすると、今回のアプリは次のように動きます。

  • 利用者が、POSTで商品情報のJSONを送ります。
  • FastAPIがリクエストを受け付けます。
  • Pydanticが、名前や価格などを検証します。
  • 検証済みの値から、SQLAlchemyの商品オブジェクトを作ります。
  • Sessionを使って、SQLiteへINSERTします。
  • 変更を確定します。
  • 登録結果をJSONで返します。
  • リクエストで使ったSessionを閉じます。

FastAPIでは、依存関係としてSessionを渡し、リクエストごとに準備と後片付けを行う構成を作れます。公式のデータベース教材でも、この考え方が使われています。(🔗 fastapi.tiangolo.com)

SQLiteファイルを、APIの利用者へ直接渡すわけではありません

今回の利用者は、HTTPを通じてAPIを呼び出します。SQLiteファイルを直接開くのは、サーバー側のプログラムです。

役割を整理すると、次のようになります。

要素今回の担当
呼び出し元HTTPリクエストを送ります
FastAPIURLと処理を対応付けます
PydanticAPIの入力と出力の構造を扱います
SQLAlchemyPythonのオブジェクトとDB操作を結び付けます
SQLite商品データをファイルへ保存します

SQLiteは、アプリケーション内のローカルなデータ保存にも使われるデータベースです。別のDBサーバーを用意せず、今回のような学習用APIの保存先として利用できます。(🔗 sqlite.org)

今回作るAPIの仕様

機能を増やす前に、受け付ける操作を決めます。

メソッドパス操作正常時
POST/products商品を登録します201
GET/products商品一覧を取得します200
GET/products/{product_id}商品を1件取得します200
PUT/products/{product_id}商品情報を置き換えます200
DELETE/products/{product_id}商品を削除します204

今回の仕様では、存在しない商品の取得・更新・削除は404にします。削除成功時の204では、本文を返しません。FastAPIでは、デコレータで成功時のステータスを指定できます。(🔗 fastapi.tiangolo.com)

更新は、前回と同じくPUTの置き換えです

今回は、部分更新のPATCHは追加しません。

PUTで在庫数を省略した場合は0、説明文を省略した場合はnullに置き換える仕様です。

「省略した項目を現在の値のまま残す」更新ではありません。PUTとPATCHを使うときは、省略項目の扱いを明確にすることが重要です。(🔗 fastapi.tiangolo.com)

ファイルを役割ごとに分ける

今回は、次の4ファイルを作ります。

ファイル担当主に書くもの
database.pyDBへの接続基盤ですEngine、Session、Base
models.py保存する表の定義ですSQLAlchemyのProduct
schemas.pyAPIの入力と出力の定義ですPydanticのモデル
main.pyAPIの入口ですルーティング、CRUD処理

保存先を含む完成後の構成は、次のとおりです。

day71_fastapi_sqlite/
    database.py
    models.py
    schemas.py
    main.py
    verify_api.py
    data/
        day71_products.db

verify_api.pyは、後半で作る動作確認用プログラムです。

dataフォルダとDBファイルは、アプリ側で作成します。DBファイルを手作業で空ファイルとして作る必要はありません。

最初は、同じフォルダへ並べます

今回は、Pythonパッケージや複雑な階層構造までは導入しません。

4つのファイルを同じフォルダへ保存し、そのフォルダで起動する構成に統一します。

実行環境を準備する

この教材では、Python 3.12以降、SQLAlchemy 2.0系、Pydantic 2系の書き方を使います。

# Pythonのバージョンを確認します
python --version

# 作業用フォルダを作ります
mkdir day71_fastapi_sqlite

# 作業用フォルダへ移動します
cd day71_fastapi_sqlite

# 仮想環境を作ります
python -m venv .venv

WindowsのPowerShellでは、次のコマンドで有効化します。

# 仮想環境を有効にします<br>.\.venv\Scripts\Activate.ps1
PowerShell

macOS・Linuxでは、次のように実行します。

# 仮想環境を有効にします
source .venv/bin/activate

続いて、教材で使うライブラリを用意します。

# 前回までと同じライブラリ系列へそろえます
python -m pip install "fastapi[standard]" "pydantic>=2,<3" "SQLAlchemy>=2.0,<2.1" requests

SQLAlchemyのバージョン範囲は、今回のコードをDay 67からの書き方にそろえるための指定です。最新版番号を固定しているわけではありません。

データベース接続を作る

まず、database.pyを作ります。

このファイルでは、「どこへ接続するか」と「Sessionをどう作るか」をまとめます。

EngineとSessionを区別する

Engineは、データベースへの接続を扱う基盤です。一方、Sessionは、ORMオブジェクトの取得や変更、トランザクションを管理します。

今回の設計では、EngineとSessionの生成器は共通で用意し、個別のSessionをリクエストごとに作ります。Sessionそのものを、並行するリクエスト間で共有しないことが重要です。(🔗 docs.sqlalchemy.org)

database.py

# リクエストへ渡すSessionの型を表すために使います
from collections.abc import Generator

# 保存先を、スクリプトの場所から決めるために使います
from pathlib import Path

from sqlalchemy import URL, create_engine
from sqlalchemy.orm import DeclarativeBase, Session, sessionmaker


# 実行した場所ではなく、このファイルの場所を基準にします
BASE_DIR = Path(__file__).resolve().parent
DB_PATH = BASE_DIR / "data" / "day71_products.db"

# DBファイルを置くフォルダを用意します
DB_PATH.parent.mkdir(parents=True, exist_ok=True)

# ファイルパスからSQLiteの接続先を作ります
DATABASE_URL = URL.create(
    "sqlite+pysqlite",
    database=str(DB_PATH),
)

# Python 3.12以降のsqlite3を使う設定です
engine = create_engine(
    DATABASE_URL,
    connect_args={
        "check_same_thread": False,
        "autocommit": False,
        "timeout": 5.0,
    },
    echo=False,
    hide_parameters=True,
)

# 呼び出すたびに、新しいSessionを作る仕組みです
SessionLocal = sessionmaker(bind=engine)


class Base(DeclarativeBase):
    """ORMモデル共通の土台です。"""

    pass


def get_session() -> Generator[Session, None, None]:
    """リクエスト専用のSessionを渡します。"""

    with SessionLocal() as session:
        yield session
Python

今回の接続引数では、Python 3.12以降のsqlite3へautocommit=Falseを渡し、トランザクション制御を明示しています。また、timeoutはロック時に待つ時間に関係する設定であり、API全体の処理時間制限ではありません。(🔗 docs.sqlalchemy.org)

接続先のパスを明確にする理由

今回の設計では、起動するたびに同じファイルを参照することを意図しています。

相対的なファイル名だけを使い、実行場所によって別のDBへ接続してしまうと、「保存した商品がなくなった」と誤解しやすくなります。

あとで起動時にDB_PATHを表示し、実際の保存先を確認できるようにします。

yieldは、使う前と使ったあとの処理を分けます

get_sessionでは、Sessionを作ってからyieldで渡します。リクエストでの利用が終わると、withの後片付けでSessionを閉じます。

ただし、今回のget_sessionは、CRUDの変更を自動で確定する担当ではありません。変更を確定する範囲は、各APIのsession.beginで明示します。Sessionの後片付けとトランザクションの確定は、別の責任として理解してください。(🔗 docs.sqlalchemy.org)

保存するテーブルを定義する

次に、models.pyを作ります。

今回の保存項目は、次のとおりです。

カラム内容主なルール
product_id商品を識別する番号です整数の主キーです
name商品名です必須、1〜100文字です
price_yen円単位の価格です必須、0〜10000000です
stock在庫数です必須、0〜100000です
description説明文ですnullまたは1000文字以内です

今回は1テーブルなので、外部キーの設定は使いません。

models.py

from sqlalchemy import CheckConstraint, Integer, String, Text
from sqlalchemy.orm import Mapped, mapped_column

# database.pyで定義した共通の土台を読み込みます
from database import Base


class Product(Base):
    """SQLiteの商品テーブルに対応します。"""

    __tablename__ = "products"

    # API以外の経路で保存しても、基本的な条件を守らせます
    __table_args__ = (
        CheckConstraint(
            "length(trim(name)) BETWEEN 1 AND 100",
            name="ck_products_name",
        ),
        CheckConstraint(
            "price_yen BETWEEN 0 AND 10000000",
            name="ck_products_price",
        ),
        CheckConstraint(
            "stock BETWEEN 0 AND 100000",
            name="ck_products_stock",
        ),
        CheckConstraint(
            "description IS NULL OR length(description) <= 1000",
            name="ck_products_description",
        ),
    )

    product_id: Mapped[int] = mapped_column(
        Integer,
        primary_key=True,
    )

    name: Mapped[str] = mapped_column(
        String(100),
        nullable=False,
    )

    price_yen: Mapped[int] = mapped_column(
        Integer,
        nullable=False,
    )

    stock: Mapped[int] = mapped_column(
        Integer,
        nullable=False,
    )

    description: Mapped[str | None] = mapped_column(
        Text,
        nullable=True,
    )
Python

ここでは、ORMのカラム定義とCHECK制約を組み合わせています。SQLiteではString(100)のような宣言だけを文字数制限として頼らず、今回のように別の検証条件も用意します。(🔗 docs.sqlalchemy.org)

APIの入力と出力を定義する

続いて、schemas.pyを作ります。

ORMモデルが「保存先の構造」なら、こちらは「APIの入口と出口の構造」です。

入力チェックとDB制約は、どちらも用意します

今回の設計では、同じような条件が2か所に登場します。

場所主な目的今回の例
APIの入力モデル不適切なリクエストを早く拒否します負の価格を受け付けません
データベース制約保存されるデータの基本ルールを守ります価格にCHECKを付けます

これは単純な書き間違いによる重複ではなく、異なる境界を守るための設計です。

ただし、条件を変更するときは、両方の整合性を確認する必要があります。

schemas.py

from pydantic import BaseModel, ConfigDict, Field


class ProductInput(BaseModel):
    """POSTとPUTで受け付けるデータです。"""

    model_config = ConfigDict(
        str_strip_whitespace=True,
        extra="forbid",
    )

    # 前後の空白を除去したあと、文字数を確認します
    name: str = Field(min_length=1, max_length=100)

    # JSONの整数を要求します
    price_yen: int = Field(
        ge=0,
        le=10_000_000,
        strict=True,
    )

    # PUTで省略した場合も、0を使います
    stock: int = Field(
        default=0,
        ge=0,
        le=100_000,
        strict=True,
    )

    # PUTで省略した場合も、Noneを使います
    description: str | None = Field(
        default=None,
        max_length=1000,
    )


class ProductRead(BaseModel):
    """APIが返す商品情報です。"""

    # ORMオブジェクトの属性から、モデルを作れるようにします
    model_config = ConfigDict(from_attributes=True)

    product_id: int
    name: str
    price_yen: int
    stock: int
    description: str | None

ProductReadのfrom_attributes=Trueにより、辞書だけでなく、ORMオブジェクトの属性からも値を読み取ってモデルを作れます。完成版では、ProductRead.model_validateを使って返却用データへ変換します。(🔗 pydantic.dev)

モデルを分けると、何がわかりやすくなるのでしょうか

今回の構成では、次の違いをコード上で確認できます。

  • 利用者が入力してよい項目には、商品IDがありません。
  • APIが返す項目には、商品IDがあります。
  • 保存用モデルには、主キーやDB制約があります。

「全部同じ商品情報だから1つでよい」とまとめる前に、誰が何のために使うデータかを区別します。

APIの入口とCRUDを実装する

最後に、main.pyを作ります。

このファイルには、起動処理、ルーティング、CRUDを記述します。

起動時にテーブルを用意する

今回は、アプリのlifespanでテーブルを作成します。lifespanは、アプリの開始・終了時の処理をまとめる仕組みです。(🔗 fastapi.tiangolo.com)

ここで重要なのは、テーブル作成前にProductモデルが読み込まれていることです。

今回のコードでは、main.pyの先頭でProductをimportし、そのあと起動時にcreate_allを実行します。

main.py

from contextlib import asynccontextmanager
from typing import Annotated

from fastapi import (
    Depends,
    FastAPI,
    HTTPException,
    Path,
    Query,
    Response,
    status,
)
from sqlalchemy import select
from sqlalchemy.orm import Session

# 役割ごとに分けたファイルから読み込みます
from database import Base, DB_PATH, engine, get_session
from models import Product
from schemas import ProductInput, ProductRead


@asynccontextmanager
async def lifespan(app: FastAPI):
    """起動時にテーブルを用意し、終了時に接続資源を解放します。"""

    try:
        # Productの定義は、上のimportで登録されています
        Base.metadata.create_all(engine)
        print(f"学習用DBの保存先: {DB_PATH}")
        yield
    finally:
        engine.dispose()


app = FastAPI(
    title="Day 71 FastAPI × SQLite",
    version="1.0.0",
    lifespan=lifespan,
)

# 各API関数へ、リクエスト専用のSessionを渡します
SessionDependency = Annotated[Session, Depends(get_session)]

# 商品IDは1以上の整数です
ProductId = Annotated[int, Path(ge=1)]


def find_product(session: Session, product_id: int) -> Product:
    """商品を取得し、存在しなければ404にします。"""

    product = session.get(Product, product_id)

    if product is None:
        raise HTTPException(
            status_code=status.HTTP_404_NOT_FOUND,
            detail="商品が見つかりません",
        )

    return product


@app.post(
    "/products",
    response_model=ProductRead,
    status_code=status.HTTP_201_CREATED,
)
def create_product(
    payload: ProductInput,
    session: SessionDependency,
):
    """商品を登録します。"""

    with session.begin():
        product = Product(**payload.model_dump())
        session.add(product)

        # INSERTを実行して、自動採番されたIDを取得します
        session.flush()

        # Sessionが有効なうちに、返却用データを準備します
        result = ProductRead.model_validate(product)

    # 確定に成功してから返します
    return result


@app.get("/products", response_model=list[ProductRead])
def list_products(
    session: SessionDependency,
    offset: Annotated[int, Query(ge=0)] = 0,
    limit: Annotated[int, Query(ge=1, le=100)] = 20,
):
    """商品一覧を、商品ID順に返します。"""

    with session.begin():
        statement = (
            select(Product)
            .order_by(Product.product_id)
            .offset(offset)
            .limit(limit)
        )

        products = session.scalars(statement).all()

        result = [
            ProductRead.model_validate(product)
            for product in products
        ]

    return result


@app.get("/products/{product_id}", response_model=ProductRead)
def get_product(
    product_id: ProductId,
    session: SessionDependency,
):
    """商品を1件返します。"""

    with session.begin():
        product = find_product(session, product_id)
        result = ProductRead.model_validate(product)

    return result


@app.put("/products/{product_id}", response_model=ProductRead)
def replace_product(
    product_id: ProductId,
    payload: ProductInput,
    session: SessionDependency,
):
    """編集可能な商品情報を置き換えます。"""

    with session.begin():
        product = find_product(session, product_id)

        # 初期値を含め、全項目を明示的に書き戻します
        product.name = payload.name
        product.price_yen = payload.price_yen
        product.stock = payload.stock
        product.description = payload.description

        # UPDATEを実行し、DB制約も確認します
        session.flush()
        result = ProductRead.model_validate(product)

    return result


@app.delete(
    "/products/{product_id}",
    status_code=status.HTTP_204_NO_CONTENT,
    response_class=Response,
)
def delete_product(
    product_id: ProductId,
    session: SessionDependency,
):
    """指定した商品を削除します。"""

    with session.begin():
        product = find_product(session, product_id)
        session.delete(product)

    # 削除が確定したあと、本文なしで返します
    return Response(status_code=status.HTTP_204_NO_CONTENT)
Python

SQLAlchemyのsession.beginは、正常に終了したらcommitし、例外が発生したらrollbackします。今回の各APIは、その範囲を抜けてから成功レスポンスを返す構成です。(🔗 docs.sqlalchemy.org)

起動してAPIへアクセスする

4つのファイルを保存したら、そのフォルダで次のコマンドを実行します。

# 自分のPC内で使う開発用サーバーを起動します
python -m uvicorn main:app --reload --host 127.0.0.1 --port 8000

今回も、複数ワーカーの指定は追加しません。

起動したら、次のURLをブラウザで開きます。

http://127.0.0.1:8000/docs

この画面から、登録・取得・更新・削除を試します。

Create:商品を登録する

POST /productsで、次のJSONを送ります。

{
  "name": "Python入門書",
  "price_yen": 2800,
  "stock": 10,
  "description": "基礎から学ぶための架空の商品です"
}
JSON

新しいDBへの最初の登録なら、次のような結果になります。

{
  "product_id": 1,
  "name": "Python入門書",
  "price_yen": 2800,
  "stock": 10,
  "description": "基礎から学ぶための架空の商品です"
}
JSON

商品IDは、実際に返された値を使ってください。

登録処理の中で、何が起きたのでしょうか

今回のコードを追うと、次の順番です。

  • ProductInputがJSONを検証します。
  • Productオブジェクトを作ります。
  • session.addで登録対象へ追加します。
  • session.flushでINSERTし、商品IDを取得します。
  • ProductReadへ必要な値を移します。
  • session.beginの正常終了で確定します。
  • 201で登録結果を返します。

addした時点、flushした時点、確定した時点を区別することが重要です。flushはSQLを送りますが、そのトランザクションを確定する操作ではありません。(🔗 docs.sqlalchemy.org)

Read:一覧と詳細を取得する

一覧を取得する

http://127.0.0.1:8000/products

今回のAPIは、商品配列を直接返します。

[
  {
    "product_id": 1,
    "name": "Python入門書",
    "price_yen": 2800,
    "stock": 10,
    "description": "基礎から学ぶための架空の商品です"
  }
]
JSON

商品がなければ、空の配列になります。

[]
JSON

取得件数を指定する

http://127.0.0.1:8000/products?offset=0&limit=5

今回の実装では、先頭から0件飛ばし、最大5件を返します。

一覧の順番は商品ID順です。ページ分割するときは、並び順を明確にしておく方針にしています。

商品を1件取得する

http://127.0.0.1:8000/products/1

実際に登録されたIDを指定します。

今回のfind_productは、対象がない場合に次の本文を持つ404を返します。

{
  "detail": "商品が見つかりません"
}
JSON

Update:商品情報を置き換える

PUT /products/{product_id}で、登録した商品のIDと次のJSONを指定します。

{
  "name": "Python入門書 改訂版",
  "price_yen": 3200,
  "stock": 8,
  "description": "練習問題を追加した架空の商品です"
}
JSON

今回のコードでは、商品IDを変えずに、4つの編集項目を書き換えます。

そのあとGETで同じ商品を取得し、更新後の値を確認します。

省略項目に注意します

次のPUTを送った場合を考えます。

{
  "name": "Python入門書 改訂版",
  "price_yen": 3300
}
JSON

今回の仕様では、stockは0、descriptionはnullになります。

部分更新にしたい場合は、PATCH用の入力モデルを設計し、未指定とnullを区別する必要があります。FastAPIでは、部分更新にmodel_dump(exclude_unset=True)を利用する方法が紹介されています。(🔗 fastapi.tiangolo.com)

Delete:商品を削除する

DELETE /products/{product_id}で、削除する商品IDを指定します。

今回の処理は、対象を取得してからsession.deleteへ渡します。その後、トランザクションが正常に確定すれば204を返します。

204には本文がないため、呼び出し元で無条件にJSONとして読み取らないようにします。(🔗 fastapi.tiangolo.com)

削除後に同じIDをGETすると、今回のAPIでは404です。

最重要:再起動後もデータが残ることを確認する

今回のテーマでは、CRUDを動かすだけでなく、永続保存を確認することが大切です。

次の順番で試します。

  • 商品を1件登録します。
  • 返された商品IDを控えます。
  • その商品を削除せずに残します。
  • サーバーのターミナルでCtrl+Cを押します。
  • 同じコマンドでサーバーを起動します。
  • 控えた商品IDをGETします。
  • 登録した内容が残っていることを確認します。

今回のコードは、起動するたびに初期商品をINSERTする処理を入れていません。そのため、再起動だけで同じ商品が増える仕様にはなっていません。

「再起動すると消えた」ときは、保存先を確認します

最初に、起動時に表示されたDBの保存先を確認してください。

今回のチェックポイントは、次のとおりです。

  • Day 69のメモリ保存版を起動していませんか。
  • 違うフォルダのmain.pyを読み込んでいませんか。
  • 別の日のDBファイルへ接続していませんか。
  • 商品を削除する確認プログラムを実行していませんか。

「データが消えた」と判断する前に、同じプログラムが、同じ保存先を見ているかを確認します。

PythonでCRUDをまとめて確認する

手動操作の次は、確認手順をプログラムにします。

次のverify_api.pyは、自分が登録した商品だけを更新・削除します。既存の商品一覧をまとめて消す処理は入れていません。

# ローカルAPIの動作確認に使います
import requests


BASE_URL = "http://127.0.0.1:8000"
TIMEOUT = 10


def expect_status(response, expected):
    """期待したHTTPステータスか確認します。"""

    if response.status_code != expected:
        raise AssertionError(
            f"期待={expected}, 実際={response.status_code}, "
            f"本文={response.text}"
        )


def main():
    # 登録するのは架空の商品です
    response = requests.post(
        f"{BASE_URL}/products",
        json={
            "name": "Day71確認用ノート",
            "price_yen": 250,
            "stock": 30,
            "description": "動作確認用です",
        },
        timeout=TIMEOUT,
    )
    expect_status(response, 201)

    product_id = response.json()["product_id"]
    detail_url = f"{BASE_URL}/products/{product_id}"

    print(f"登録OK: 商品ID={product_id}")

    # Read:登録内容を確認します
    response = requests.get(detail_url, timeout=TIMEOUT)
    expect_status(response, 200)

    if response.json()["price_yen"] != 250:
        raise AssertionError("登録した価格と異なります")

    print("取得OK")

    # Update:全項目を置き換えます
    response = requests.put(
        detail_url,
        json={
            "name": "Day71確認用ノート 改訂版",
            "price_yen": 300,
            "stock": 20,
            "description": None,
        },
        timeout=TIMEOUT,
    )
    expect_status(response, 200)
    print("更新OK")

    # 不正な更新を拒否することを確認します
    response = requests.put(
        detail_url,
        json={
            "name": "不正な更新",
            "price_yen": -1,
        },
        timeout=TIMEOUT,
    )
    expect_status(response, 422)

    # 拒否された更新で、保存値が変わっていないことを確認します
    response = requests.get(detail_url, timeout=TIMEOUT)
    expect_status(response, 200)

    product = response.json()

    if product["price_yen"] != 300 or product["stock"] != 20:
        raise AssertionError("不正な更新後の保存値が想定と異なります")

    print("入力検証OK")

    # Delete:今回登録した商品だけを削除します
    response = requests.delete(detail_url, timeout=TIMEOUT)
    expect_status(response, 204)

    if response.content != b"":
        raise AssertionError("204の本文が空ではありません")

    print("削除OK")

    # 削除済みの商品が取得できないことを確認します
    response = requests.get(detail_url, timeout=TIMEOUT)
    expect_status(response, 404)

    print("CRUDの確認が完了しました")


if __name__ == "__main__":
    main()
Python

サーバーを起動したまま、別のターミナルで実行します。

# 自分で登録した1件を使い、CRUDを確認します
python verify_api.py

想定される表示です。商品IDは登録状況によって変わります。

登録OK: 商品ID=2
取得OK
更新OK
入力検証OK
削除OK
CRUDの確認が完了しました

このプログラムが途中で失敗した場合、確認用商品が残ることがあります。表示されたIDを使い、/docsで状態を確認してください。

また、この確認は最後に商品を削除します。再起動後の保存確認とは別の試験として扱います。

トランザクションの境界を深く理解する

今回の各APIでは、次の形を使っています。

# トランザクションの範囲を示す例です
with session.begin():
    # この範囲で、取得や変更を行います
    pass

# 正常終了し、確定できたあとで応答を返します
Python

この設計では、変更処理の途中で例外が起きれば、未確定の変更を取り消します。

ただし、確定済みのデータを、あとからrollbackで自由に戻せるわけではありません。また、DBの取り消しは、外部へのメール送信や別サービスへのAPI呼び出しまで取り消す仕組みではありません。(🔗 docs.sqlalchemy.org)

今回の学習では、まず「1回のリクエストで行うDB操作」を短いまとまりとして扱います。

なぜ、取得もsession.beginで囲むのでしょうか

今回のコードでは、読み取りも含めてSessionの利用範囲をそろえています。

読み取りAPIで商品を書き換えるわけではありませんが、どこでデータを読み、どこでトランザクションを終了するかを明確にする意図です。

この教材では、Sessionを作る場所、トランザクションを始める場所、レスポンスを返す場所を追いやすくすることを優先しています。

SQLite接続で勘違いしやすいこと

check_same_thread=Falseは、安全を自動保証する設定ではありません

これはPythonのSQLiteドライバーのスレッド検査に関する設定です。

FastAPIのSQLite利用例でも使われますが、「同じSessionを複数のリクエストで同時に共有してよい」という意味ではありません。今回もSessionはリクエストごとに分けています。(🔗 fastapi.tiangolo.com)

待ち時間を増やせば、同時更新問題が全部解決するわけではありません

今回のtimeoutは5秒ですが、これだけで多数の書き込みを並列に処理できる構成になるわけではありません。

SQLiteは、同時の書き込みが多い用途では、クライアント・サーバー型DBの検討が必要になる場合があります。今回のようなローカル学習では、まずトランザクションを短くし、書き込み途中に長い処理を挟まない方針にします。(🔗 sqlite.org)

async defに変更すれば、自動で非同期DB接続になるわけではありません

今回のAPI関数は、同期型SQLAlchemy Sessionを使うため、通常のdefで統一しています。

接続ライブラリを変えずに関数名の前へasyncを付けるだけ、という変更は行いません。非同期DBアクセスは、対応するEngineやSession、ドライバーを組み合わせて学ぶ別の段階です。(🔗 docs.sqlalchemy.org)

create_allは、データベース構造の更新機能ではありません

今回の起動処理では、次のコードを使っています。

# 定義済みのテーブルがなければ作成します
Base.metadata.create_all(engine)
Python

これは、既存のproductsテーブルへ新しいカラムを自動追加する処理ではありません。

たとえば、あとからcategory_idをモデルへ追加しても、既存DBが自動で同じ構造になるとは考えないでください。既存テーブルの変更は、マイグレーションとして別に管理します。(🔗 docs.sqlalchemy.org)

学習用であっても、データを残したい場合は、構造変更とデータ保護をセットで考えます。

入力エラーと、保存先の障害を分ける

今回のAPIでは、次のように考えます。

状況今回の扱い確認する場所
価格が負です入力検証で拒否しますリクエストのJSONです
商品IDが存在しません404を返します対象IDです
DBファイルへ書き込めません成功扱いにはしませんサーバー側のエラーです
他の処理でDBがロックされています保存に失敗する場合があります他アプリとトランザクションです
DB構造とモデルが異なります修正・移行が必要ですモデルと実際のテーブルです

今回の完成版では、DB障害を一律に「入力が悪い」と変換する処理は入れていません。

実用化するときは、内部情報を利用者へ出しすぎないエラー応答と、原因を調べるためのサーバーログを設計します。

安全に発展させるための確認事項

今回のアプリには、認証や権限管理はありません。したがって、実在する顧客情報を登録し、外部へ公開する用途には、そのまま使わないでください。

  • 学習では、架空の商品だけを使います。
  • 入力の型が正しくても、操作権限を確認したことにはなりません。
  • 削除成功後の復元機能は、今回実装していません。
  • 同じJSONをPOSTすると、今回の仕様では別商品として登録します。
  • 更新前に他の利用者が変更したかを検出する仕組みはありません。
  • データベースファイルを暗号化する処理は実装していません。
  • dataフォルダを、内容未確認のまま公開しない運用にします。

Gitを使う場合の、今回のプロジェクト用設定例です。

# ローカルのDBや関連ファイルを追跡対象から外します
data/

# 仮想環境とPythonの生成ファイルです
.venv/
__pycache__/

この設定例は、情報管理のすべてを解決するものではありません。そもそも学習データへ実情報を混ぜない方針を優先します。

動作確認チェックリスト

確認内容操作今回の期待結果
初回起動新しい作業フォルダで起動しますDBとテーブルが作られます
登録正しいJSONをPOSTします201と商品IDを返します
一覧GET /productsを実行します商品配列を返します
詳細登録したIDをGETします商品情報を返します
更新全項目をPUTします更新結果を返します
省略更新PUTでstockを省略します今回は0になります
不正入力負の価格を送ります422で拒否します
不存在存在しないIDを指定します404です
削除登録した商品をDELETEします本文なしの204です
永続保存削除せずに再起動します同じ商品を取得できます
保存先起動時の表示を見ます想定したDBパスです

この表は、今回のコードで確認するための期待値です。コードを眺めるだけでなく、実際の結果と照合してください。

Day 71の仕上げ課題

  • 4ファイルを作成し、APIを起動します。
  • 登録から削除までを/docsで操作します。
  • verify_api.pyを実行します。
  • 別の商品を残し、再起動後も取得できることを確認します。
  • database.pyとmodels.pyの役割の違いを説明します。
  • 入力モデルとORMモデルで、同じような条件を確認する理由を説明します。
  • 一覧へ価格上限のクエリパラメータを追加します。
  • 商品検索を追加したら、検索条件をSQLのWHEREへどう対応させるか考えます。

価格上限を追加するときは、「未指定」と「0円を指定」を区別することも忘れないでください。前回までの学習内容を、少しずつ今回の構成へ移していきます。

Day 71のまとめ

今回の制作では、FastAPI、入力・出力モデル、ORM、SQLiteを、責任の分かれた構成へ整理しました。

  • database.pyでは、接続基盤とSessionの作り方を定義しました。
  • models.pyでは、保存するテーブルを定義しました。
  • schemas.pyでは、APIの入口と出口を定義しました。
  • main.pyでは、HTTPリクエストとCRUDを結び付けました。
  • Sessionの後片付けと、トランザクションの確定を区別しました。
  • 再起動後の確認によって、永続保存を確かめました。

Day 71の到達点は、「SQLiteへ保存できた」だけではありません。どのファイルが何を担当し、いつ接続を使い、いつ変更が確定し、いつ後片付けされるかを説明できることです。この土台が整うと、検索機能、関連テーブル、認証、テストなどを追加するときも、変更する場所を判断しやすくなります。

タイトルとURLをコピーしました