Django
第1部: Django入門
[編集]第1章: Djangoとは
[編集]Djangoの概要と特徴
[編集]Django（ジャンゴ）は、Pythonで書かれた強力なウェブアプリケーションフレームワークです。2005年にローレンス・ジャーナル・ワールド社の内部プロジェクトとして誕生し、その後オープンソースとして公開されました。「締切りに追われるパーフェクショニストのためのフレームワーク」というスローガンが示すように、開発効率と品質の両立を重視して設計されています。
Djangoの最大の特徴は、必要な機能があらかじめ用意された「バッテリー同梱（Battery Included）」の思想です。データベース操作、フォーム処理、認証、管理画面など、ウェブアプリケーション開発に必要な機能が標準で提供されています。これにより、開発者は基礎的な機能の実装に時間を費やすことなく、ビジネスロジックの実装に注力することができます。
セキュリティ面においても、Djangoは優れた特徴を持っています。クロスサイトスクリプティング（XSS）、クロスサイトリクエストフォージェリ（CSRF）、SQLインジェクションなどの一般的な攻撃に対する防御機能が標準で組み込まれており、セキュアなアプリケーション開発をサポートします。
Pythonウェブフレームワークの中でのDjangoの位置づけ
[編集]現在、Python用のウェブアプリケーションフレームワークには、Django以外にもFlask、FastAPI、Pyramidなど、多くの選択肢が存在します。その中でDjangoは「フルスタックフレームワーク」として、最も包括的な機能を提供しています。
Flaskが最小限の機能を提供し、開発者に大きな自由度を与える「マイクロフレームワーク」であるのに対し、Djangoは規約に従った開発を促します。これは一見制約のように感じられるかもしれませんが、大規模なプロジェクトでは一貫性のある開発を実現し、保守性を高めることにつながります。
FastAPIが非同期処理と高速なパフォーマンスに特化しているのに対し、Djangoは汎用性と開発効率を重視しています。ただし、Django 3.0以降では非同期処理もサポートされており、現代的なウェブ開発のニーズにも対応しています。
Djangoを選ぶ理由
[編集]Djangoを選択する最大の理由は、生産性の高さにあります。データベースのスキーマからAdmin画面が自動生成される機能や、豊富なミドルウェア、充実したテンプレートエンジンなど、開発効率を向上させる機能が数多く用意されています。
また、Djangoは成熟したフレームワークとして、広範なドキュメントと活発なコミュニティを持っています。問題に直面した際に、解決策を見つけやすい環境が整っていることは、実務での開発において大きな利点となります。
企業での採用実績も、Djangoの強みの一つです。Instagram、Mozilla、Pinterest、National Geographic など、多くの著名なサービスがDjangoを採用しています。これは、Djangoが大規模なサービスの開発・運用に耐えうる信頼性を持っていることを示しています。
さらに、Pythonのエコシステムとの親和性も重要な利点です。機械学習やデータ分析のライブラリが充実しているPythonの特性を活かし、これらの機能をウェブアプリケーションに統合しやすい環境を提供します。
Djangoは初学者にとっても学びやすいフレームワークです。MVT（Model-View-Template）アーキテクチャに従った明確な構造と、豊富な学習リソースにより、段階的に知識を深めていくことができます。同時に、カスタマイズや拡張の余地も十分にあり、上級者の要求にも応えることができます。
以上のような特徴から、Djangoは個人の小規模プロジェクトから企業の大規模システムまで、幅広い用途に適したフレームワークだと言えます。次章からは、実際にDjangoを使用するための環境構築と基本的な使い方について、詳しく見ていきましょう。
第2章: 開発環境のセットアップ
[編集]Python環境の構築
[編集]Djangoの開発環境を整える第一歩は、適切なPython環境の構築です。Djangoは3.2以降のバージョンでPython 3.8以上を必要とします。本書では長期サポート（LTS）版のPython 3.10を使用することを推奨します。
WindowsユーザーはPythonの公式ウェブサイトからインストーラーをダウンロードしてインストールできます。インストール時には「Add Python to PATH」オプションを必ず有効にしてください。これにより、コマンドプロンプトからPythonを直接実行できるようになります。
macOSユーザーの場合、Homebrewを使用したインストールが推奨されます。Homebrewをインストール後、「brew install python」コマンドを実行することで、最新のPythonをインストールできます。なお、macOSには初期状態でPython 2系がインストールされていますが、これは使用しないでください。
Linuxユーザーの場合、ディストリビューションのパッケージマネージャーを使用してインストールできます。Ubuntu/Debianの場合は「apt install python3」、RedHat系の場合は「dnf install python3」を使用します。
インストール完了後、ターミナルで「python --version」を実行し、適切なバージョンがインストールされていることを確認してください。
仮想環境の作成と管理
[編集]Python開発において、プロジェクトごとに独立した環境を用意することは非常に重要です。これにより、異なるプロジェクト間でのパッケージのバージョン競合を防ぎ、クリーンな開発環境を維持できます。
Python 3には仮想環境を作成するためのvenvモジュールが標準で組み込まれています。新しいプロジェクトを始める際は、以下の手順で仮想環境を作成します。
まず、プロジェクトのディレクトリを作成し、その中で仮想環境を初期化します。仮想環境の名前は一般的に「venv」や「env」が使用されますが、任意の名前を付けることができます。仮想環境を作成したら、それをアクティベートして使用します。
mkdir myproject cd myproject python -m venv venv
仮想環境のアクティベートはOS依存です。Windowsの場合は「venv\Scripts\activate」を、Unix系の場合は「source venv/bin/activate」を実行します。アクティベート後、プロンプトに仮想環境名が表示され、パッケージのインストールがこの環境に制限されるようになります。
Djangoのインストール
[編集]仮想環境をアクティベートした状態で、pipを使用してDjangoをインストールします。本書では安定版のDjango 4.2（LTS）を使用します。
pip install Django==4.2
インストールが完了したら、Pythonインタープリタを起動し、Djangoのバージョンを確認します。
import django print(django.get_version())
この時点で、必要に応じて追加のパッケージもインストールしておくとよいでしょう。開発に便利なパッケージとして、django-debug-toolbar（デバッグ支援）やdjango-extensions（開発用ユーティリティ）などがあります。
統合開発環境(IDE)の選択とセットアップ
[編集]効率的なDjango開発には、適切な統合開発環境（IDE）の選択が重要です。本書では、無料で利用できるVSCode（Visual Studio Code）の使用を推奨します。VSCodeは軽量でありながら、拡張機能により高度な開発支援機能を利用できます。
VSCodeをインストールしたら、Python開発に必要な以下の拡張機能をインストールしてください：
- Python（Microsoft公式の Python拡張）
- Django（Django開発支援）
- Pylance（高度なPythonコード解析）
- GitLens（Gitの統合機能強化）
VSCodeの設定では、プロジェクトの仮想環境を正しく認識させることが重要です。コマンドパレット（Ctrl+Shift+P）から「Python: Select Interpreter」を実行し、先ほど作成した仮想環境のPythonインタープリタを選択します。
また、以下の設定をsettings.jsonに追加することで、Django開発に適した環境が整います：
{ "python.linting.enabled": true, "python.linting.pylintEnabled": true, "python.formatting.provider": "black", "editor.formatOnSave": true, "files.associations": { "**/*.html": "html", "'''/templates/'''/*.html": "django-html", "'''/templates/'''/*": "django-txt" } }
この設定により、コードの自動フォーマットやリンティング、Djangoテンプレートの適切なシンタックスハイライトが有効になります。
以上で基本的な開発環境のセットアップは完了です。次章では、この環境を使って実際にDjangoプロジェクトを作成し、基本的な構造について学んでいきます。なお、開発環境の構築は一度きりではなく、プロジェクトの要件に応じて適宜カスタマイズしていくことになります。トラブルシューティングやより詳細な設定については、各ツールの公式ドキュメントを参照することをお勧めします。
第3章: はじめてのDjangoプロジェクト
[編集]プロジェクトの作成
[編集]Djangoプロジェクトは、ウェブアプリケーションの設定や機能を含む一つの単位です。django-adminコマンドを使用して、新しいプロジェクトを作成します。ここでは、ブログシステムを例に説明していきましょう。
プロジェクトの作成には、仮想環境をアクティベートした状態で以下のコマンドを実行します。
django-admin startproject myblog
このコマンドを実行すると、以下のような構造のプロジェクトが作成されます。
</syntaxhighlight> myblog/
├── manage.py
└── myblog/
├── __init__.py
├── settings.py
├── urls.py
├── asgi.py
└── wsgi.py
</syntaxhighlight>
各ファイルの役割について詳しく見ていきましょう。manage.pyは、プロジェクトの管理用コマンドラインツールです。データベースの操作やサーバーの起動など、様々な管理タスクを実行できます。
settings.pyには、プロジェクトの設定が含まれています。データベースの設定、インストールされたアプリケーションのリスト、静的ファイルの配置場所など、重要な設定がここで管理されます。特に、SECRET_KEYは本番環境では必ず変更し、環境変数から読み込むようにしましょう。
urls.pyは、URLパターンを定義するファイルです。ウェブアプリケーションへのリクエストは、ここで定義されたパターンに基づいて適切なビュー関数にルーティングされます。
アプリケーションの作成
[編集]Djangoプロジェクトは、複数のアプリケーションから構成されます。アプリケーションは、特定の機能をまとめた単位です。ブログシステムの場合、記事の管理や表示を行うblogアプリケーションを作成しましょう。
cd myblog python manage.py startapp blog
このコマンドにより、以下のような構造のアプリケーションが作成されます。
blog/ ├── __init__.py ├── admin.py ├── apps.py ├── migrations/ ├── models.py ├── tests.py └── views.py
作成したアプリケーションをプロジェクトで使用するには、settings.pyのINSTALLED_APPSにアプリケーションを追加する必要があります。
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'blog.apps.BlogConfig', # 追加 ]
基本的なプロジェクト構造の理解
[編集]Djangoのプロジェクト構造は、MVT（Model-View-Template）アーキテクチャに基づいています。これは一般的なMVC（Model-View-Controller）パターンのDjango版と考えることができます。
models.pyでは、データベースのテーブル構造をPythonクラスとして定義します。ブログシステムの場合、以下のような記事モデルを定義できます。
from django.db import models from django.utils import timezone class Post(models.Model): title = models.CharField(max_length=200) content = models.TextField() created_date = models.DateTimeField(default=timezone.now) published_date = models.DateTimeField(blank=True, null=True) def publish(self): self.published_date = timezone.now() self.save() def __str__(self): return self.title
views.pyでは、ビュー関数またはクラスベースビューを定義します。ビューは、HTTPリクエストを受け取り、必要な処理を行ってレスポンスを返す役割を担います。
from django.shortcuts import render from .models import Post def post_list(request): posts = Post.objects.filter(published_date__isnull=False).order_by('-published_date') return render(request, 'blog/post_list.html', {'posts': posts})
テンプレートは、HTMLファイルにDjangoのテンプレート言語を組み込んだものです。アプリケーションディレクトリ内にtemplatesディレクトリを作成し、その中にテンプレートファイルを配置します。
{% extends 'base.html' %} {% block content %} {% for post in posts %} <article> <h2>{{ post.title }}</h2> <p>{{ post.content }}</p> <time>{{ post.published_date }}</time> </article> {% endfor %} {% endblock %}
開発サーバーの起動と動作確認
[編集]開発サーバーを起動するには、manage.py runserverコマンドを使用します。
python manage.py runserver
このコマンドにより、開発サーバーがローカルホストの8000番ポートで起動します。ブラウザでhttp://localhost:8000にアクセスすると、Djangoのウェルカムページが表示されます。
開発サーバーは自動リロード機能を備えており、ソースコードの変更を検知して自動的にサーバーを再起動します。ただし、以下の場合は手動での操作が必要です：
- 新しいファイルを追加した場合
- データベースの構造を変更した場合（マイグレーションの実行が必要）
- settings.pyの内容を変更した場合
本番環境では、開発サーバーではなく、GunicornなどのWSGIサーバーを使用することに注意してください。
以上で基本的なDjangoプロジェクトの作成と構造の理解が完了しました。次章では、MVTアーキテクチャについてより詳しく学び、実践的なアプリケーション開発の手法を見ていきます。
第2部: Djangoの基礎概念
[編集]第4章: MVTアーキテクチャ
[編集]Modelの基礎
[編集]Djangoのモデルは、データベースのテーブル構造をPythonクラスとして表現します。モデルは、データの保存、取得、更新、削除といったデータベース操作をオブジェクト指向的に行うための抽象化層を提供します。
モデルの定義は、django.db.modelsをベースに行います。以下は、ブログシステムの記事とカテゴリを表現するモデルの例です。
from django.db import models from django.contrib.auth.models import User class Category(models.Model): name = models.CharField(max_length=100) description = models.TextField(blank=True) created_at = models.DateTimeField(auto_now_add=True) class Meta: verbose_name_plural = "Categories" ordering = ['name'] def __str__(self): return self.name class Article(models.Model): title = models.CharField(max_length=200) content = models.TextField() author = models.ForeignKey(User, on_delete=models.CASCADE) category = models.ForeignKey(Category, on_delete=models.PROTECT) tags = models.CharField(max_length=200, blank=True) created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) is_published = models.BooleanField(default=False) def __str__(self): return self.title def get_summary(self): return self.content[:200] + '...' if len(self.content) > 200 else self.content
モデルでは、フィールドタイプを適切に選択することが重要です。主なフィールドタイプには以下のようなものがあります：
- CharField: 文字列（最大長の指定が必要）
- TextField: 長い文字列
- IntegerField: 整数
- FloatField: 浮動小数点数
- DateTimeField: 日時
- BooleanField: 真偽値
- ForeignKey: 他のモデルへの参照（1対多の関係）
- ManyToManyField: 多対多の関係
- OneToOneField: 1対1の関係
Viewの基礎
[編集]ビューは、Webリクエストを受け取り、処理を行い、レスポンスを返す役割を担います。Djangoでは、関数ベースビュー（FBV）とクラスベースビュー（CBV）の2つの方式でビューを実装できます。
関数ベースビューは、シンプルで理解しやすい特徴があります：
from django.shortcuts import render, get_object_or_404 from .models import Article def article_list(request): articles = Article.objects.filter(is_published=True).order_by('-created_at') context = {'articles': articles} return render(request, 'blog/article_list.html', context) def article_detail(request, article_id): article = get_object_or_404(Article, id=article_id, is_published=True) context = {'article': article} return render(request, 'blog/article_detail.html', context)
一方、クラスベースビューは、共通の処理を継承によって再利用できる利点があります：
from django.views.generic import ListView, DetailView from .models import Article class ArticleListView(ListView): model = Article template_name = 'blog/article_list.html' context_object_name = 'articles' queryset = Article.objects.filter(is_published=True) paginate_by = 10 class ArticleDetailView(DetailView): model = Article template_name = 'blog/article_detail.html' context_object_name = 'article' def get_queryset(self): return Article.objects.filter(is_published=True)
Templateの基礎
[編集]テンプレートは、動的なHTMLを生成するためのシステムです。Djangoのテンプレート言語は、変数の展開、制御構文、フィルタ、継承などの機能を提供します。
基本的なテンプレートの構造は以下のようになります：
{% extends 'base.html' %} {% block title %}記事一覧{% endblock %} {% block content %} <div class="article-list"> {% for article in articles %} <article class="article-item"> <h2>{{ article.title }}</h2> <div class="article-meta"> <span>作成日: {{ article.created_at|date:"Y-m-d" }}</span> <span>著者: {{ article.author.username }}</span> </div> <div class="article-summary"> {{ article.get_summary }} </div> <div class="article-category"> カテゴリ: {{ article.category.name }} </div> </article> {% empty %} <p>記事がありません。</p> {% endfor %} </div> {% if is_paginated %} <nav class="pagination"> {% if page_obj.has_previous %} <a href="?page={{ page_obj.previous_page_number }}">前へ</a> {% endif %} <span class="current"> Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }} </span> {% if page_obj.has_next %} <a href="?page={{ page_obj.next_page_number }}">次へ</a> {% endif %} </nav> {% endif %} {% endblock %}
URLconfの設定
[編集]URLconfは、URLパターンとビューの対応関係を定義します。プロジェクトのurls.pyとアプリケーションのurls.pyを適切に分離することで、モジュール性の高いURLの設定が可能になります。
プロジェクトのurls.py：
from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('blog/', include('blog.urls')), ]
アプリケーションのurls.py：
from django.urls import path from . import views app_name = 'blog' urlpatterns = [ path('', views.ArticleListView.as_view(), name='article_list'), path('<int:pk>/', views.ArticleDetailView.as_view(), name='article_detail'), path('category/<int:category_id>/', views.category_articles, name='category_articles'), ]
MVTパターンの理解
[編集]Djangoにおける各コンポーネントの役割は以下のように整理できます：
- Model: データの構造とビジネスロジックを定義します。データベースとの相互作用を担当し、データの整合性を保証します。
- View: HTTPリクエストを処理し、適切なビジネスロジックを実行して、レスポンスを生成します。
- Template: ユーザーに表示するHTMLを生成します。ビジネスロジックは含まず、表示に関する処理のみを担当します。
これらのコンポーネントは疎結合に保たれ、それぞれの責務が明確に分離されています。この分離により、コードの保守性が向上し、テストが容易になります。次章では、データベース操作についてより詳しく学んでいきます。
第5章: データベース操作
[編集]モデルの定義
[編集]Djangoのモデルは、データベースのテーブル構造をPythonのクラスとして表現するだけでなく、高度なデータ操作機能も提供します。モデルを定義する際は、フィールドの型や制約、リレーションシップを慎重に設計する必要があります。
以下は、より実践的なブログシステムのモデル定義例です：
from django.db import models from django.contrib.auth.models import User from django.utils.text import slugify class Category(models.Model): name = models.CharField(max_length=100, unique=True) slug = models.SlugField(unique=True, blank=True) description = models.TextField(blank=True) parent = models.ForeignKey( 'self', on_delete=models.CASCADE, null=True, blank=True, related_name='children' ) def save(self, *args, **kwargs): if not self.slug: self.slug = slugify(self.name) super().save(*args, **kwargs) class Meta: verbose_name_plural = 'categories' ordering = ['name'] class Tag(models.Model): name = models.CharField(max_length=50, unique=True) slug = models.SlugField(unique=True) def __str__(self): return self.name class Article(models.Model): STATUS_CHOICES = [ ('draft', '下書き'), ('published', '公開済み'), ('archived', 'アーカイブ') ] title = models.CharField(max_length=200) slug = models.SlugField(unique=True) content = models.TextField() summary = models.TextField(blank=True) author = models.ForeignKey( User, on_delete=models.PROTECT, related_name='articles' ) category = models.ForeignKey( Category, on_delete=models.PROTECT, related_name='articles' ) tags = models.ManyToManyField(Tag, related_name='articles') status = models.CharField( max_length=10, choices=STATUS_CHOICES, default='draft' ) created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) published_at = models.DateTimeField(null=True, blank=True) view_count = models.PositiveIntegerField(default=0) class Meta: ordering = ['-created_at'] indexes = [ models.Index(fields=['-created_at']), models.Index(fields=['status', '-published_at']) ] def __str__(self): return self.title
マイグレーション
[編集]マイグレーションは、モデルの変更をデータベースに反映するための仕組みです。マイグレーションファイルの作成と適用は以下のコマンドで行います：
# マイグレーションファイルの作成 python manage.py makemigrations # マイグレーションの適用 python manage.py migrate
マイグレーションのベストプラクティスとして、以下の点に注意が必要です：
- 既存のデータに影響を与える変更は慎重に行う
- マイグレーションファイルはバージョン管理に含める
- 本番環境でのマイグレーションは必ずバックアップを取ってから実行する
- 複雑なデータ変更は、データマイグレーションを使用する
- データマイグレーションの例：
from django.db import migrations def set_default_slugs(apps, schema_editor): Article = apps.get_model('blog', 'Article') for article in Article.objects.all(): article.slug = slugify(article.title) article.save() class Migration(migrations.Migration): dependencies = [ ('blog', '0002_article_slug'), ] operations = [ migrations.RunPython(set_default_slugs), ]
クエリセット
[編集]クエリセットは、データベースからのデータ取得を効率的に行うための強力な機能を提供します。
- 基本的なクエリ操作：
# 全件取得 articles = Article.objects.all() # フィルタリング published_articles = Article.objects.filter(status='published') # 除外 non_draft_articles = Article.objects.exclude(status='draft') # 並び替え recent_articles = Article.objects.order_by('-created_at') # 件数制限 latest_five = Article.objects.order_by('-created_at')[:5] # 複合条件 featured_articles = Article.objects.filter( status='published', category__name='Python' ).exclude( tags__name='draft' ).order_by('-published_at')
- 高度なクエリ操作：
from django.db.models import Q, F, Count, Avg from django.utils import timezone # Q オブジェクトを使用した複雑な条件 complex_query = Article.objects.filter( Q(status='published') & (Q(category__name='Python') | Q(tags__name='Django')) ) # F オブジェクトを使用したフィールド間の比較 updated_articles = Article.objects.filter( updated_at__gt=F('created_at') ) # アノテーションとアグリゲーション category_stats = Category.objects.annotate( article_count=Count('articles'), avg_views=Avg('articles__view_count') ).filter(article_count__gt=0) # サブクエリ popular_categories = Category.objects.filter( articles__view_count__gt=( Article.objects.aggregate( avg_views=Avg('view_count') )['avg_views'] ) ).distinct()
Admin サイトの活用
[編集]Django Adminは、モデルの管理インターフェースを自動生成する強力な機能です。以下は、カスタマイズされたAdmin設定の例です：
from django.contrib import admin from django.utils.html import format_html from .models import Category, Tag, Article @admin.register(Category) class CategoryAdmin(admin.ModelAdmin): list_display = ['name', 'slug', 'parent', 'article_count'] list_filter = ['parent'] search_fields = ['name', 'description'] prepopulated_fields = {'slug': ('name',)} def article_count(self, obj): return obj.articles.count() article_count.short_description = '記事数' @admin.register(Article) class ArticleAdmin(admin.ModelAdmin): list_display = [ 'title', 'author', 'category', 'status', 'published_at', 'view_count', 'tag_list' ] list_filter = ['status', 'category', 'tags'] search_fields = ['title', 'content'] prepopulated_fields = {'slug': ('title',)} raw_id_fields = ['author'] date_hierarchy = 'created_at' filter_horizontal = ['tags'] def tag_list(self, obj): return ', '.join(tag.name for tag in obj.tags.all()) tag_list.short_description = '要素' def get_queryset(self, request): return super().get_queryset(request).prefetch_related('tags')
このように設定されたAdmin サイトでは、効率的なデータ管理が可能になり、開発時のデータ確認や簡単な運用タスクを容易に実行できます。
次章では、フォームとバリデーションについて学び、ユーザーからのデータ入力を適切に処理する方法を見ていきます。
第6章: フォームとバリデーション
[編集]Djangoフォームの基礎
[編集]Djangoのフォームは、HTMLフォームの生成、データのバリデーション、クリーニングを一貫して処理する機能を提供します。フォームの基本的な使い方から、より高度なカスタマイズまでを見ていきましょう。
まず、シンプルなコンタクトフォームの例から始めます：
from django import forms class ContactForm(forms.Form): name = forms.CharField( max_length=100, widget=forms.TextInput(attrs={'class': 'form-control'}) ) email = forms.EmailField( widget=forms.EmailInput(attrs={'class': 'form-control'}) ) subject = forms.CharField( max_length=200, widget=forms.TextInput(attrs={'class': 'form-control'}) ) message = forms.CharField( widget=forms.Textarea(attrs={ 'class': 'form-control', 'rows': 5 }) ) def clean_email(self): email = self.cleaned_data['email'] if not email.endswith(('@example.com', '@example.co.jp')): raise forms.ValidationError('許可されたメールドメインではありません。') return email
このフォームをビューで使用する例：
from django.shortcuts import render, redirect from django.core.mail import send_mail from .forms import ContactForm def contact_view(request): if request.method == 'POST': form = ContactForm(request.POST) if form.is_valid(): name = form.cleaned_data['name'] email = form.cleaned_data['email'] subject = form.cleaned_data['subject'] message = form.cleaned_data['message'] # メール送信処理 send_mail( subject=f'お問い合わせ: {subject}', message=f'送信者: {name}\nメール: {email}\n\n{message}', from_email='noreply@example.com', recipient_list=['admin@example.com'], fail_silently=False, ) return redirect('contact_success') else: form = ContactForm() return render(request, 'contact.html', {'form': form})
モデルフォーム
[編集]モデルフォームは、モデルの定義を基にしてフォームを自動生成する機能です。データベースとの連携が必要なフォームを効率的に作成できます。
from django.forms import ModelForm from .models import Article class ArticleForm(ModelForm): class Meta: model = Article fields = ['title', 'content', 'category', 'tags', 'status'] widgets = { 'title': forms.TextInput(attrs={'class': 'form-control'}), 'content': forms.Textarea(attrs={ 'class': 'form-control', 'rows': 10 }), 'category': forms.Select(attrs={'class': 'form-select'}), 'tags': forms.SelectMultiple(attrs={'class': 'form-select'}), 'status': forms.Select(attrs={'class': 'form-select'}) } help_texts = { 'tags': '複数の要素を選択できます。', 'status': '記事の公開状態を選択してください。' } error_messages = { 'title': { 'required': 'タイトルは必須です。', 'max_length': '200文字以内で入力してください。' } } def clean(self): cleaned_data = super().clean() status = cleaned_data.get('status') content = cleaned_data.get('content') if status == 'published' and len(content) < 100: raise forms.ValidationError( '公開記事の場合、本文は最低100文字必要です。' ) return cleaned_data
バリデーション
[編集]Djangoのフォームバリデーションは、フィールドレベルとフォームレベルの両方で行うことができます。以下は、より高度なバリデーションの例です：
from django import forms from django.core.validators import RegexValidator, MinLengthValidator from django.utils import timezone class UserRegistrationForm(forms.Form): username = forms.CharField( min_length=4, max_length=30, validators=[ RegexValidator( r'^[a-zA-Z0-9_]+$', 'ユーザー名は英数字とアンダースコアのみ使用できます。' ) ] ) password = forms.CharField( widget=forms.PasswordInput, validators=[MinLengthValidator(8)] ) password_confirm = forms.CharField(widget=forms.PasswordInput) birth_date = forms.DateField(widget=forms.DateInput(attrs={'type': 'date'})) def clean_username(self): username = self.cleaned_data['username'] if User.objects.filter(username=username).exists(): raise forms.ValidationError('このユーザー名は既に使用されています。') return username def clean_birth_date(self): birth_date = self.cleaned_data['birth_date'] age = (timezone.now().date() - birth_date).days / 365 if age < 18: raise forms.ValidationError('18歳以上である必要があります。') return birth_date def clean(self): cleaned_data = super().clean() password = cleaned_data.get('password') password_confirm = cleaned_data.get('password_confirm') if password and password_confirm and password != password_confirm: raise forms.ValidationError('パスワードが一致しません。') return cleaned_data
クリーニングとウィジェット
[編集]フォームのクリーニングとウィジェットのカスタマイズにより、より柔軟なフォーム処理が可能になります：
class AdvancedArticleForm(ModelForm): tags_string = forms.CharField( required=False, help_text='カンマ区切りで要素を入力してください' ) class Meta: model = Article fields = ['title', 'content', 'category', 'status'] widgets = { 'content': forms.Textarea(attrs={ 'class': 'markdown-editor', 'data-preview': 'markdown-preview' }) } def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self.instance.pk: self.fields['tags_string'].initial = ', '.join( tag.name for tag in self.instance.tags.all() ) def clean_tags_string(self): tags_string = self.cleaned_data['tags_string'] tag_names = [t.strip() for t in tags_string.split(',') if t.strip()] if len(tag_names) > 5: raise forms.ValidationError('要素は5個まで指定できます。') return tag_names def save(self, commit=True): article = super().save(commit=False) if commit: article.save() # 要素の保存 tag_names = self.cleaned_data['tags_string'] current_tags = set() for name in tag_names: tag, _ = Tag.objects.get_or_create(name=name) current_tags.add(tag) # 既存の要素を更新 article.tags.set(current_tags) return article
このように、Djangoのフォームシステムは、単純なフォームから複雑なデータ処理まで、柔軟に対応できる機能を提供しています。次章では、認証と認可について学び、ユーザー管理の実装方法を見ていきます。
第3部: 実践的なDjango開発
[編集]第3部では、実際のプロジェクトで必要となる実践的なDjango開発の手法について解説していきます。この部では、データベース設計からデプロイメントまで、本番環境で使用できるWebアプリケーションの開発に必要な知識を体系的に学んでいきます。
$1
[編集]データベース設計は、アプリケーション開発の根幹を成す重要な要素です。適切なモデル設計により、保守性の高く拡張性のあるアプリケーションを構築することができます。
まず、基本的なモデルの定義方法から見ていきましょう。以下は、ブログアプリケーションを例にしたモデル定義です：
from django.db import models from django.contrib.auth.models import User class Category(models.Model): name = models.CharField(max_length=100) description = models.TextField(blank=True) created_at = models.DateTimeField(auto_now_add=True) class Meta: verbose_name_plural = "Categories" ordering = ['-created_at'] def __str__(self): return self.name class Post(models.Model): STATUS_CHOICES = [ ('draft', '下書き'), ('published', '公開済み'), ] title = models.CharField(max_length=200) content = models.TextField() author = models.ForeignKey(User, on_delete=models.CASCADE) category = models.ForeignKey(Category, on_delete=models.PROTECT) status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft') created_at = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) def __str__(self): return self.title
このモデル定義では、多対一のリレーションシップをForeignKeyを使って実装しています。on_deleteパラメータは、参照先のオブジェクトが削除された際の動作を指定します。
モデルを定義したら、マイグレーションを作成して適用する必要があります：
python manage.py makemigrations python manage.py migrate
データベースのクエリ最適化も重要なポイントです。以下は、効率的なクエリの例です：
# 非効率的なクエリ posts = Post.objects.all() for post in posts: print(post.author.username) # N+1問題が発生 # 最適化されたクエリ posts = Post.objects.select_related('author').all() for post in posts: print(post.author.username) # 追加のクエリが発生しない
以下の表は、一般的なフィールドタイプとその使用例をまとめたものです：
フィールドタイプ 説明 一般的な用途 CharField 文字列を格納 タイトル、名前など TextField 長文テキストを格納 記事本文、説明文など DateTimeField 日時を格納 作成日時、更新日時など ForeignKey 他のモデルへの参照 リレーションシップの定義 ManyToManyField 多対多の関係を定義 要素、カテゴリーなど
モデルのバリデーションは、データの整合性を保つために重要です。以下は、カスタムバリデーションの実装例です：
from django.core.exceptions import ValidationError from django.utils import timezone class Post(models.Model): # 既存のフィールド定義... def clean(self): if self.status == 'published' and not self.content: raise ValidationError('公開記事には本文が必要です。') if self.created_at > timezone.now(): raise ValidationError('未来の日付は設定できません。') def save(self, *args, **kwargs): self.full_clean() super().save(*args, **kwargs)
これらの基本的な概念を理解した上で、次章ではビューとテンプレートの実装について詳しく見ていきます。
$1
[編集]Djangoのビューとテンプレートは、アプリケーションのロジックとプレゼンテーション層を担う重要な要素です。この章では、効率的なビューの実装方法とテンプレートの活用について解説します。
まず、関数ベースビューの基本的な実装から見ていきましょう：
from django.shortcuts import render, get_object_or_404 from django.contrib.auth.decorators import login_required from .models import Post @login_required def post_detail(request, post_id): post = get_object_or_404(Post, id=post_id) context = { 'post': post, 'related_posts': Post.objects.filter(category=post.category).exclude(id=post.id)[:3] } return render(request, 'blog/post_detail.html', context)
一方、クラスベースビューを使用すると、共通の処理を継承により再利用できます：
from django.views.generic import ListView, DetailView from django.contrib.auth.mixins import LoginRequiredMixin class PostListView(LoginRequiredMixin, ListView): model = Post template_name = 'blog/post_list.html' context_object_name = 'posts' paginate_by = 10 def get_queryset(self): return Post.objects.filter(status='published').select_related('author') def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) context['categories'] = Category.objects.all() return context
テンプレートの継承は、共通のレイアウトを効率的に管理するために重要です。以下は基本テンプレートの例です：
<!-- templates/base.html --> <!DOCTYPE html> <html> <head> <title>{% block title %}Default Title{% endblock %}</title> <link rel="stylesheet" href="{% static 'css/style.css' %}"> </head> <body> <header> {% include 'includes/navbar.html' %} </header> <main> {% block content %} {% endblock %} </main> <footer> {% include 'includes/footer.html' %} </footer> </body> </html>
継承したテンプレートの実装例：
<!-- templates/blog/post_detail.html --> {% extends 'base.html' %} {% block title %}{{ post.title }} | Blog{% endblock %} {% block content %} <article class="post"> <h1>{{ post.title }}</h1> <div class="meta"> {{ post.created_at|date:"Y-m-d" }} by {{ post.author.username }} </div> {{ post.content|safe|linebreaks }} </article> <section class="related-posts"> <h2>関連記事</h2> {% for related_post in related_posts %} {% include 'blog/includes/post_card.html' with post=related_post %} {% endfor %} </section> {% endblock %}
フォーム処理も重要な要素です。以下はフォームクラスの実装例です：
from django import forms from .models import Post class PostForm(forms.ModelForm): class Meta: model = Post fields = ['title', 'content', 'category', 'status'] widgets = { 'content': forms.Textarea(attrs={'class': 'editor'}), 'status': forms.Select(attrs={'class': 'form-select'}) } def clean_title(self): title = self.cleaned_data['title'] if len(title) < 10: raise forms.ValidationError('タイトルは10文字以上必要です。') return title
コンテキストプロセッサーを使用すると、全てのテンプレートで利用可能な共通のコンテキストを定義できます：
# context_processors.py from .models import Category def common_context(request): return { 'categories': Category.objects.all(), 'site_name': 'My Blog', 'current_year': datetime.now().year }
これをsettings.pyに登録します：
TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', 'blog.context_processors.common_context', # 追加 ], }, }, ]
次章では、認証と権限管理について詳しく解説していきます。
$1
[編集]アプリケーションのセキュリティを確保する上で、認証と権限管理は非常に重要な要素です。Djangoは強力な認証システムを提供していますが、これをカスタマイズして実際のプロジェクトに適用する方法を解説します。
まず、カスタムユーザーモデルの実装から始めましょう。デフォルトのUserモデルを拡張する代わりに、完全なカスタムモデルを作成することをお勧めします：
# accounts/models.py from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager from django.db import models class CustomUserManager(BaseUserManager): def create_user(self, email, password=None, **extra_fields): if not email: raise ValueError('メールアドレスは必須です') email = self.normalize_email(email) user = self.model(email=email, **extra_fields) user.set_password(password) user.save(using=self._db) return user def create_superuser(self, email, password=None, **extra_fields): extra_fields.setdefault('is_staff', True) extra_fields.setdefault('is_superuser', True) return self.create_user(email, password, **extra_fields) class CustomUser(AbstractBaseUser, PermissionsMixin): email = models.EmailField(unique=True) username = models.CharField(max_length=100) is_active = models.BooleanField(default=True) is_staff = models.BooleanField(default=False) date_joined = models.DateTimeField(auto_now_add=True) objects = CustomUserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = ['username'] class Meta: verbose_name = 'user' verbose_name_plural = 'users'
settings.pyに以下を追加してカスタムユーザーモデルを有効化します：
AUTH_USER_MODEL = 'accounts.CustomUser'
次に、権限とグループの設定について見ていきましょう。以下は、カスタム権限の実装例です：
# blog/models.py class Post(models.Model): # 既存のフィールド定義... class Meta: permissions = [ ("can_publish_post", "Can publish post"), ("can_feature_post", "Can feature post"), ]
これらの権限を使用したパーミッションミックスインの例：
from django.contrib.auth.mixins import PermissionRequiredMixin class PublishPostView(PermissionRequiredMixin, UpdateView): model = Post permission_required = 'blog.can_publish_post' template_name = 'blog/publish_post.html' def handle_no_permission(self): messages.error(self.request, '記事を公開する権限がありません。') return redirect('blog:post_list')
セッション管理も重要な要素です。以下は、カスタムセッションミドルウェアの実装例です：
# middleware.py from django.utils import timezone class SessionTimeoutMiddleware: def __init__(self, get_response): self.get_response = get_response def __call__(self, request): if request.user.is_authenticated: current_time = timezone.now() last_activity = request.session.get('last_activity') if last_activity and (current_time - last_activity).seconds > 3600: request.session.flush() auth.logout(request) request.session['last_activity'] = current_time response = self.get_response(request) return response
ソーシャル認証の導入には、Python Social Authを使用します。以下は設定例です：
# settings.py INSTALLED_APPS = [ # ... 'social_django', ] AUTHENTICATION_BACKENDS = ( 'social_core.backends.google.GoogleOAuth2', 'social_core.backends.github.GithubOAuth2', 'django.contrib.auth.backends.ModelBackend', ) SOCIAL_AUTH_GOOGLE_OAUTH2_KEY = 'your-key' SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET = 'your-secret'
認証関連のURLパターンの設定：
# urls.py from django.urls import path, include from . import views urlpatterns = [ path('login/', views.CustomLoginView.as_view(), name='login'), path('logout/', views.CustomLogoutView.as_view(), name='logout'), path('signup/', views.SignUpView.as_view(), name='signup'), path('social-auth/', include('social_django.urls', namespace='social')), ]
以下の表は、一般的な認証関連の設定オプションをまとめたものです：
設定項目 説明 デフォルト値 LOGIN_URL ログインページのURL '/accounts/login/' LOGIN_REDIRECT_URL ログイン後のリダイレクト先 '/accounts/profile/' LOGOUT_REDIRECT_URL ログアウト後のリダイレクト先 None SESSION_COOKIE_AGE セッションクッキーの有効期限（秒） 1209600 (2週間) PASSWORD_RESET_TIMEOUT パスワードリセットトークンの有効期限（秒） 259200 (3日間)
この章で説明した認証システムと権限管理の実装により、セキュアなアプリケーションを構築することができます。次の章では、REST APIの実装について詳しく見ていきましょう。
$1
[編集]モダンなWebアプリケーションでは、REST APIの実装は不可欠な要素となっています。Django REST Frameworkを使用することで、効率的にAPIを構築できます。本章では、実践的なREST API開発の手法について解説します。
まず、Django REST Frameworkの基本設定から始めましょう：
# settings.py INSTALLED_APPS = [ # ... 'rest_framework', ] REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': [ 'rest_framework.authentication.SessionAuthentication', 'rest_framework.authentication.TokenAuthentication', ], 'DEFAULT_PERMISSION_CLASSES': [ 'rest_framework.permissions.IsAuthenticated', ], 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination', 'PAGE_SIZE': 10, }
次に、シリアライザーの実装例を見ていきます：
# serializers.py from rest_framework import serializers from .models import Post, Category class CategorySerializer(serializers.ModelSerializer): class Meta: model = Category fields = ['id', 'name', 'description'] class PostSerializer(serializers.ModelSerializer): author = serializers.ReadOnlyField(source='author.username') category = CategorySerializer(read_only=True) category_id = serializers.IntegerField(write_only=True) class Meta: model = Post fields = ['id', 'title', 'content', 'author', 'category', 'category_id', 'status', 'created_at', 'updated_at'] read_only_fields = ['created_at', 'updated_at'] def validate_title(self, value): if len(value) < 10: raise serializers.ValidationError('タイトルは10文字以上必要です。') return value
APIビューの実装には、ViewSetsを使用する方法が効率的です：
# views.py from rest_framework import viewsets, filters, permissions from .serializers import PostSerializer, CategorySerializer from .models import Post, Category class PostViewSet(viewsets.ModelViewSet): queryset = Post.objects.select_related('author', 'category') serializer_class = PostSerializer filter_backends = [filters.SearchFilter, filters.OrderingFilter] search_fields = ['title', 'content'] ordering_fields = ['created_at', 'updated_at'] def perform_create(self, serializer): serializer.save(author=self.request.user) def get_queryset(self): queryset = super().get_queryset() if self.action == 'list': return queryset.filter(status='published') return queryset
- カスタム権限クラスの実装例：
# permissions.py from rest_framework import permissions class IsAuthorOrReadOnly(permissions.BasePermission): def has_object_permission(self, request, view, obj): if request.method in permissions.SAFE_METHODS: return True return obj.author == request.user
- URLルーティングの設定：
# urls.py from rest_framework.routers import DefaultRouter from django.urls import path, include from . import views router = DefaultRouter() router.register(r'posts', views.PostViewSet) router.register(r'categories', views.CategoryViewSet) urlpatterns = [ path('api/', include(router.urls)), path('api-auth/', include('rest_framework.urls')), ]
APIドキュメントの自動生成には、drf-spectacular を使用します：
# settings.py INSTALLED_APPS = [ # ... 'drf_spectacular', ] REST_FRAMEWORK = { # ... 'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema', } SPECTACULAR_SETTINGS = { 'TITLE': 'Blog API', 'DESCRIPTION': 'ブログアプリケーションのAPI仕様書', 'VERSION': '1.0.0', }
以下は、一般的なAPIエンドポイントとその説明をまとめた表です：
エンドポイント メソッド 説明 /api/posts/ GET 記事一覧の取得 /api/posts/ POST 新規記事の作成 /api/posts/{id}/ GET 特定の記事の取得 /api/posts/{id}/ PUT/PATCH 記事の更新 /api/posts/{id}/ DELETE 記事の削除
- APIレスポンスの例：
{ "count": 100, "next": "http://api.example.com/posts/?page=2", "previous": null, "results": [ { "id": 1, "title": "REST APIの基礎", "content": "REST APIとは...", "author": "john_doe", "category": { "id": 1, "name": "Technology", "description": "技術関連の記事" }, "status": "published", "created_at": "2024-02-09T10:00:00Z", "updated_at": "2024-02-09T10:30:00Z" } // ... 他の記事 ] }
このようにDjango REST Frameworkを活用することで、効率的にRESTful APIを実装できます。次章では、テストとデバッグについて詳しく解説していきます。
$1
[編集]プロフェッショナルな開発において、テストとデバッグは品質を保証する上で欠かせません。本章では、Djangoアプリケーションにおける効果的なテスト手法とデバッグの方法について解説します。
まず、ユニットテストの基本的な実装から見ていきましょう：
# tests/test_models.py from django.test import TestCase from django.contrib.auth import get_user_model from blog.models import Post, Category class PostModelTest(TestCase): @classmethod def setUpTestData(cls): cls.user = get_user_model().objects.create_user( username='testuser', email='test@example.com', password='testpass123' ) cls.category = Category.objects.create( name='TestCategory', description='Test Description' ) def test_post_creation(self): post = Post.objects.create( title='Test Post', content='Test Content', author=self.user, category=self.category, status='draft' ) self.assertEqual(post.title, 'Test Post') self.assertEqual(post.author, self.user) self.assertTrue(isinstance(post, Post))
- APIのテストケース実装例：
# tests/test_apis.py from rest_framework.test import APITestCase from rest_framework import status from django.urls import reverse class PostAPITest(APITestCase): def setUp(self): self.user = get_user_model().objects.create_user( username='apiuser', password='apipass123' ) self.client.force_authenticate(user=self.user) def test_create_post(self): url = reverse('api:post-list') data = { 'title': 'API Test Post', 'content': 'API Test Content', 'category_id': self.category.id, 'status': 'draft' } response = self.client.post(url, data, format='json') self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(Post.objects.count(), 1)
テストカバレッジを計測するには、coverage.pyを使用します：
# カバレッジの計測と実行 coverage run manage.py test # レポートの生成 coverage report coverage html # HTMLレポートの生成
デバッグには、Django Debug Toolbarを活用します：
# settings.py INSTALLED_APPS = [ # ... 'debug_toolbar', ] MIDDLEWARE = [ 'debug_toolbar.middleware.DebugToolbarMiddleware', # ... ] INTERNAL_IPS = [ '127.0.0.1', ]
パフォーマンス最適化のためのクエリ分析例：
from django.db import connection from django.test import TestCase class QueryOptimizationTest(TestCase): def test_query_count(self): with self.assertNumQueries(3): # 想定されるクエリ数を指定 response = self.client.get(reverse('blog:post_list')) self.assertEqual(response.status_code, 200)
- セキュリティテストの実装例：
from django.test import Client from django.urls import reverse class SecurityTest(TestCase): def setUp(self): self.client = Client() def test_xss_prevention(self): post = Post.objects.create( title='<script>alert("XSS")</script>', content='Test Content', author=self.user ) response = self.client.get(reverse('blog:post_detail', args=[post.id])) self.assertNotContains(response, '<script>alert("XSS")</script>') self.assertContains(response, '<script>')
以下の表は、一般的なテストケースのカテゴリと推奨される実装方針をまとめたものです：
テストカテゴリ 実装方針 重要度 モデルテスト データの整合性、バリデーションの検証 高 ビューテスト レスポンス、コンテキスト、リダイレクトの検証 高 フォームテスト バリデーション、クリーニングの検証 中 APIテスト エンドポイント、認証、パーミッションの検証 高 セキュリティテスト XSS、CSRF、SQLインジェクションの防御 最高
効果的なデバッグのためのロギング設定：
# settings.py LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'handlers': { 'file': { 'level': 'DEBUG', 'class': 'logging.FileHandler', 'filename': 'debug.log', }, 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'handlers': ['console'], 'level': 'DEBUG', 'propagate': False, }, 'blog': { 'handlers': ['file', 'console'], 'level': 'DEBUG', 'propagate': True, }, }, }
このように、体系的なテストとデバッグ戦略を実装することで、アプリケーションの品質を確保することができます。次章では、本番環境へのデプロイメントについて解説していきます。
$1
[編集]本番環境へのデプロイメントは、開発したアプリケーションを実際のユーザーに提供するための重要なステップです。本章では、安全で効率的なデプロイメントプロセスについて解説します。
まず、本番環境用の設定から見ていきましょう：
# settings/production.py from .base import * DEBUG = False ALLOWED_HOSTS = ['example.com', 'www.example.com'] # セキュアな設定 SECURE_SSL_REDIRECT = True SESSION_COOKIE_SECURE = True CSRF_COOKIE_SECURE = True SECURE_BROWSER_XSS_FILTER = True SECURE_CONTENT_TYPE_NOSNIFF = True SECURE_HSTS_SECONDS = 31536000 SECURE_HSTS_INCLUDE_SUBDOMAINS = True SECURE_HSTS_PRELOAD = True # 静的ファイルの設定 STATIC_ROOT = '/var/www/example.com/static/' MEDIA_ROOT = '/var/www/example.com/media/' # データベース設定 DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': os.environ.get('DB_NAME'), 'USER': os.environ.get('DB_USER'), 'PASSWORD': os.environ.get('DB_PASSWORD'), 'HOST': os.environ.get('DB_HOST'), 'PORT': '5432', } } # キャッシュ設定 CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.redis.RedisCache', 'LOCATION': os.environ.get('REDIS_URL'), } }
- Nginxの設定例：
# /etc/nginx/sites-available/example.com server { listen 80; server_name example.com www.example.com; return 301 https://$server_name$request_uri; } server { listen 443 ssl http2; server_name example.com www.example.com; ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem; location = /favicon.ico { access_log off; log_not_found off; } location /static/ { root /var/www/example.com; expires 30d; add_header Cache-Control "public, no-transform"; } location /media/ { root /var/www/example.com; expires 30d; add_header Cache-Control "public, no-transform"; } location / { include proxy_params; proxy_pass http://unix:/run/gunicorn.sock; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; } }
Gunicornの設定ファイル：
# gunicorn_config.py import multiprocessing bind = "unix:/run/gunicorn.sock" workers = multiprocessing.cpu_count() * 2 + 1 worker_class = "uvicorn.workers.UvicornWorker" max_requests = 1000 max_requests_jitter = 50 timeout = 30 keepalive = 5
- systemdサービス設定：
# /etc/systemd/system/gunicorn.service [Unit] Description=gunicorn daemon Requires=gunicorn.socket After=network.target [Service] User=www-data Group=www-data WorkingDirectory=/var/www/example.com ExecStart=/var/www/example.com/venv/bin/gunicorn \ --config /var/www/example.com/gunicorn_config.py \ myproject.wsgi:application Restart=always [Install] WantedBy=multi-user.target
データベース移行のスクリプト例：
#!/bin/bash # deploy_db.sh set -e echo "Backing up current database..." pg_dump $DB_NAME > backup_$(date +%Y%m%d_%H%M%S).sql echo "Applying migrations..." python manage.py migrate --noinput echo "Collecting static files..." python manage.py collectstatic --noinput echo "Restarting Gunicorn..." systemctl restart gunicorn
以下の表は、デプロイメントのチェックリストをまとめたものです：
カテゴリ チェック項目 重要度 セキュリティ DEBUG = False の確認 最高 セキュリティ SECRET_KEY の変更 最高 セキュリティ SSL/TLS の設定 高 パフォーマンス 静的ファイルの最適化 中 パフォーマンス データベースインデックス 高 監視 ログ設定の確認 高 バックアップ 自動バックアップの設定 高
継続的デプロイメントの実装例（GitHub Actions）：
# .github/workflows/deploy.yml name: Deploy to Production on: push: branches: [ main ] jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: '3.11' - name: Install dependencies run: python -m pip install --upgrade pip pip install -r requirements.txt - name: Run tests run: python manage.py test - name: Deploy to server uses: appleboy/ssh-action@master with: host: ${{ secrets.SERVER_HOST }} username: ${{ secrets.SERVER_USER }} key: ${{ secrets.SSH_PRIVATE_KEY }} script: cd /var/www/example.com git pull source venv/bin/activate pip install -r requirements.txt python manage.py migrate python manage.py collectstatic --noinput systemctl restart gunicorn
これらの設定とプロセスを適切に実装することで、安定した本番環境の運用が可能になります。定期的なモニタリングとメンテナンスを行い、システムの健全性を維持することが重要です。
以上で第3部の全ての章の解説が完了しました。これまでの内容で、実践的なDjangoアプリケーション開発の基礎から本番環境への展開まで、包括的に学ぶことができました。