この記事では、PythonのWebフレームワーク「Flask」とMySQLを使い、認証機能をMVC形式で整理して作る手順を解説します。認証情報は「ユーザー名・メールアドレス・パスワード」の3項目です。パスワードは平文で保存せず、ハッシュ化して安全に管理します。

この記事で作る機能

• ユーザー名、メールアドレス、パスワードによるアカウント作成
• フォーム入力値のバリデーション
• 確認メールによるメールアドレスの有効性確認
• ログイン、ログアウト
• ログインが必要なページの保護
• パスワード紛失時の再設定メール送信
• 期限付きトークンによるパスワード再設定
• MySQLへのユーザー情報保存

使用する構成

今回は次のライブラリを使います。

• Flask：Pythonの軽量Webフレームワーク
• Flask-SQLAlchemy：MySQLのデータをPythonのクラスとして扱う
• Flask-Migrate：テーブル構造の変更を管理する
• Flask-Login：ログイン状態を管理する
• Flask-WTF / WTForms：フォームとバリデーション、CSRF対策
• Flask-Mail：確認メールや再設定メールを送信する
• itsdangerous：有効期限付きの安全なトークンを作る
• PyMySQL：PythonからMySQLへ接続する
• python-dotenv：環境変数を読み込む

MVC形式の考え方

Flaskにはフォルダ構成を強制する決まりがありません。そのため、すべてを1つの app.py に書くこともできます。しかし、機能が増えると修正箇所が分かりにくくなります。今回は役割ごとに分離します。

• Model：MySQLのテーブルとデータ操作。今回は models/user.py
• View：利用者に表示するHTML。今回は templates/
• Controller：URLごとの処理、入力確認、画面遷移。今回は controllers/auth_controller.py

FlaskではControllerをBlueprintで分けると、認証機能を他の機能から切り離しやすくなります。

完成時のファイル構成

python-example/
├── run.py
├── requirements.txt
├── .env
├── .gitignore
├── migrations/
└── app/
    ├── __init__.py
    ├── config.py
    ├── extensions.py
    ├── models/
    │   ├── __init__.py
    │   └── user.py
    ├── forms/
    │   ├── __init__.py
    │   └── auth_form.py
    ├── controllers/
    │   ├── __init__.py
    │   └── auth_controller.py
    ├── services/
    │   ├── __init__.py
    │   ├── mail_service.py
    │   └── token_service.py
    └── templates/
        ├── base.html
        ├── index.html
        └── auth/
            ├── register.html
            ├── login.html
            ├── forgot_password.html
            └── reset_password.html

1. Pythonの仮想環境を作る

mkdir python-example
cd python-example
python3 -m venv venv
source venv/bin/activate

python3 -m venv venv は、プロジェクト専用のPython環境を作るコマンドです。ほかのPythonアプリとライブラリのバージョンが混ざるのを防ぎます。Windowsの場合は venv\Scripts\activate で有効化します。

2. 必要なライブラリをインストールする

pip install Flask Flask-SQLAlchemy Flask-Migrate Flask-Login Flask-WTF Flask-Mail email-validator PyMySQL python-dotenv
pip freeze > requirements.txt

email-validator は、メールアドレスの形式をWTFormsで確認するために必要です。インストール後の状態を requirements.txt に記録しておけば、別のサーバーでも pip install -r requirements.txt で同じ環境を作れます。

3. MySQLにデータベースと専用ユーザーを作る

MySQLへ管理権限のあるユーザーでログインします。

mysql -u root -p

続いて、データベースとアプリ専用ユーザーを作成します。

CREATE DATABASE python_example
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;

CREATE USER 'python_user'@'localhost'
  IDENTIFIED BY '十分に長く推測されにくいパスワード';

GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, INDEX, DROP
  ON python_example.* TO 'python_user'@'localhost';

FLUSH PRIVILEGES;
EXIT;

utf8mb4 を指定すると、日本語だけでなく絵文字も保存できます。本番環境ではrootユーザーをアプリから使わず、対象データベースだけを操作できる専用ユーザーを使います。

4. 環境変数を設定する

パスワードやメールサーバーの認証情報をソースコードへ直接書かないように、プロジェクト直下へ .env を作ります。

SECRET_KEY=ここに長いランダム文字列
DATABASE_URL=mysql+pymysql://python_user:DBパスワード@localhost/python_example?charset=utf8mb4

