Python FastAPI入門：初心者向けAPI開発ガイド

By /

Python FastAPI入門：初心者向けAPI開発ガイド

はじめに

現代のソフトウェア開発において、API（Application Programming Interface）は不可欠な要素です。モバイルアプリケーション、フロントエンドのウェブサイト、IoTデバイス、そしてマイクロサービス間の連携など、様々な場所でデータのやり取りや機能の呼び出しにAPIが利用されています。

Pythonはデータサイエンス、機械学習、自動化など幅広い分野で人気がありますが、API開発においても非常に強力な選択肢です。FlaskやDjangoのようなフレームワークは長年にわたりPythonでのウェブ開発やAPI開発を支えてきましたが、近年、新たなフレームワークが注目を集めています。それが FastAPI です。

FastAPIは、その名前が示す通り、高速（Fast）であること、そしてAPI開発に特化していることを特徴としています。Pythonのモダンな機能（特に型ヒントとasyncio）を最大限に活用することで、開発の生産性と実行時のパフォーマンスを両立させています。さらに、OpenAPI標準とJSON Schemaに準拠したAPIドキュメントを自動生成する機能は、開発者にとって非常に大きなメリットとなります。

この詳細なガイドでは、Pythonを使ってAPIを開発したいと考えている初心者の方を対象に、FastAPIの基本的な使い方から、より実践的な機能までをステップバイステップで解説します。FastAPIの魅力に触れ、実際に動くAPIを構築できるようになることを目指します。

この記事で学ぶこと:

  • FastAPIとは何か、なぜ人気があるのか
  • FastAPIプロジェクトのセットアップ方法
  • 基本的なAPIエンドポイント（GET, POST, PUT, DELETE）の作成
  • パスパラメータとクエリパラメータの扱い方
  • リクエストボディ（JSONデータ）の受け取りと検証
  • Pydanticを使ったデータモデルの定義
  • 自動生成されるAPIドキュメント（Swagger UIとReDoc）の活用
  • HTTPレスポンスのカスタマイズ
  • 基本的なエラーハンドリング
  • 依存性注入（Dependency Injection）の基礎

さあ、FastAPIの世界へ飛び込みましょう！

1. FastAPIとは？なぜFastAPIを選ぶのか？

FastAPIは、Python 3.8+向けのモダンで高速（高性能）なWebフレームワークであり、APIの構築に特化しています。Starlette（軽量なASGIフレームワーク）とPydantic（データ検証ライブラリ）をベースに構築されており、以下の特徴を持っています。

  • 高速: Starletteベースで、GoやNode.jsといったコンパイル言語や非同期フレームワークに匹敵する非常に高いパフォーマンスを発揮します。これは、Pythonの非同期I/Oライブラリであるasyncioを効果的に利用しているためです。
  • 開発速度の向上: 型ヒントを積極的に活用することで、エディタの補完機能が強力に働き、開発ミスを減らし、コードを書く速度を向上させます。Pydanticによるデータの自動検証も開発効率を高めます。
  • バグの削減: 型ヒントとPydanticによるデータ検証により、実行時エラーの多くを事前に防ぐことができます。
  • 直感的: シンプルでわかりやすいAPI設計になっています。
  • 簡単な学習: ドキュメントが非常に充実しており、学習コストが比較的低いフレームワークです。
  • 自動ドキュメント: OpenAPI (以前のSwagger) 標準に準拠した対話型のAPIドキュメント（Swagger UIとReDoc）を自動生成します。これにより、APIの仕様書を手動で作成・更新する手間が省け、フロントエンド開発者やAPI利用者が容易にAPIの使い方を理解できます。
  • 標準準拠: OpenAPIとJSON Schemaという広く受け入れられている標準に準拠しているため、他のツールとの連携も容易です。

これらの特徴から、FastAPIはマイクロサービスの開発、機械学習モデルのAPI化、モダンなウェブアプリケーションのバックエンドなど、幅広い用途で非常に人気が高まっています。特に、非同期処理を多用するI/Oバウンドな処理（データベースアクセス、外部API呼び出しなど）を含むAPIにおいては、そのパフォーマンスが大きな利点となります。

2. 開発環境のセットアップ

FastAPIを始める前に、いくつかの準備が必要です。

2.1 Pythonのインストール

FastAPIはPython 3.8以上が必要です。まだインストールしていない場合は、公式ウェブサイトから最新版のPythonをダウンロードしてインストールしてください。

インストール後、ターミナルやコマンドプロンプトで以下のコマンドを実行し、Pythonが正しくインストールされているか、バージョンがFastAPIの要件を満たしているか確認しましょう。

“`bash
python –version

または

python3 –version
“`

2.2 仮想環境の利用（強く推奨）

Pythonプロジェクトを開発する際は、仮想環境を利用することを強く推奨します。仮想環境を使うことで、プロジェクトごとに必要なライブラリのバージョンを隔離し、異なるプロジェクト間での依存関係の衝突を防ぐことができます。

Python 3.3以降では、venvという仮想環境を作成・管理するための標準ライブラリが付属しています。

プロジェクト用のディレクトリを作成し、その中で仮想環境を作成しましょう。

“`bash

プロジェクトディレクトリを作成

mkdir myapi
cd myapi

仮想環境を作成（環境名は .venv など任意）

python -m venv .venv

または python3 -m venv .venv

“`

仮想環境を作成したら、それをアクティベート（有効化）します。

  • macOS/Linux:
    bash
    source .venv/bin/activate
    ターミナルのプロンプトの先頭に仮想環境の名前（例: (.venv)）が表示されれば成功です。

  • Windows (Command Prompt):
    cmd
    .venv\Scripts\activate.bat

  • Windows (PowerShell):
    powershell
    .venv\Scripts\Activate.ps1

仮想環境を終了したい場合は、deactivateコマンドを実行します。

bash
deactivate

以降の作業は、仮想環境をアクティベートした状態で行ってください。

2.3 FastAPIとUvicornのインストール

FastAPIを動かすためには、FastAPIライブラリ自体と、ASGIサーバーが必要です。FastAPIはASGI (Asynchronous Server Gateway Interface) という標準インターフェース上で動作します。一般的なASGIサーバーとしては、Uvicorn、Hypercornなどがあります。FastAPIのドキュメントではUvicornが推奨されています。

仮想環境をアクティベートしたターミナルで、以下のコマンドを実行して必要なライブラリをインストールします。

