# FastAPIでのRepositoryパターンを用いたPostgreSQL利用の実装例

## 目次
1. 1-1. はじめに
2. 1-2. 環境設定
3. 1-3. アプリケーション構造
4. 2-1. FastAPIのインストール
5. 2-2. PostgreSQLの設定
6. 2-3. SQLAlchemyとPydanticの設定
7. 3-1. モデル定義
8. 3-2. レポジトリパターンの実装
9. 3-3. ルーターとエンドポイントの作成
10. 4-1. 動作確認
11. まとめ

## 1-1. はじめに
FastAPIは、PythonでRESTful APIを構築するための軽量で高性能なフレームワークです。PostgreSQLをデータベースとして利用しつつ、Repositoryパターンを採用することで、コードの可読性や保守性を向上させます。

## 1-2. 環境設定
- Python 3.9以上
- PostgreSQL 12以上
- FastAPI 0.65.2以上
- SQLAlchemy 1.4以上
- Pydantic 1.8.2以上
- Docker (オプショナル)

## 1-3. アプリケーション構造
プロジェクトのディレクトリ構造は以下の通りです。

```
my_fastapi_app/
    ├── app/
    │   ├── main.py
    │   ├── models.py
    │   ├── repositories/
    │   │   └── user_repository.py
    │   ├── routers/
    │   │   └── user_router.py
    │   └── database.py
    ├── requirements.txt
    └── docker-compose.yml
```

## 2-1. FastAPIのインストール
まずは必要なパッケージをインストールします。

```bash
pip install fastapi uvicorn sqlalchemy psycopg2-binary
```

`requirements.txt` にこれらの依存関係を記載しておくと便利です。

## 2-2. PostgreSQLの設定
Dockerを使用してPostgreSQLをセットアップします。`docker-compose.yml`は以下の内容です。

```yaml
version: '3'
services:
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    ports:
      - "5432:5432"
```

コンテナを起動します。

```bash
docker-compose up -d
```

## 2-3. SQLAlchemyとPydanticの設定
SQLAlchemyを用いてデータモデルを作成し、Pydanticを利用してデータバリデーションを行います。

## 3-1. モデル定義
`models.py`でSQLAlchemyのモデルを定義します。

```python
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql://myuser:mypassword@localhost/mydatabase"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    email = Column(String, unique=True, index=True)
```

## 3-2. レポジトリパターンの実装
`repositories/user_repository.py`にて、データベース操作を行うクラスを定義します。

```python
from sqlalchemy.orm import Session
from .models import User
from .schemas import UserCreate

class UserRepository:
    def __init__(self, db: Session):
        self.db = db

    def get_user(self, user_id: int) -> User:
        return self.db.query(User).filter(User.id == user_id).first()

    def create_user(self, user: UserCreate) -> User:
        db_user = User(name=user.name, email=user.email)
        self.db.add(db_user)
        self.db.commit()
        self.db.refresh(db_user)
        return db_user
```

## 3-3. ルーターとエンドポイントの作成
`routers/user_router.py`にルーターを実装します。

```python
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from ..database import SessionLocal, engine
from ..repositories.user_repository import UserRepository
from ..schemas import UserCreate, UserRead
from ..models import Base

router = APIRouter()

# 確実にテーブルが作成されるように
Base.metadata.create_all(bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@router.post("/users/", response_model=UserRead)
def create_user(user: UserCreate, db: Session = Depends(get_db)):
    db_user = UserRepository(db).create_user(user=user)
    return db_user
```

## 4-1. 動作確認
アプリを実行して、エンドポイントが正常に動作するか確認します。

```bash
uvicorn app.main:app --reload
```

ブラウザで`http://127.0.0.1:8000/docs`にアクセスし、FastAPIのSwagger UIを使ってAPIをテストします。

## まとめ
今回の実装例では、FastAPIとPostgreSQLを組み合わせてレポジトリパターンを採用し、データベースとのやり取りを抽象化する方法を紹介しました。これにより、アプリケーションの構造が明確になり、変更への適応力も向上します。また、テストの際にもレポジトリパターンは役立ちます。是非参考にしてください。 [cv:issue_marketplace_engineer]

FastAPIでのRepositoryパターンを用いたPostgreSQL利用の実装例

目次

続きを読むには単価診断を受けてください（30秒）