MAIL_SERVER=smtp.example.com
MAIL_PORT=587
MAIL_USE_TLS=true
MAIL_USERNAME=no-reply@example.com
MAIL_PASSWORD=メール用パスワード
MAIL_DEFAULT_SENDER=no-reply@example.com

SECRET_KEY はCSRF対策やトークン署名に使います。次のコマンドで生成できます。

python -c "import secrets; print(secrets.token_hex(32))"

.gitignore には必ず次を記載します。

venv/
.env
__pycache__/
*.pyc

5. 設定ファイルを作る

app/config.py を作成します。

import os
from dotenv import load_dotenv

load_dotenv()

class Config:
    SECRET_KEY = os.environ["SECRET_KEY"]
    SQLALCHEMY_DATABASE_URI = os.environ["DATABASE_URL"]
    SQLALCHEMY_TRACK_MODIFICATIONS = False

    MAIL_SERVER = os.environ["MAIL_SERVER"]
    MAIL_PORT = int(os.getenv("MAIL_PORT", "587"))
    MAIL_USE_TLS = os.getenv("MAIL_USE_TLS", "true").lower() == "true"
    MAIL_USERNAME = os.environ["MAIL_USERNAME"]
    MAIL_PASSWORD = os.environ["MAIL_PASSWORD"]
    MAIL_DEFAULT_SENDER = os.environ["MAIL_DEFAULT_SENDER"]

os.environ["名前"] は、設定がない場合にエラーとなります。重要な設定の不足に気づきやすいため、本番用の認証情報にはこの書き方が向いています。

6. 拡張機能をまとめる

app/extensions.py を作ります。

from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
from flask_mail import Mail

db = SQLAlchemy()
migrate = Migrate()
login_manager = LoginManager()
mail = Mail()

login_manager.login_view = "auth.login"
login_manager.login_message = "ログインしてください。"
login_manager.login_message_category = "warning"

ここでは拡張機能の本体だけを作り、アプリとの接続は後ほど create_app() の中で行います。この形式はApplication Factoryパターンと呼ばれ、テストや設定の切り替えがしやすくなります。

7. Userモデルを作る

app/models/user.py を作成します。

from datetime import datetime, timezone
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from app.extensions import db, login_manager

class User(UserMixin, db.Model):
    __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(50), unique=True, nullable=False, index=True)
    email = db.Column(db.String(255), unique=True, nullable=False, index=True)
    password_hash = db.Column(db.String(255), nullable=False)
    email_verified = db.Column(db.Boolean, nullable=False, default=False)
    created_at = db.Column(
        db.DateTime,
        nullable=False,
        default=lambda: datetime.now(timezone.utc)
    )

    def set_password(self, password):
        self.password_hash = generate_password_hash(password)

    def check_password(self, password):
        return check_password_hash(self.password_hash, password)

@login_manager.user_loader
def load_user(user_id):
    return db.session.get(User, int(user_id))

データベースにはパスワードそのものではなく password_hash を保存します。generate_password_hash() は同じパスワードでも毎回異なるハッシュ値を作ります。ログイン時は check_password() で照合します。

email_verified はメール確認が完了したかを示す項目です。登録直後は False、確認用URLを開いたあとに True へ変更します。

8. フォームとバリデーションを作る

app/forms/auth_form.py を作成します。

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import (
    DataRequired, Email, EqualTo, Length, Regexp, ValidationError
)
from app.models.user import User

class RegisterForm(FlaskForm):
    username = StringField(
        "ユーザー名",
        validators=[
            DataRequired(),
            Length(min=3, max=50),
            Regexp(
                r"^[A-Za-z0-9_]+$",
                message="半角英数字とアンダースコアのみ使用できます。"
            )
        ]
    )
    email = StringField(
        "メールアドレス",
        validators=[DataRequired(), Email(), Length(max=255)]
    )
    password = PasswordField(
        "パスワード",
        validators=[
            DataRequired(),
            Length(min=12, max=128),
            Regexp(r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$",
                   message="英大文字・英小文字・数字を含めてください。")
        ]
    )
    password_confirm = PasswordField(
        "パスワード（確認）",
        validators=[DataRequired(), EqualTo("password")]
    )
    submit = SubmitField("アカウントを作成")

    def validate_username(self, field):
        if User.query.filter_by(username=field.data.strip()).first():
            raise ValidationError("このユーザー名はすでに使われています。")

    def validate_email(self, field):
        email = field.data.strip().lower()
        if User.query.filter_by(email=email).first():
            raise ValidationError("このメールアドレスはすでに登録されています。")