bash
pip install fastapi uvicorn[standard]

  • fastapi: FastAPIフレームワーク本体です。
  • uvicorn[standard]: Uvicorn ASGIサーバーをインストールします。[standard]オプションは、パフォーマンスを向上させるための追加の依存関係（如：uvloop, httptools）も一緒にインストールします。

これでFastAPIを使ったAPI開発を始めるための準備が整いました！

3. 最初のFastAPIアプリケーション

さあ、実際にコードを書いて最初のFastAPIアプリケーションを作成しましょう。

3.1 “Hello, World!” API

myapiディレクトリ内に main.py というファイルを作成し、以下のコードを記述します。

“`python

main.py

from fastapi import FastAPI

FastAPIのインスタンスを作成

app = FastAPI()

GETリクエストに対するパスオペレーションを定義

@app.get(“/”)
async def read_root():
return {“Hello”: “World”}
“`

コードの解説:

  1. from fastapi import FastAPI: fastapi ライブラリから FastAPI クラスをインポートしています。
  2. app = FastAPI(): FastAPI クラスのインスタンスを作成しています。この app インスタンスが、APIの全ての機能を定義する中心となります。
  3. @app.get("/"): これはPythonのデコレータと呼ばれる構文です。app.get("/") は、HTTPの GET メソッドで / というパス（URLのルート）へのリクエストがあった場合に、その直下に定義されている関数を実行することをFastAPIに指示します。この get や後述する post, put, delete などをパスオペレーションデコレータと呼びます。
  4. async def read_root():: デコレータの直下に関数を定義します。この関数が実際のリクエスト処理を行います。
    • async def: FastAPIは非同期処理 (asyncio) をサポートしています。I/Oバウンドな処理（ファイルの読み書き、データベースへのアクセス、外部API呼び出しなど）を含むパスオペレーションは async def で定義することで、その処理中に他のリクエストを並行して処理できるようになり、アプリケーション全体のパフォーマンスが向上します。この例では簡単な辞書を返すだけなので async は必須ではありませんが、FastAPIでは慣習的に async def を使うことが多いです。同期的な処理しか行わない場合は def でも構いません。
    • read_root: 関数の名前は任意ですが、何を行う関数なのかがわかる名前にすると良いでしょう。
    • (): この関数は今のところ引数を取りません。後でパスパラメータやクエリパラメータ、リクエストボディを受け取る際に引数を定義します。
  5. return {"Hello": "World"}: この関数が返す値が、クライアントへのレスポンスボディとなります。FastAPIはPythonの辞書 (dict) やリスト (list) を自動的にJSON形式に変換してレスポンスとして返します。

3.2 アプリケーションの実行

作成したFastAPIアプリケーションをASGIサーバーであるUvicornを使って実行します。

プロジェクトディレクトリ（main.pyがある場所）で、仮想環境がアクティベートされていることを確認し、以下のコマンドを実行します。

bash
uvicorn main:app --reload

コマンドの解説:

  • uvicorn: 実行するサーバーの名前です。
  • main:app: Uvicornに、main.pyファイル内のappという名前のFastAPIインスタンスを実行するように指示しています。ファイル名:FastAPIインスタンス名の形式です。
  • --reload: このオプションを付けると、コードの変更を検知してサーバーが自動的に再起動されます。開発中は非常に便利なので付けておくことを推奨します。

コマンドを実行すると、以下のような出力が表示されるはずです。

INFO: Will watch for changes in these directories: ['/path/to/myapi']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [xxxxx] using statreload
INFO: Started server running on http://127.0.0.1:8000

これでアプリケーションが起動しました。http://127.0.0.1:8000 でリクエストを受け付けています。

3.3 APIへのアクセスと確認

ウェブブラウザやcURLなどのツールを使って、起動したAPIにアクセスしてみましょう。

  • ウェブブラウザ:
    ブラウザのアドレスバーに http://127.0.0.1:8000 と入力してEnterを押します。
    画面に {"Hello":"World"} というJSONが表示されるはずです。

  • cURL (ターミナル/コマンドプロンプト):
    bash
    curl http://127.0.0.1:8000
    ターミナルに {"Hello":"World"} と出力されます。

おめでとうございます！これで最初のFastAPIアプリケーションが正常に動作しました。

4. 自動生成されるAPIドキュメント

FastAPIの最も便利な機能の一つに、対話型のAPIドキュメントの自動生成があります。アプリケーションが起動している状態で、以下のURLにアクセスしてみてください。

  • Swagger UI: http://127.0.0.1:8000/docs
  • ReDoc: http://127.0.0.1:8000/redoc

4.1 Swagger UI (/docs)

Swagger UIにアクセスすると、定義したAPIエンドポイント（この例では / へのGETリクエスト）が一覧表示されます。

Swagger UI example
(画像はFastAPI公式ドキュメントより)

  • エンドポイントの表示: 定義したパス (/) とHTTPメソッド (GET) が表示されます。
  • APIの試行: 各エンドポイントを展開すると、「Try it out」ボタンが表示されます。これをクリックすると、パラメータを入力して実際にそのAPIを呼び出すことができます。
  • レスポンスの確認: APIを呼び出した結果、リクエストURL、レスポンスボディ、レスポンスヘッダー、HTTPステータスコードなどが確認できます。

これはAPIの動作確認や、他の開発者へのAPI仕様共有に非常に役立ちます。コードを変更して保存すると、--reloadオプションのおかげでサーバーが再起動され、ドキュメントも自動的に最新の状態に更新されます。

4.2 ReDoc (/redoc)

ReDocにアクセスすると、より視覚的で読みやすい形式のAPIドキュメントが表示されます。

ReDoc example
(画像はFastAPI公式ドキュメントより)

ReDocはAPI全体を一つのページに整理して表示するのに適しており、APIリファレンスとして利用するのに便利です。

これらのドキュメントは、FastAPIがコード中の型ヒントやパスオペレーションデコレータの情報から自動的にOpenAPI仕様を生成し、それをSwagger UIやReDocが整形して表示することで実現されています。特別な設定なしにこれほど高品質なドキュメントが得られるのは、FastAPIの大きな強みです。

5. パスパラメータとクエリパラメータ

APIでは、しばしばリクエストURLの一部やクエリ文字列からデータを受け取る必要があります。FastAPIではこれを簡単に行えます。

5.1 パスパラメータ

URLのパスの一部として渡されるデータです。例えば /items/5 の 5 のように、特定のリソースを識別するためによく使われます。

FastAPIでは、パスパラメータを波括弧 {} で囲んでパスに含めることで定義します。そして、パスオペレーション関数の引数として、波括弧で囲んだ名前と同じ名前の引数を定義します。