class LoginForm(FlaskForm):
    login_id = StringField(
        "ユーザー名またはメールアドレス",
        validators=[DataRequired(), Length(max=255)]
    )
    password = PasswordField("パスワード", validators=[DataRequired()])
    submit = SubmitField("ログイン")

class ForgotPasswordForm(FlaskForm):
    email = StringField(
        "メールアドレス",
        validators=[DataRequired(), Email(), Length(max=255)]
    )
    submit = SubmitField("再設定メールを送信")

class ResetPasswordForm(FlaskForm):
    password = PasswordField(
        "新しいパスワード",
        validators=[
            DataRequired(),
            Length(min=12, max=128),
            Regexp(r"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).+$",
                   message="英大文字・英小文字・数字を含めてください。")
        ]
    )
    password_confirm = PasswordField(
        "新しいパスワード（確認）",
        validators=[DataRequired(), EqualTo("password")]
    )
    submit = SubmitField("パスワードを変更")

ブラウザ側の required だけでは不十分です。利用者はHTTPリクエストを直接送ることもできるため、必ずPython側でも確認します。主な確認内容は、必須入力、長さ、メール形式、使用可能文字、パスワード一致、重複登録です。

9. 有効期限付きトークンを作る

app/services/token_service.py を作ります。

from flask import current_app
from itsdangerous import URLSafeTimedSerializer, BadSignature, SignatureExpired

def _serializer():
    return URLSafeTimedSerializer(current_app.config["SECRET_KEY"])

def create_token(user_id, purpose):
    return _serializer().dumps({"user_id": user_id}, salt=purpose)

def verify_token(token, purpose, max_age=3600):
    try:
        data = _serializer().loads(token, salt=purpose, max_age=max_age)
        return data.get("user_id")
    except (SignatureExpired, BadSignature):
        return None

purpose には、メール確認なら email-confirm、パスワード再設定なら password-reset を指定します。用途ごとにsaltを分けることで、確認用トークンをパスワード再設定へ流用できないようにします。max_age=3600 は有効期限1時間です。

10. メール送信処理を作る

app/services/mail_service.py を作成します。

from flask import url_for
from flask_mail import Message
from app.extensions import mail
from app.services.token_service import create_token

def send_verification_email(user):
    token = create_token(user.id, "email-confirm")
    verify_url = url_for(
        "auth.verify_email", token=token, _external=True
    )
    message = Message(
        subject="メールアドレスの確認",
        recipients=[user.email],
        body=f"""アカウント作成ありがとうございます。
次のURLを1時間以内に開いてください。

{verify_url}

心当たりがない場合は、このメールを破棄してください。
"""
    )
    mail.send(message)

def send_password_reset_email(user):
    token = create_token(user.id, "password-reset")
    reset_url = url_for(
        "auth.reset_password", token=token, _external=True
    )
    message = Message(
        subject="パスワード再設定",
        recipients=[user.email],
        body=f"""次のURLを1時間以内に開き、新しいパスワードを設定してください。

{reset_url}

依頼していない場合は、このメールを破棄してください。
"""
    )
    mail.send(message)

_external=True を指定すると、メール本文で利用できる絶対URLが作られます。本番環境ではHTTPSで公開し、正しいドメインが生成されるようにWebサーバー側のHost設定も確認します。

11. Controllerを作る

app/controllers/auth_controller.py を作ります。

from flask import Blueprint, render_template, redirect, url_for, flash, request
from flask_login import login_user, logout_user, login_required, current_user
from sqlalchemy import or_
from app.extensions import db
from app.models.user import User
from app.forms.auth_form import (
    RegisterForm, LoginForm, ForgotPasswordForm, ResetPasswordForm
)
from app.services.mail_service import (
    send_verification_email, send_password_reset_email
)
from app.services.token_service import verify_token

auth_bp = Blueprint("auth", __name__, url_prefix="/auth")

@auth_bp.route("/register", methods=["GET", "POST"])
def register():
    if current_user.is_authenticated:
        return redirect(url_for("index"))

    form = RegisterForm()
    if form.validate_on_submit():
        user = User(
            username=form.username.data.strip(),
            email=form.email.data.strip().lower()
        )
        user.set_password(form.password.data)
        db.session.add(user)
        db.session.commit()

        send_verification_email(user)
        flash("確認メールを送信しました。メール内のURLを開いてください。", "success")
        return redirect(url_for("auth.login"))

    return render_template("auth/register.html", form=form)

@auth_bp.route("/verify-email/<token>")
def verify_email(token):
    user_id = verify_token(token, "email-confirm", max_age=3600)
    user = db.session.get(User, user_id) if user_id else None

    if not user:
        flash("確認URLが無効、または有効期限が切れています。", "danger")
        return redirect(url_for("auth.login"))

    if not user.email_verified:
        user.email_verified = True
        db.session.commit()

    flash("メールアドレスを確認しました。ログインできます。", "success")
    return redirect(url_for("auth.login"))

@auth_bp.route("/login", methods=["GET", "POST"])
def login():
    if current_user.is_authenticated:
        return redirect(url_for("index"))

    form = LoginForm()
    if form.validate_on_submit():
        login_id = form.login_id.data.strip()
        user = User.query.filter(
            or_(User.username == login_id, User.email == login_id.lower())
        ).first()

        if not user or not user.check_password(form.password.data):
            flash("ユーザー名、メールアドレス、またはパスワードが違います。", "danger")
            return render_template("auth/login.html", form=form)

        if not user.email_verified:
            flash("メールアドレスの確認が完了していません。", "warning")
            return render_template("auth/login.html", form=form)

        login_user(user)
        next_url = request.args.get("next")
        if next_url and next_url.startswith("/"):
            return redirect(next_url)
        return redirect(url_for("index"))

    return render_template("auth/login.html", form=form)

@auth_bp.route("/logout", methods=["POST"])
@login_required
def logout():
    logout_user()
    flash("ログアウトしました。", "success")
    return redirect(url_for("auth.login"))

@auth_bp.route("/forgot-password", methods=["GET", "POST"])
def forgot_password():
    form = ForgotPasswordForm()
    if form.validate_on_submit():
        user = User.query.filter_by(
            email=form.email.data.strip().lower()
        ).first()

        if user:
            send_password_reset_email(user)

        flash("登録済みの場合は、再設定メールを送信しました。", "success")
        return redirect(url_for("auth.login"))

    return render_template("auth/forgot_password.html", form=form)

@auth_bp.route("/reset-password/<token>", methods=["GET", "POST"])
def reset_password(token):
    user_id = verify_token(token, "password-reset", max_age=3600)
    user = db.session.get(User, user_id) if user_id else None

    if not user:
        flash("再設定URLが無効、または有効期限が切れています。", "danger")
        return redirect(url_for("auth.forgot_password"))

    form = ResetPasswordForm()
    if form.validate_on_submit():
        user.set_password(form.password.data)
        db.session.commit()
        flash("パスワードを変更しました。", "success")
        return redirect(url_for("auth.login"))

    return render_template("auth/reset_password.html", form=form)

パスワード再設定では、メールアドレスが未登録の場合でも同じ案内を表示しています。「そのメールアドレスが登録されているか」を第三者に知られにくくするためです。また、ログアウトをGETではなくPOSTにしているのは、外部サイトのリンクを開いただけでログアウトさせられる動作を防ぐためです。

12. Flaskアプリを初期化する

app/__init__.py を作成します。

from flask import Flask, render_template
from flask_login import login_required
from app.config import Config
from app.extensions import db, migrate, login_manager, mail

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)

    db.init_app(app)
    migrate.init_app(app, db)
    login_manager.init_app(app)
    mail.init_app(app)

    from app.controllers.auth_controller import auth_bp
    app.register_blueprint(auth_bp)

    @app.route("/")
    def index():
        return render_template("index.html")

    @app.route("/mypage")
    @login_required
    def mypage():
        return "ログイン済みのユーザーだけが表示できます。"

    return app

run.py は次の内容です。

from app import create_app

app = create_app()

if __name__ == "__main__":
    app.run(debug=True)

13. HTMLテンプレートを作る

app/templates/base.html では、CSRFトークンを含むログアウトフォームとメッセージ表示を用意します。

<!doctype html>
<html lang="ja">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{% block title %}Python Example{% endblock %}</title>
</head>
<body>
  <nav>
    <a href="{{ url_for('index') }}">ホーム</a>
    {% if current_user.is_authenticated %}
      <form method="post" action="{{ url_for('auth.logout') }}">
        <input type="hidden" name="csrf_token" value="{{ csrf_token() }}">
        <button type="submit">ログアウト</button>
      </form>
    {% else %}
      <a href="{{ url_for('auth.login') }}">ログイン</a>
      <a href="{{ url_for('auth.register') }}">アカウント作成</a>
    {% endif %}
  </nav>

  {% with messages = get_flashed_messages(with_categories=true) %}
    {% for category, message in messages %}
      <p class="{{ category }}">{{ message }}</p>
    {% endfor %}
  {% endwith %}

  {% block content %}{% endblock %}