main.py を以下のように編集して、/items/{item_id} というパスパラメータを持つエンドポイントを追加してみましょう。

“`python
from fastapi import FastAPI

app = FastAPI()

元のルートエンドポイントはそのまま

@app.get(“/”)
async def read_root():
return {“Hello”: “World”}

パスパラメータを持つエンドポイント

@app.get(“/items/{item_id}”)
async def read_item(item_id): # <- item_id という引数を定義
return {“item_id”: item_id}
“`

uvicorn main:app --reload でサーバーを起動（または再起動）し、http://127.0.0.1:8000/items/5 や http://127.0.0.1:8000/items/foo にアクセスしてみてください。レスポンスとして {"item_id": "5"} や {"item_id": "foo"} が返ってくるはずです。

型ヒントの活用:

FastAPIはPythonの型ヒントを積極的に利用します。パスパラメータの引数に型ヒントを追加することで、FastAPIは自動的にデータの型変換と検証を行ってくれます。

read_item 関数を以下のように修正します。

python
@app.get("/items/{item_id}")
async def read_item(item_id: int): # <- 型ヒントを int に変更
return {"item_id": item_id}

これで、item_id は整数型として扱われます。

  • http://127.0.0.1:8000/items/5 にアクセスすると、item_id は整数 5 として関数に渡され、{"item_id": 5} が返されます。（JSONでは数値は引用符なしで表示されることが多いです）
  • http://127.0.0.1:8000/items/foo のように整数に変換できない値を渡すと、FastAPIは自動的に検証エラーを返し、HTTPステータスコード 422 Unprocessable Entity とエラー詳細を含むJSONレスポンスが返されます。手動で型チェックやエラー処理を書く必要がありません。

Swagger UI (/docs) を見てみましょう。/items/{item_id} エンドポイントには、item_id が必須の整数型パラメータであることがドキュメント化されています。ここでも「Try it out」で異なる値を試すことができます。

5.2 クエリパラメータ

URLの ? の後に キー=値 の形式で渡されるパラメータです。複数ある場合は & で繋ぎます。例えば /items?limit=10&offset=0 の limit=10 や offset=0 の部分です。主にフィルタリング、ページネーション、ソートなどのオプションを指定するために使われます。

クエリパラメータは、パスオペレーション関数の引数として定義します。パスパラメータと異なり、特別な構文は必要ありません。関数引数として定義されたものが、パスパラメータとして宣言されていなければ、自動的にクエリパラメータとして扱われます。

main.py を以下のように編集し、/items/{item_id} エンドポイントにクエリパラメータ q を追加してみましょう。

“`python
from fastapi import FastAPI

Optional を使うために typing モジュールをインポート

from typing import Union

app = FastAPI()

@app.get(“/”)
async def read_root():
return {“Hello”: “World”}

パスパラメータとクエリパラメータを持つエンドポイント

@app.get(“/items/{item_id}”)
async def read_item(item_id: int, q: Union[str, None] = None):
# Union[str, None] は str または None 型を意味する
# = None は q が省略可能（オプショナル）であることを示す
if q: # q が None でない場合
return {“item_id”: item_id, “q”: q}
return {“item_id”: item_id}
“`

  • item_id: int: これはパスパラメータとして定義されています（URLパスに含まれているため）。型は int です。
  • q: Union[str, None] = None: これはクエリパラメータとして定義されています。
    • q という名前のクエリパラメータを受け取ります。
    • Union[str, None] または Python 3.10以降であれば str | None は、パラメータの型が文字列 (str) または None であることを示します。これは、クエリパラメータが省略可能であることを表現するためによく使われます。
    • = None: 引数にデフォルト値 None を設定することで、このパラメータが必須ではない（オプショナルである）ことを示します。デフォルト値を指定しない場合、そのクエリパラメータは必須となります。

サーバーを再起動し、以下のURLで試してみましょう。

  • http://127.0.0.1:8000/items/5 -> {"item_id": 5} が返されます (q は省略されているため)。
  • http://127.0.0.1:8000/items/5?q=somequery -> {"item_id": 5, "q": "somequery"} が返されます (q が渡されたため)。
  • http://127.0.0.1:8000/items/foo?q=somequery -> item_id が整数ではないため、422 エラーが返されます。

Swagger UI (/docs) を見ると、/items/{item_id} エンドポイントには、必須のパスパラメータ item_id (integer) と、オプショナルなクエリパラメータ q (string) がドキュメント化されています。

このように、FastAPIは型ヒントとデフォルト値を利用することで、パスパラメータとクエリパラメータの定義、型変換、検証、そしてドキュメント化を自動的に行ってくれます。

デフォルト値と必須パラメータ:

  • 引数にデフォルト値を指定しない場合（例: item_id: int）、そのパラメータは 必須 となります。
  • 引数にデフォルト値を指定した場合（例: q: Union[str, None] = None または skip: int = 0）、そのパラメータは オプショナル となります。

5.3 型ヒントを活用したパラメータ検証

FastAPIはPydanticと連携し、型ヒントを使ってより複雑なパラメータ検証を行うことができます。

例えば、クエリパラメータに数値を受け取り、その最小値や最大値を制限したい場合などです。fastapi モジュールから Query や Path をインポートして使用します。

“`python
from fastapi import FastAPI, Query, Path
from typing import Union

app = FastAPI()

@app.get(“/”)
async def read_root():
return {“Hello”: “World”}

より高度な検証を持つパスパラメータとクエリパラメータ

@app.get(“/items/{item_id}”)
async def read_item(
item_id: int = Path(…, title=”The ID of the item to get”, ge=1), # item_id は必須 ( ge=1 は1以上)
q: Union[str, None] = Query(None, alias=”item-query”, max_length=50, description=”The query string for the item”) # q はオプショナル
):
# Path(…) の … は、デフォルト値がない、つまり必須であることを示す
# Query(None, …) の None は、デフォルト値 None、つまりオプショナルであることを示す
results = {“item_id”: item_id}
if q:
results.update({“q”: q})
return results
“`

  • item_id: int = Path(..., title="...", ge=1):
    • Path(...) を使うことで、これがパスパラメータであることを明示し、追加の検証やメタデータを設定できます。
    • ... (Ellipsis) は、このパラメータが必須であり、デフォルト値がないことを示します。
    • title, description: 自動生成ドキュメントに表示されるメタデータです。
    • ge=1: Pydanticの機能を利用して、値が1以上であることを検証します (ge = greater than or equal)。他にも le (less than or equal), gt (greater than), lt (less than) などがあります。
  • q: Union[str, None] = Query(None, alias="item-query", max_length=50, description="..."):
    • Query(None, ...) を使うことで、これがクエリパラメータであることを明示し、追加の検証やメタデータを設定できます。デフォルト値 None を渡すことでオプショナルにしています。
    • alias="item-query": クエリパラメータの名前を item-query としますが、関数内の引数名としては q を使います。これはURL上のパラメータ名とコード上の変数名を分けたい場合に便利です。
    • max_length=50: 文字列の最大長を50文字に制限します。