</body>
</html>

フォームは共通して、ラベル、入力欄、バリデーションエラーを表示します。例として app/templates/auth/register.html を示します。

{% extends "base.html" %}
{% block title %}アカウント作成{% endblock %}
{% block content %}
<h1>アカウント作成</h1>
<form method="post" novalidate>
  {{ form.hidden_tag() }}

  {{ form.username.label }}
  {{ form.username(autocomplete="username") }}
  {% for error in form.username.errors %}
    <p class="error">{{ error }}</p>
  {% endfor %}

  {{ form.email.label }}
  {{ form.email(autocomplete="email") }}
  {% for error in form.email.errors %}
    <p class="error">{{ error }}</p>
  {% endfor %}

  {{ form.password.label }}
  {{ form.password(autocomplete="new-password") }}
  {% for error in form.password.errors %}
    <p class="error">{{ error }}</p>
  {% endfor %}

  {{ form.password_confirm.label }}
  {{ form.password_confirm(autocomplete="new-password") }}
  {% for error in form.password_confirm.errors %}
    <p class="error">{{ error }}</p>
  {% endfor %}

  {{ form.submit() }}
</form>
{% endblock %}

form.hidden_tag() にはCSRFトークンが含まれます。第三者サイトから勝手にフォームを送信される攻撃を防ぐため、省略しないようにします。ログイン画面にはユーザー名またはメールアドレス、パスワード、ログインボタンと、パスワード再設定画面へのリンクを置きます。

14. MySQLへテーブルを作成する

モデルを読み込める状態にしてからマイグレーションを実行します。

export FLASK_APP=run.py
flask db init
flask db migrate -m "create users table"
flask db upgrade

flask db init は初回だけ実行します。flask db migrate はモデルとの差分から変更ファイルを作り、flask db upgrade が実際にMySQLへ反映します。本番環境では、生成された変更内容を確認してから適用してください。

テーブルを確認する場合は次のようにします。

mysql -u python_user -p python_example
SHOW TABLES;
DESCRIBE users;

15. 動作を確認する

flask --app run.py run --debug

ブラウザで http://127.0.0.1:5000/auth/register を開き、次の順番で確認します。

1. 未入力や不正なメール形式でエラーが表示される
2. 短いパスワードや条件を満たさないパスワードが拒否される
3. 正常に登録するとMySQLへユーザーが追加される
4. 確認メールが届き、URLを開くと email_verified が有効になる
5. 確認前はログインできず、確認後はログインできる
6. 同じユーザー名やメールアドレスを重複登録できない
7. パスワード再設定メールが届き、新しいパスワードに変更できる
8. 期限切れ、改ざん済みトークンが拒否される
9. 未ログインで /mypage を開くとログイン画面へ移動する

本番公開前に追加したい対策

ここまでで基本的な認証は動きますが、インターネットへ公開する場合は次の対策も重要です。

• 必ずHTTPSを使用する
• ログインや再設定メール送信へ回数制限を入れる
• 連続失敗を記録し、総当たり攻撃を検知する
• セッションCookieへ Secure、HttpOnly、適切な SameSite を設定する
• 確認メールの再送機能を用意し、再送にも回数制限を入れる
• メール送信はCeleryなどのバックグラウンド処理へ分離する
• パスワード変更後に既存セッションを無効化する仕組みを検討する
• ユーザー入力や認証結果をログへ残す際、パスワードやトークンを書かない
• MySQLとアプリのバックアップ、復元手順を用意する

Cookie設定の一例は次のとおりです。

SESSION_COOKIE_SECURE = True
SESSION_COOKIE_HTTPONLY = True
SESSION_COOKIE_SAMESITE = "Lax"
REMEMBER_COOKIE_SECURE = True
REMEMBER_COOKIE_HTTPONLY = True

よくあるエラー

Access denied for user

MySQLのユーザー名、パスワード、接続元ホスト、GRANTの対象を確認します。'python_user'@'localhost' と 'python_user'@'127.0.0.1' はMySQLでは別の接続元として扱われる場合があります。

No module named PyMySQL

仮想環境が有効か確認し、pip install PyMySQL を実行します。Gunicornやsystemdから起動する場合は、仮想環境内の実行ファイルを指定します。

確認メールのURLがlocalhostになる

本番ドメインやリバースプロキシの設定が正しくFlaskへ渡っていない可能性があります。ApacheやNginxのHostヘッダー、HTTPS判定、必要に応じてProxyFixの設定を確認します。

CSRF token is missing

テンプレート内のフォームに {{ form.hidden_tag() }} があるか確認します。通常のHTMLフォームを使う場合も、CSRFトークンのhidden項目が必要です。

まとめ

PythonとFlaskでログイン認証を作る場合は、ログイン処理だけでなく、登録時の入力確認、メールアドレス確認、パスワードのハッシュ化、再設定用トークンの期限管理までを一つの流れとして考えることが大切です。

MVC形式でModel、View、Controllerを分け、メール処理とトークン処理をServiceへ分離しておけば、機能追加やテストもしやすくなります。まずはローカル環境で登録から再設定まで一通り確認し、その後にHTTPS、回数制限、ログ管理など本番向けの安全対策を追加すると進めやすいでしょう。

この記事では、Rocky Linux上にPythonの実行環境を用意し、Flaskで作ったWebアプリをApache経由で公開するまでを、初めて学ぶ人向けに説明します。例として使うホスト名と設置先は次のとおりです。

ホスト名：python.example.com
設置先：/var/www/html/python.example.com

実際に試す場合は、python.example.comを自分のドメインへ読み替えてください。

PythonとPHPではWebアプリの動かし方が少し違う

PHPはApacheがPHPファイルを直接読み込み、処理結果を返す構成がよく使われます。一方、PythonのWebアプリでは、ApacheがPythonファイルを直接実行するのではなく、Gunicornというアプリケーションサーバーへアクセスを転送する構成が一般的です。

ブラウザ
  ↓
Apache
  ↓
Gunicorn
  ↓
Flaskで作ったPythonアプリ

それぞれの役割を簡単に整理すると、FlaskはWebアプリを作るためのフレームワーク、Gunicornは作成したアプリを常時動かすサーバー、ApacheはインターネットからのHTTP・HTTPSアクセスを受け付ける入口です。

Flaskを選ぶ理由

PythonにはDjango、Flask、FastAPIなどのWebフレームワークがあります。初めて小さなWebアプリを作る場合は、構成が単純で必要な機能を少しずつ追加できるFlaskが分かりやすいでしょう。

• Flask：小規模なWebサイト、学習、簡単な業務アプリ向け
• Django：ログインや管理画面を含む大きめのサービス向け
• FastAPI：スマートフォンアプリや外部サービス向けのAPI開発に向く

今回はFlaskを使います。

1．Rocky Linuxを更新する

sudo dnf update -y

sudoは管理者権限でコマンドを実行する指定です。dnfはRocky Linuxでソフトウェアを管理する仕組み、updateはインストール済みパッケージを更新する操作です。-yを付けると、途中の確認へ自動的にyesと回答します。

本番サーバーでは更新による影響がないか確認してから実行してください。

2．Pythonとpipをインストールする

sudo dnf install -y python3 python3-pip

installはパッケージのインストール、python3はPython本体、python3-pipはPython用パッケージ管理ツールです。pipを使うことでFlaskやGunicornを追加できます。

インストール後にバージョンを確認します。

python3 --version
pip3 --version

--versionはインストールされているバージョンを表示する指定です。バージョン番号が表示されれば、Pythonを実行できる状態です。

3．Webアプリ用ディレクトリを作る

sudo mkdir -p /var/www/html/python.example.com
sudo chown -R rocky:rocky /var/www/html/python.example.com
cd /var/www/html/python.example.com

mkdirはディレクトリを作るコマンドです。-pを付けると、途中のディレクトリが存在しない場合もまとめて作成します。

chownは所有者を変更するコマンドです。-Rは内部のファイルやディレクトリにも再帰的に設定する指定です。ここではRocky Linuxへログインしているユーザー名をrockyとしています。別のユーザーを使っている場合は読み替えてください。

cdは作業するディレクトリを移動するコマンドです。

4．Pythonの仮想環境を作る

python3 -m venv venv

python3でPython 3を起動し、-m venvで仮想環境を作る標準機能を呼び出しています。最後のvenvは作成するディレクトリ名です。

仮想環境とは、Webアプリ専用のPython環境です。OS全体へFlaskなどを直接インストールせず、アプリごとに使用するパッケージとバージョンを分けられます。

続いて仮想環境を有効にします。

source venv/bin/activate

sourceは指定した設定ファイルを現在のシェルへ読み込むコマンドです。実行後、プロンプトの先頭に(venv)と表示されれば有効になっています。