これらの変更を保存し、サーバーを再起動してSwagger UIを確認すると、より詳細な情報（必須/オプショナル、型、検証ルール、説明、別名）がドキュメント化されているのがわかります。実際に試してみると、検証ルールに違反した場合（例: item_id=0 や q が50文字を超える場合）に自動的に422エラーが返されることが確認できます。

6. リクエストボディの受け取り（POST, PUT）

POSTやPUTリクエストでは、URLパラメータだけでなく、リクエストのボディにJSONなどのデータを含めて送信することが一般的です。FastAPIでは、リクエストボディのデータをPythonオブジェクトとして簡単に受け取り、さらにそのデータを自動的に検証することができます。

この機能は、Pydanticというライブラリと連携して実現されます。Pydanticを使うと、データの構造をクラスとして定義でき、FastAPIはその定義に基づいて受信したJSONデータを検証し、定義したクラスのインスタンスに変換してくれます。

6.1 Pydanticモデルの定義

まず、リクエストボディとして期待するデータの構造をPydanticモデルとして定義します。

main.py に以下のPydanticモデルを追加します。

“`python
from fastapi import FastAPI
from pydantic import BaseModel # PydanticのBaseModelをインポート
from typing import Union, Optional # Optionalを使う場合

app = FastAPI()

Pydanticモデルの定義

class Item(BaseModel):
# 型ヒント付きで属性を定義
name: str # 必須の文字列
price: float # 必須の浮動小数点数
is_offer: Union[bool, None] = None # Optional[bool] と同じ、デフォルト値は None

仮のデータベースとしてリストを使う

この例では単純化のためグローバル変数にリストを置くが、

実際にはデータベースなどを使う

fake_items_db = [{“item_name”: “Foo”}, {“item_name”: “Bar”}, {“item_name”: “Baz”}]

@app.get(“/”)
async def read_root():
return {“Hello”: “World”}

これまでの /items/{item_id} エンドポイント

@app.get(“/items/{item_id}”)
async def read_item(item_id: int, q: Union[str, None] = None):
if q:
return {“item_id”: item_id, “q”: q}
return {“item_id”: item_id}

仮のデータベースから全アイテムを取得するエンドポイント

@app.get(“/items/”)
async def read_items():
return fake_items_db

新しいアイテムを作成する POST エンドポイント

@app.post(“/items/”)

item: Item でリクエストボディを Item モデルとして受け取る

async def create_item(item: Item):
# 受信したデータは Pydantic モデルのインスタンスとして関数に渡される
# item.name, item.price, item.is_offer でアクセスできる
# Pydantic モデルは dict() メソッドで辞書に変換できる
item_dict = item.dict()
# 例として、item_idを追加してみる
item_dict.update({“item_id”: “fakeid”})
# 仮のデータベースに追加（実際にはDBに保存）
fake_items_db.append({“item_name”: item.name}) # データベースへの追加はitem_nameのみ
return item_dict # レスポンスとして作成したアイテムを返す
“`

コードの解説:

  1. from pydantic import BaseModel: Pydanticの基底モデルクラス BaseModel をインポートします。
  2. class Item(BaseModel):: BaseModel を継承して Item というクラスを定義しています。これがデータのモデルになります。
  3. name: str: name という属性（フィールド）は文字列型 (str) であり、必須であることを示します（デフォルト値がないため）。
  4. price: float: price 属性は浮動小数点数型 (float) であり、必須です。
  5. is_offer: Union[bool, None] = None: is_offer 属性はブール型 (bool) または None を受け付け、デフォルト値が None であるためオプショナルです。Optional[bool] は Union[bool, None] の短縮形です。
  6. @app.post("/items/"): /items/ パスへの POST リクエストを処理するエンドポイントを定義します。
  7. async def create_item(item: Item):: 関数 create_item は、引数 item を取ります。
    • item: Item: ここで、引数の型ヒントとして先ほど定義したPydanticモデル Item を指定しています。FastAPIはこれを見て、リクエストボディのJSONを読み込み、Item モデルの定義に従って検証し、検証が成功すればそのデータを Item クラスのインスタンスとして item 引数に渡します。
  8. 関数本体では、受け取った item オブジェクトの属性（item.name, item.price, item.is_offer）にアクセスして処理を行います。item.dict() メソッドは、PydanticモデルのインスタンスをPythonの辞書に変換します。

サーバーを再起動し、Swagger UI (/docs) を見てみましょう。/items/ パスに新しい POST セクションが追加されているはずです。展開すると、リクエストボディのスキーマ（Item モデル）が定義されており、必須フィールドなどがドキュメント化されています。「Try it out」でリクエストボディの例が表示され、それを編集して実際にPOSTリクエストを送信できます。

試してみる (Swagger UI または cURL):

  • Swagger UI: /items/ (POST) セクションで「Try it out」をクリックし、Request bodyに以下のJSONを入力して「Execute」します。
    json
    {
    "name": "Awesome Item",
    "price": 19.95,
    "is_offer": true
    }
    成功すると、HTTPステータスコード 200 OK と共に、レスポンスボディに作成されたアイテムのデータ（例: {"name": "Awesome Item", "price": 19.95, "is_offer": true, "item_id": "fakeid"}）が返されます。

  • cURL:
    bash
    curl -X POST -H "Content-Type: application/json" -d '{"name": "New Item", "price": 25.5}' http://127.0.0.1:8000/items/
    is_offer はオプショナルなので省略可能です。サーバーは {"name": "New Item", "price": 25.5, "is_offer": null, "item_id": "fakeid"} のようなJSONを返します。

データ検証エラー:

必須フィールドを省略したり、型が一致しない値を送信したりすると、Pydanticが自動的に検証を行い、HTTPステータスコード 422 Unprocessable Entity と詳細なエラーメッセージを含むJSONレスポンスが返されます。

“`bash

price を省略して POST

curl -X POST -H “Content-Type: application/json” -d ‘{“name”: “Bad Item”}’ http://127.0.0.1:8000/items/
json
{
“detail”: [
{
“type”: “missing”,
“loc”: [
“body”,
“price”
],
“msg”: “Field required”,
“type”: “value_error.missing”
}
]
}
“`
このように、FastAPIとPydanticを使えば、リクエストボディのデータ検証とシリアライズ・デシリアライズを簡単かつ宣言的に行うことができます。

6.2 PUTリクエストでのボディとパスパラメータの組み合わせ

PUTリクエストは、既存のリソースを更新するためによく使われます。通常、更新対象のリソースをパスパラメータで指定し、更新内容をリクエストボディで送信します。

例として、特定のアイテムを更新するPUTエンドポイントを追加してみましょう。仮のデータベースのアイテムを更新する処理をシミュレートします。

まず、Pydanticモデルにもう一つ属性を追加しておくと便利かもしれません。

“`python

main.py (既存のコードに追記または変更)

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Union, Optional

app = FastAPI()

class Item(BaseModel):
name: str
price: float
is_offer: Union[bool, None] = None
# 更新時に description をオプションで追加してみる
description: Union[str, None] = None

仮のデータベース（辞書にしてみる）

fake_items_db = {
“foo”: {“name”: “Foo”, “price”: 50.2},
“bar”: {“name”: “Bar”, “price”: 62.0, “description”: “The bartenders bar”},
“baz”: {“name”: “Baz”, “price”: 50.2, “is_offer”: True}
}

GET /items/ (全件取得はそのまま)

@app.get(“/items/”)
async def read_items():
return fake_items_db

GET /items/{item_id} (特定アイテム取得)

@app.get(“/items/{item_id}”)
async def read_item(item_id: str): # ここでは item_id を str で受け取る（DBのキー名）
if item_id in fake_items_db:
return fake_items_db[item_id]
# 存在しない場合は 404 エラーを返す
from fastapi import HTTPException
raise HTTPException(status_code=404, detail=”Item not found”)

POST /items/ (アイテム作成)

@app.post(“/items/”)
async def create_item(item: Item):
# ここでは新しいアイテムを fake_items_db に追加するのではなく、
# 受け取ったアイテムデータを返すのみとする (シンプル化)
# 実際にはユニークIDを生成してDBに追加するなどを行う
return item # 受け取ったItemモデルのインスタンスをそのまま返すとJSONに変換される

PUT /items/{item_id} (アイテム更新)

@app.put(“/items/{item_id}”)

パスパラメータ item_id と リクエストボディ item を同時に受け取る

async def update_item(item_id: str, item: Item):
# 仮のデータベースを更新する処理
if item_id in fake_items_db:
# 受け取った item オブジェクトの内容で更新
# item.dict() で Pydantic モデルを辞書に変換
fake_items_db[item_id] = item.dict()
return {“item_id”: item_id, **item.dict()} # 更新されたアイテム情報を返す
else:
# 存在しないアイテムIDの場合は新規作成とみなすこともできるが、
# 今回はシンプルにエラーとする
from fastapi import HTTPException
raise HTTPException(status_code=404, detail=f”Item with ID {item_id} not found”)

“`

コードの解説:

  1. fake_items_db をリストから辞書に変更しました。これは、アイテムID（文字列キー）を使って特定のアイテムに素早くアクセスできるようにするためです。
  2. GET /items/{item_id} エンドポイントも、辞書からアイテムを取得するように修正し、存在しない場合は HTTPException を発生させるようにしました（エラーハンドリングについては後述します）。item_id の型を str に変更しました。
  3. POST /items/ はシンプル化のため、受け取った item をそのまま返すようにしました。
  4. @app.put("/items/{item_id}"): /items/{item_id} パスへの PUT リクエストを処理するエンドポイントです。
  5. async def update_item(item_id: str, item: Item):: 関数はパスパラメータ item_id (string型) と、リクエストボディとして期待されるPydanticモデル Item のインスタンスを item という引数で受け取ります。
  6. 関数内で、受け取った item_id をキーとして fake_items_db を検索し、存在すれば item.dict() で取得した辞書データでそのエントリを更新します。

サーバーを再起動し、Swagger UIで /items/{item_id} (PUT) エンドポイントを確認してみてください。パスパラメータ item_id とリクエストボディ Item の両方がドキュメント化されているのがわかります。

試してみる (Swagger UI または cURL):

  • Swagger UI: /items/{item_id} (PUT) セクションで「Try it out」をクリックします。
    • item_id に foo と入力します。
    • Request body に以下のJSONを入力して「Execute」します。
      json
      {
      "name": "Updated Foo",
      "price": 55.0,
      "description": "This is an updated item"
      }
      成功すると、HTTPステータスコード 200 OK と共に、更新されたアイテム情報が返されます。http://127.0.0.1:8000/items/foo にGETリクエストを送ると、更新されたデータが取得できるはずです。
    • item_id に nonexistent のような存在しないIDを入力して試すと、404 Not Found エラーが返されるのが確認できます。

パスパラメータとリクエストボディは、異なる情報源からのデータですが、FastAPIではこれらを関数の引数として自然に組み合わせることができます。

7. HTTPメソッド

これまで GET, POST, PUT を見てきました。FastAPIでは、GET 以外にも主要なHTTPメソッドに対応するパスオペレーションデコレータが用意されています。

  • @app.get(): データの取得
  • @app.post(): 新しいデータの作成
  • @app.put(): 既存のデータの更新（全体または指定部分）
  • @app.delete(): データの削除
  • @app.options(): リソースに対する通信オプションの取得
  • @app.head(): GETと同じヘッダーを取得（ボディはなし）
  • @app.patch(): 既存のデータの一部更新
  • @app.trace(): リモートのアプリケーションレベルのメッセージループパスをたどる

これらはすべて同様の構文で使用できます。パスパラメータ、クエリパラメータ、リクエストボディの扱いは、メソッドの種類に関わらず同じように定義できます。

例として、アイテムを削除する DELETE エンドポイントを追加してみましょう。

“`python

main.py (既存のコードに追記)

… 既存のimport, appインスタンス, Itemモデル, fake_items_db …

DELETE /items/{item_id} (アイテム削除)

@app.delete(“/items/{item_id}”)
async def delete_item(item_id: str):
if item_id in fake_items_db:
del fake_items_db[item_id] # 辞書からエントリを削除
return {“message”: f”Item with ID {item_id} deleted successfully”}
else:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail=f”Item with ID {item_id} not found”)

… 既存の GET, POST, PUT エンドポイント …

“`