仮想環境を終了するときは次を実行します。

deactivate

SSHで再ログインした後は仮想環境が解除されていますが、作り直す必要はありません。アプリのディレクトリへ移動し、再びsource venv/bin/activateを実行します。

5．pipを更新してFlaskとGunicornを入れる

python -m pip install --upgrade pip
pip install flask gunicorn

python -m pipは、現在有効になっているPython環境のpipを実行する書き方です。installはインストール、--upgradeは既に入っているパッケージを新しいバージョンへ更新する指定です。

2行目ではFlaskとGunicornを仮想環境内へインストールしています。

• flask：URLとPythonの処理を結び付け、Web画面を作るフレームワーク
• gunicorn：Flaskアプリを本番サーバーで動かすためのWSGIサーバー

6．最小のFlaskアプリを作る

/var/www/html/python.example.com/app.pyを次の内容で作成します。

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Python Webアプリが動いています"

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=8000)

from flask import FlaskはFlask本体を読み込みます。app = Flask(__name__)はWebアプリを作成する処理です。

@app.route("/")は、トップページのURLへアクセスされたときに、その直後の関数を実行する指定です。returnでブラウザへ返す内容を指定しています。

最後のapp.run()は、app.pyを直接実行した場合に127.0.0.1の8000番ポートで開発用サーバーを起動する処理です。127.0.0.1は同じサーバー内部からだけ接続できるアドレスです。

7．開発用サーバーで確認する

cd /var/www/html/python.example.com
source venv/bin/activate
python app.py

別のSSH接続から次を実行します。

curl http://127.0.0.1:8000/

curlはコマンド上からHTTPアクセスを行うツールです。「Python Webアプリが動いています」と返れば、Flaskアプリは正常に動いています。

開発用サーバーは確認には便利ですが、本番公開を目的としたものではありません。本番ではGunicornを使います。

8．Gunicornで起動する

gunicorn --bind 127.0.0.1:8000 app:app

gunicornはアプリケーションサーバーを起動するコマンドです。--bind 127.0.0.1:8000は、同じサーバー内部の8000番ポートで待ち受ける指定です。

最後のapp:appは、コロンの左側がファイル名app.py、右側がファイル内で作成したapp変数を示します。

すでに8000番ポートが使用されている場合は「Address already in use」と表示されます。使用中のプロセスは次のコマンドで確認できます。

sudo ss -lntp | grep :8000

ssは通信ポートの使用状況を調べるコマンド、-lntpは待ち受け中のTCPポートとプロセスを数値表示する指定です。grep :8000で8000番を含む行だけに絞っています。

9．Apacheでpython.example.comだけを転送する

Rocky LinuxではApacheのサービス名とパッケージ名はhttpdです。

sudo dnf install -y httpd
sudo systemctl enable --now httpd

systemctlはサービスを管理するコマンドです。enableはOS起動時の自動起動を有効にし、--nowは自動起動の設定と同時に、その場でサービスも起動します。

/etc/httpd/conf.d/python.example.com.confを作り、次の設定を記載します。

<VirtualHost *:80>
    ServerName python.example.com

    ErrorLog /var/log/httpd/python.example.com-error.log
    CustomLog /var/log/httpd/python.example.com-access.log combined

    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8000/
    ProxyPassReverse / http://127.0.0.1:8000/
</VirtualHost>

VirtualHost *:80はHTTPの80番ポート用設定、ServerNameは対象のホスト名です。ProxyPassをこのVirtualHostの中へ記載することで、python.example.comへのアクセスだけがGunicornへ転送されます。他のホストには影響しません。

ProxyPreserveHost Onは、ブラウザから送られたホスト名を転送先へ引き継ぎます。ProxyPassはApacheからGunicornへ転送する設定、ProxyPassReverseはGunicornから返された応答ヘッダーを外部公開用に調整する設定です。

この構成ではApacheがファイルを直接表示しないため、基本的にDocumentRootは必要ありません。ページの内容はFlaskが返します。

10．Apacheの設定を確認して反映する

sudo apachectl configtest
sudo systemctl reload httpd

apachectl configtestはApache設定の文法確認です。「Syntax OK」と表示されたことを確認してから反映します。

reloadはサービスを停止せずに設定を読み直す操作です。設定に誤りがある状態でいきなり再起動するより、安全に確認できます。

Rocky LinuxでSELinuxが有効な場合は、ApacheからGunicornへのネットワーク接続を許可します。