サーバーを再起動し、Swagger UIで /items/{item_id} (DELETE) エンドポイントを確認してください。

試してみる (Swagger UI または cURL):

  • Swagger UI: /items/{item_id} (DELETE) で「Try it out」、item_id に例えば foo と入力して実行します。成功すれば 200 OK とメッセージが返されます。その後 GET /items/foo を試すと 404 Not Found になるはずです。

8. レスポンスモデル

FastAPIでは、リクエストボディの検証だけでなく、APIからのレスポンスの構造もPydanticモデルを使って定義・検証・整形することができます。これをレスポンスモデルと呼びます。

レスポンスモデルを指定することで、以下のメリットがあります。

  • 自動ドキュメント: レスポンスのスキーマが自動生成ドキュメントに正確に表示されます。
  • データ整形・フィルタリング: 関数が返すPythonオブジェクトに余計な属性が含まれていても、レスポンスモデルで定義された属性だけがクライアントに返されるJSONに含まれます。これにより、意図しないデータの漏洩を防ぐことができます。
  • データ検証: 返すデータがレスポンスモデルの定義に合致するかどうかが検証されます（開発時に役立ちます）。

レスポンスモデルは、パスオペレーションデコレータの response_model 引数にPydanticモデルを指定することで設定します。

例として、GET /items/{item_id} エンドポイントのレスポンスモデルを指定してみましょう。アイテムの詳細を返すので、Item モデルを使用できます。

“`python

main.py (既存のコードに追記または変更)

… 既存のimport, appインスタンス, Itemモデル, fake_items_db …

GET /items/{item_id} (特定アイテム取得) – response_model を追加

@app.get(“/items/{item_id}”, response_model=Item) # <– response_model を指定
async def read_item(item_id: str):
if item_id in fake_items_db:
# 辞書を返す。FastAPIはこれを Item モデルとして検証し、JSONに変換する。
# Item モデルにないキー(例えば後から追加した一時的なデータ)は無視される。
return fake_items_db[item_id]
else:
from fastapi import HTTPException
raise HTTPException(status_code=404, detail=”Item not found”)

GET /items/ (全件取得) のレスポンスモデルをリストのItemに指定

typing から List をインポート

from typing import List

@app.get(“/items/”, response_model=List[Item]) # <– List[Item] を指定
async def read_items():
# 辞書のリストを返す。各要素は Item モデルとして検証される。
return list(fake_items_db.values()) # 辞書の値をリストに変換して返す

… 既存の POST, PUT, DELETE エンドポイント …

“`

コードの解説:

  1. from typing import List: レスポンスモデルがPydanticモデルのリストである場合、typing から List をインポートします。
  2. @app.get("/items/{item_id}", response_model=Item): response_model=Item を追加しました。これにより、このエンドポイントが返すレスポンスは Item モデルの構造に従うべきことがFastAPIに伝わります。実際に返す値（fake_items_db[item_id] の辞書）は、FastAPIによって自動的に Item モデルとして検証され、その構造に基づいてJSONにシリアライズされます。もし辞書に Item モデルに含まれないキーがあっても、それはレスポンスJSONには含まれません。
  3. @app.get("/items/", response_model=List[Item]): 全アイテム取得のエンドポイントのレスポンスモデルを List[Item] に指定しました。これは、「このエンドポイントは Item モデルのリストを返す」という意味になります。返す値 list(fake_items_db.values()) は辞書のリストですが、FastAPIはリストの各要素を Item モデルとして検証し、適切なJSON配列に変換します。

サーバーを再起動し、Swagger UI (/docs) を見てみましょう。各エンドポイントの「Responses」セクションに、定義したレスポンスモデルに基づいた詳細なスキーマが表示されていることがわかります。

レスポンスモデルの使い分け:

  • リクエストボディ: クライアントから送られてくるデータの構造を定義・検証するために使用します。パスオペレーション関数の引数に型ヒントとしてPydanticモデルを指定します。
  • レスポンスモデル: サーバーからクライアントへ返すデータの構造を定義・検証・整形するために使用します。パスオペレーションデコレータの response_model 引数にPydanticモデルを指定します。

これらを組み合わせることで、APIの入出力両方において明確なスキーマと自動検証、ドキュメント化を実現できます。

9. エラーハンドリング

API開発において、エラーへの適切な対応は非常に重要です。 Fast APIでは、HTTPエラーレスポンスを簡単に返すための方法がいくつか提供されています。

9.1 HTTPException

最も一般的な方法は、fastapi モジュールから HTTPException をインポートし、パスオペレーション関数内でエラー条件に遭遇した場合に raise HTTPException(...) を使うことです。

HTTPException は、HTTPステータスコードと詳細（detail）メッセージを引数に取ります。詳細メッセージはクライアントへのレスポンスボディとして返されます。

既に GET /items/{item_id} や DELETE /items/{item_id} でアイテムが見つからなかった場合に 404 Not Found を返す例で HTTPException を使用しています。

“`python

main.py (一部再掲)

from fastapi import FastAPI, HTTPException

… その他 import …

… appインスタンス, Itemモデル, fake_items_db …

GET /items/{item_id} (特定アイテム取得)

@app.get(“/items/{item_id}”, response_model=Item)
async def read_item(item_id: str):
if item_id in fake_items_db:
return fake_items_db[item_id]
else:
# アイテムが見つからない場合は 404 Not Found エラーを発生させる
raise HTTPException(status_code=404, detail=”Item not found”)

DELETE /items/{item_id} (アイテム削除)

@app.delete(“/items/{item_id}”)
async def delete_item(item_id: str):
if item_id in fake_items_db:
del fake_items_db[item_id]
return {“message”: f”Item with ID {item_id} deleted successfully”}
else:
# アイテムが見つからない場合は 404 Not Found エラーを発生させる
raise HTTPException(status_code=404, detail=f”Item with ID {item_id} not found”)

… その他エンドポイント …

“`

raise HTTPException(status_code=404, detail="Item not found") のように呼び出すと、FastAPIは自動的にHTTPステータスコード 404 を設定し、ボディに {"detail": "Item not found"} というJSONを含むレスポンスを返します。

一般的なHTTPステータスコードには以下のようなものがあります。

  • 200 OK: リクエスト成功
  • 201 Created: リソース作成成功 (POST など)
  • 204 No Content: リクエスト成功、レスポンスボディなし (DELETE など)
  • 400 Bad Request: クライアントのリクエストが不正 (形式など)
  • 401 Unauthorized: 認証が必要だが提供されていない、または無効
  • 403 Forbidden: 認証はされているが、リソースへのアクセス権限がない
  • 404 Not Found: リソースが見つからない
  • 405 Method Not Allowed: 指定されたメソッドが許可されていない
  • 422 Unprocessable Entity: リクエストの構文は正しいが、意味的に処理できない (Pydantic検証エラーなど)
  • 500 Internal Server Error: サーバー側の予期しないエラー

状況に応じて適切なステータスコードを使用することが重要です。

9.2 デフォルトのエラーハンドリング

FastAPI（およびStarlette）は、Pydanticによる検証エラー (422 Unprocessable Entity) やその他の一般的なHTTPエラーに対するデフォルトのエラーハンドラーを持っています。先ほどパスパラメータの型が間違っていた場合に422エラーが自動的に返されたのは、このデフォルトハンドラーのおかげです。

9.3 カスタムエラーハンドリング

特定のタイプのエラーや例外に対して、独自のレスポンスを返したい場合は、カスタムエラーハンドラーを登録することも可能ですが、入門レベルでは HTTPException を使う方法で十分でしょう。公式ドキュメントにはカスタムハンドリングの方法も詳しく解説されています。

10. 依存性注入（Dependency Injection）

依存性注入は、FastAPIの強力な機能の一つです。これは、パスオペレーション関数が必要とする「依存関係」（他のコンポーネントや値など）を、FastAPIが自動的に「注入」してくれる仕組みです。

依存関係は、FastAPIのパスオペレーション関数や、他の依存関係として定義された関数など、呼び出し可能なオブジェクト（callable）として定義されます。FastAPIはリクエストを受け付けた際に、これらの依存関係を実行し、その結果をパスオペレーション関数の引数として渡します。

依存性注入を使うことで、以下のメリットが得られます。

  • コードの再利用: 複数のパスオペレーションで共通して必要な処理（データベース接続、認証、設定値の取得、共通のパラメータ処理など）を一つの関数として定義し、再利用できます。
  • コードのモジュール化: 各関数やパスオペレーションは、自身が必要とするものだけを宣言すればよく、依存関係の取得や初期化といった責任から解放されます。
  • テスト容易性: 依存関係をモックオブジェクトなどに簡単に置き換えてテストできます。
  • コードの整理: ロジックが整理され、パスオペレーション関数自体はビジネスロジックに集中できます。
  • 自動ドキュメント: 依存関係として定義されたパラメータも自動生成ドキュメントに含まれます。

10.1 シンプルな依存関係の例

簡単な例として、共通のクエリパラメータを処理する依存関係を作成してみましょう。ページネーションでよく使われる skip と limit パラメータを扱う関数を定義します。

“`python

main.py (既存のコードに追記)

from fastapi import FastAPI, Depends # Depends をインポート
from typing import Union, Optional

… その他 import, appインスタンス, Itemモデル, fake_items_db …

依存関係として使用する関数を定義

この関数はクエリパラメータ skip と limit を受け取り、辞書で返す

async def common_parameters(skip: int = 0, limit: int = 100):
return {“skip”: skip, “limit”: limit}

GET /items/ (全件取得) のエンドポイントを変更し、依存関係を使用

@app.get(“/items/”, response_model=List[Item])

引数 common: dict = Depends(common_parameters) で依存関係を注入

async def read_items(common: dict = Depends(common_parameters)):
# common には common_parameters 関数の戻り値（{“skip”: …, “limit”: …}）が入る
skip = common[“skip”]
limit = common[“limit”]
# 仮のデータベースから指定範囲のアイテムを返す
return list(fake_items_db.values())[skip : skip + limit] # スライスで範囲を指定

… その他エンドポイント …

“`

コードの解説:

  1. from fastapi import Depends: 依存関係を宣言するために Depends をインポートします。
  2. async def common_parameters(skip: int = 0, limit: int = 100):: 依存関係として使用する通常の関数を定義します。この関数も引数としてパラメータ（この場合はクエリパラメータ skip と limit）を受け取ることができます。
  3. @app.get("/items/", response_model=List[Item]): /items/ エンドポイントの定義です。
  4. async def read_items(common: dict = Depends(common_parameters)):: パスオペレーション関数 read_items に、新しい引数 common を追加しました。
    • common: dict: 引数の型ヒントは、依存関係が返す値の型 (dict) です。
    • = Depends(common_parameters): これが依存関係の宣言です。Depends 関数に、呼び出す依存関係関数 (common_parameters) を渡します。FastAPIはリクエスト処理中に common_parameters を呼び出し、その戻り値を read_items 関数の common 引数に渡します。
  5. 関数本体では、注入された common 辞書から skip と limit を取り出し、仮のデータベースから指定された範囲のアイテムを返すようにロジックを変更しました。

サーバーを再起動し、Swagger UIで /items/ (GET) エンドポイントを確認してください。クエリパラメータ skip (integer, default=0) と limit (integer, default=100) がドキュメントに追加されています。これらは common_parameters 関数で定義した引数から自動的にドキュメント化されます。

試してみる:

  • http://127.0.0.1:8000/items/ -> 全アイテムが返されます (skip=0, limit=100が適用)。
  • http://127.0.0.1:8000/items/?skip=1&limit=1 -> 2番目のアイテム1つだけが返されます。

10.2 依存関係内で他の依存関係を使用

依存関係関数は、さらに別の依存関係を持つこともできます。FastAPIは依存関係のチェーンを解決し、適切な順序で実行します。

10.3 クラスを使った依存関係

依存関係は関数だけでなく、クラスを使って定義することもできます。クラスを使った依存関係は、依存関係が状態を持つ必要がある場合（例：データベースセッション）や、より構造的に依存関係を定義したい場合に便利です。

クラスを依存関係として使う場合、FastAPIはそのクラスをインスタンス化し、そのインスタンスをパスオペレーション関数に渡します。もしクラスに __call__ メソッドが定義されていれば、FastAPIはそのメソッドを実行し、その戻り値を渡します（これはより進んだ使い方です）。シンプルなケースでは、クラスのインスタンスをそのまま受け取ってその属性やメソッドを利用することが多いです。