sudo setsebool -P httpd_can_network_connect 1

setseboolはSELinuxの許可項目を変更するコマンドです。-Pを付けると再起動後も設定が維持されます。実際に転送するホストはApacheのVirtualHost設定で指定したpython.example.comだけです。

11．本番ではGunicornをsystemdへ登録する

次のようなコマンドでGunicornをバックグラウンド起動することもできます。

gunicorn --bind 127.0.0.1:8000 --daemon app:app

ただし、手動起動ではサーバー再起動後に自動で立ち上がらず、異常終了時の復旧やログ確認も面倒です。本番ではsystemdへサービスとして登録します。

サービス名は任意ですが、何の処理か分かりやすいgunicorn-python-example.serviceとします。

sudo vi /etc/systemd/system/gunicorn-python-example.service

ファイルへ次を記載します。

[Unit]
Description=Gunicorn for python.example.com
After=network.target

[Service]
User=rocky
Group=rocky
WorkingDirectory=/var/www/html/python.example.com

ExecStart=/var/www/html/python.example.com/venv/bin/gunicorn     --workers 2     --bind 127.0.0.1:8000     app:app

Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

systemd設定の意味

• Description：サービスの説明
• After=network.target：ネットワークの準備後に起動
• UserとGroup：Gunicornを実行するLinuxユーザーとグループ
• WorkingDirectory：アプリの作業ディレクトリ
• ExecStart：実際に起動するGunicornのコマンド
• --workers 2：リクエストを処理するワーカープロセスを2つ起動
• Restart=always：Gunicornが停止した場合に再起動
• RestartSec=5：再起動まで5秒待機
• WantedBy=multi-user.target：通常のサーバー起動時に利用するサービスとして登録

仮想環境をsourceで有効にしなくても、ExecStartで仮想環境内のGunicornをフルパス指定しているため、正しい環境が使用されます。

12．サービスを登録して起動する

sudo systemctl daemon-reload
sudo systemctl enable --now gunicorn-python-example

daemon-reloadは新しく作成・変更したsystemd設定を読み直す操作です。設定ファイルを編集しただけではsystemdへ反映されないため、必ず実行します。

enable --nowにより、自動起動の有効化と現在の起動を同時に行います。状態は次で確認できます。

sudo systemctl status gunicorn-python-example

active (running)と表示されれば起動しています。

13．プログラム更新後の反映とログ確認

app.pyなどを変更した後は、Gunicornを再起動します。

sudo systemctl restart gunicorn-python-example

Pythonプログラムだけを変更した場合、Apacheを再起動する必要はありません。ApacheのVirtualHost設定を変更した場合だけ、構文確認後にApacheをreloadします。

Gunicornのログを直近100件確認する場合は次を実行します。

sudo journalctl -u gunicorn-python-example -n 100

リアルタイムで確認する場合は次のとおりです。

sudo journalctl -u gunicorn-python-example -f

journalctlはsystemdが管理するログを表示するコマンドです。-uは対象サービス、-n 100は直近100件、-fは新しいログを継続表示する指定です。

よくあるトラブル

502 Proxy Errorが表示される

ApacheからGunicornへ接続できていない可能性があります。Gunicornの状態、8000番ポート、SELinuxを順番に確認します。

sudo systemctl status gunicorn-python-example
sudo ss -lntp | grep :8000
sudo journalctl -u gunicorn-python-example -n 100

Address already in useと表示される

手動で起動したGunicornが残っている、または別のアプリが8000番ポートを使っています。使用中のプロセスを確認し、同じアプリを二重に起動しないようにします。

Apacheの既存サイトまで転送される

ProxyPassがVirtualHostの外側に書かれていないか確認します。python.example.comのVirtualHost内だけに記載すれば、このホストだけが転送対象になります。

まとめ

Pythonのコード自体は比較的読みやすい一方、Webアプリを本番公開するにはFlask、Gunicorn、Apache、systemdの役割を理解する必要があります。最初は登場人物が多く見えますが、それぞれの役割は明確です。

• Flask：Webアプリの処理を作る
• Gunicorn：Flaskアプリを本番環境で動かす
• Apache：外部からのアクセスを受け付けてGunicornへ転送する
• systemd：Gunicornの起動、停止、自動起動、再起動、ログを管理する

まずはトップページに文字を表示する最小アプリを動かし、仕組みを確認してからHTMLテンプレート、MySQL、投稿フォーム、ログイン機能などを追加していくと理解しやすくなります。