“`python

main.py (既存のコードに追記)

… 既存のimport, appインスタンス, Itemモデル, fake_items_db …

クラスを使った依存関係の定義

class CommonQueryParams:
def init(self, q: Union[str, None] = None, skip: int = 0, limit: int = 100):
self.q = q
self.skip = skip
self.limit = limit

GET /items/ のエンドポイントを変更し、クラス依存関係を使用

@app.get(“/items/”)

引数 common: CommonQueryParams = Depends() で依存関係を注入

async def read_items(common: CommonQueryParams = Depends(CommonQueryParams)):
# common には CommonQueryParams クラスのインスタンスが入る
response = {“items”: list(fake_items_db.values())[common.skip : common.skip + common.limit]}
if common.q:
response.update({“q”: common.q})
return response

… その他エンドポイント …

“`

コードの解説:

  1. class CommonQueryParams:: __init__ メソッドを持つクラスを定義します。__init__ メソッドの引数に定義されたパラメータ（q, skip, limit）は、FastAPIによって自動的に解決されます（クエリパラメータとして）。
  2. async def read_items(common: CommonQueryParams = Depends(CommonQueryParams)):: read_items 関数の引数を変更しました。
    • common: CommonQueryParams: 型ヒントは CommonQueryParams クラスです。
    • = Depends(CommonQueryParams): Depends にクラス自体を渡します。FastAPIは CommonQueryParams() を呼び出し、そのインスタンスを common 引数に渡します。
  3. 関数本体では、注入された common インスタンスの属性（common.skip, common.limit, common.q）にアクセスして処理を行います。

サーバーを再起動し、Swagger UIで /items/ (GET) エンドポイントを確認してください。今回は q クエリパラメータも追加でドキュメント化されていることがわかります。

依存性注入は、FastAPIでアプリケーションを構築する上で非常に重要な概念です。認証・認可、データベースセッション管理、設定読み込みなど、様々な場面で活用されます。

11. さらに進んだトピック（概要）

入門レベルで上記の機能（パス/クエリパラメータ、リクエストボディ、Pydantic、自動ドキュメント、エラーハンドリング、依存性注入）を理解すれば、基本的なAPIは十分構築できます。しかし、FastAPIにはさらに多くの強力な機能があります。ここではそれらの概要のみ紹介します。詳細については公式ドキュメントを参照してください。

  • Background Tasks: APIレスポンスをクライアントに返した後で実行したいタスク（例: メールの送信、ファイルの後処理）を定義できます。BackgroundTasks を依存関係として注入して使用します。
  • WebSockets: クライアントとサーバー間での双方向通信を実現するためのWebSocketsをサポートしています。
  • Security (Authentication & Authorization): OAuth2、JWT、HTTP Basic認証などの認証・認可メカニズムを簡単に実装するためのユーティリティを提供しています。依存性注入を活用して、パスオペレーションに関数を注入することで実現されます。
  • Middleware: 各リクエストがパスオペレーション関数に到達する前、またはレスポンスがクライアントに返される前に、共通の処理（例: CORSヘッダーの追加、ロギング、カスタム認証）を実行したい場合にミドルウェアを使用します。Starletteのミドルウェアを利用します。
  • CORS (Cross-Origin Resource Sharing): 異なるオリジン（ドメイン、ポートなど）からのリクエストを許可するための設定を簡単に行うことができます。StarletteのCORSMiddlewareを使用するのが一般的です。
  • Static Files: HTML、CSS、JavaScript、画像などの静的ファイルを配信する必要がある場合、StaticFiles を使用できます。
  • Testing: fastapi.testclient.TestClient を使うことで、アプリケーション全体を実行せずに、FastAPIアプリケーションに対して擬似的なリクエストを送信し、レスポンスを確認するテストを簡単に書くことができます。これはRequestsライブラリをベースにしています。
  • Deployment: 開発時には uvicorn で --reload オプションを使って実行しますが、本番環境ではより堅牢なASGIサーバー（例: Uvicorn, Gunicorn + Uvicorn worker）を使用し、リバースプロキシ（例: Nginx, Traefik）と組み合わせて運用するのが一般的です。Dockerコンテナでのデプロイも容易です。

これらのトピックは、より本格的なアプリケーションを構築する際に必要になってくるでしょう。

12. まとめと次のステップ

このガイドでは、FastAPIを使った基本的なAPI開発のステップを詳細に解説しました。FastAPIの高速性、開発効率、自動ドキュメント生成といったメリットを実感していただけたかと思います。

学習した内容:

  • FastAPIの基本とセットアップ
  • パスオペレーション (@app.get, @app.post など) の定義
  • パスパラメータとクエリパラメータの扱い
  • Pydanticを使ったリクエストボディの定義と検証
  • 自動生成されるAPIドキュメント (Swagger UI, ReDoc) の活用
  • レスポンスモデルによる出力の定義と整形
  • HTTPException を使った基本的なエラーハンドリング
  • Depends を使った依存性注入の基礎

FastAPIはPythonのモダンな機能を活用することで、開発者がAPIのビジネスロジックに集中できるよう設計されています。自動生成されるドキュメントは開発効率を劇的に向上させ、Pydanticによるデータ検証は堅牢なAPIを構築する上で強力な味方となります。

次のステップ:

  1. 練習: このガイドで学んだことをもとに、簡単なAPIをいくつか自分で作成してみてください。例えば、ユーザー管理API（ユーザーの作成、取得、更新、削除）や、ToDoリストAPIなどが良い練習になります。
  2. 公式ドキュメントを読む: FastAPIの公式ドキュメントは非常に充実しており、多くの機能や高度な使い方、ベストプラクティスについて詳しく解説されています。ぜひ積極的に参照してください。
  3. データベース連携: 実際のAPI開発では、データベースとの連携が不可欠です。SQLAlchemy（ORM）や他のデータベースライブラリとFastAPIを組み合わせて使う方法を学びましょう。公式ドキュメントにもSQLAlchemyを使った例があります。
  4. 認証・認可の実装: 実際のAPIでは、誰がアクセスできるか、どのような操作が許可されるかを制御する必要があります。FastAPIのセキュリティ機能を使って認証・認可を実装する方法を学びましょう。
  5. テストの書き方: 変更を加えてもAPIが正しく動作し続けることを保証するために、テストを書くことは重要です。TestClient を使ったテストの書き方を学びましょう。
  6. デプロイ方法: 開発したAPIをインターネット上に公開するためのデプロイ方法（Uvicorn/Gunicorn、Docker、クラウドプラットフォームなど）を学びましょう。

FastAPIは活発に開発されており、コミュニティも大きいため、困ったことがあれば情報を探しやすく、サポートも得やすいでしょう。

この記事が、あなたがPythonとFastAPIを使ったAPI開発の素晴らしい旅を始めるための一助となれば幸いです。頑張ってください！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール