翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。

# Python アプリケーションの Elastic Beanstalk でのデプロイ
<a name="create-deploy-python-apps"></a>

この章では、Python ウェブアプリケーションを設定してデプロイする手順について説明します AWS Elastic Beanstalk。Elastic Beanstalk を使用すると、Amazon Web Services を使用して簡単に Python ウェブアプリケーションのデプロイ、管理、スケーリングができます。

Elastic Beanstalk コマンドラインインターフェイス (EB CLI) または Elastic Beanstalk コンソールを使用すると、わずか数分でアプリケーションをデプロイできます。Elastic Beanstalk アプリケーションをデプロイした後も、EB CLI を使用してアプリケーションと環境を管理することも、Elastic Beanstalk コンソール AWS CLI、または APIs を使用することもできます。

EB CLI を使用して Python *Hello World* ウェブアプリケーションを作成してデプロイするには、「[Python の QuickStart](python-quickstart.md)」のステップバイステップの手順に従います。

**Topics**
+ [QuickStart: Elastic Beanstalk に Python アプリケーションをデプロイする](python-quickstart.md)
+ [Elastic Beanstalk 用の Python 開発環境の設定](python-development-environment.md)
+ [Elastic Beanstalk Python プラットフォームを使用する](create-deploy-python-container.md)
+ [Elastic Beanstalk への Flask アプリケーションのデプロイ](create-deploy-python-flask.md)
+ [Elastic Beanstalk への Django アプリケーションのデプロイ](create-deploy-python-django.md)
+ [Amazon RDS DB インスタンスを Python Elastic Beanstalk 環境に追加する](create-deploy-python-rds.md)
+ [Python のツールとリソース](create-deploy-python-tools-resources.md)

# QuickStart: Elastic Beanstalk に Python アプリケーションをデプロイする
<a name="python-quickstart"></a>

この QuickStart チュートリアルでは、Python アプリケーションを作成し、 AWS Elastic Beanstalk 環境にデプロイするプロセスについて説明します。

**本番稼働用ではない**  
例はデモンストレーションのみを目的としています。サンプルアプリケーションを本番環境で使用しないでください。

**Topics**
+ [AWS アカウント](#python-quickstart-aws-account)
+ [前提条件](#python-quickstart-prereq)
+ [ステップ 1: Python アプリケーションを作成する](#python-quickstart-create-app)
+ [ステップ 2: アプリケーションをローカルに実行する](#python-quickstart-run-local)
+ [ステップ 3: EB CLI を使用して Python アプリケーションをデプロイする](#python-quickstart-deploy)
+ [ステップ 4: Elastic Beanstalk でアプリケーションを実行する](#python-quickstart-run-eb-ap)
+ [ステップ 5：クリーンアップ](#go-tutorial-cleanup)
+ [AWS アプリケーションの リソース](#python-quickstart-eb-resources)
+ [次の手順](#python-quickstart-next-steps)
+ [Elastic Beanstalk コンソールでデプロイする](#python-quickstart-console)

## AWS アカウント
<a name="python-quickstart-aws-account"></a>

まだ AWS のお客様でない場合は、 AWS アカウントを作成する必要があります。サインアップすると、Elastic Beanstalk やその他の必要な AWS サービスにアクセスできます。

 AWS アカウントをすでにお持ちの場合は、「」に進むことができます[前提条件](#python-quickstart-prereq)。

### AWS アカウントを作成する
<a name="python-quickstart-aws-account-procedure"></a>

#### にサインアップする AWS アカウント
<a name="sign-up-for-aws"></a>

がない場合は AWS アカウント、次の手順を実行して作成します。

**にサインアップするには AWS アカウント**

1. [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup) を開きます。

1. オンラインの手順に従います。

   サインアップ手順の一環として、電話またはテキストメッセージを受け取り、電話キーパッドで検証コードを入力します。

   にサインアップすると AWS アカウント、 *AWS アカウントのルートユーザー* が作成されます。ルートユーザーには、アカウントのすべての AWS のサービス とリソースへのアクセス権があります。セキュリティベストプラクティスとして、ユーザーに管理アクセス権を割り当て、[ルートユーザーアクセスが必要なタスク](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks)の実行にはルートユーザーのみを使用するようにしてください。

AWS サインアッププロセスが完了すると、 から確認メールが送信されます。[https://aws.amazon.com/](https://aws.amazon.com/) の **[マイアカウント]** をクリックして、いつでもアカウントの現在のアクティビティを表示し、アカウントを管理することができます。

#### 管理アクセスを持つユーザーを作成する
<a name="create-an-admin"></a>

にサインアップしたら AWS アカウント、日常的なタスクにルートユーザーを使用しないように AWS アカウントのルートユーザー、 を保護し AWS IAM アイデンティティセンター、 を有効にして管理ユーザーを作成します。

**を保護する AWS アカウントのルートユーザー**

1.  **ルートユーザー**を選択し、 AWS アカウント E メールアドレスを入力して、アカウント所有者[AWS マネジメントコンソール](https://console.aws.amazon.com/)として にサインインします。次のページでパスワードを入力します。

   ルートユーザーを使用してサインインする方法については、「*AWS サインイン ユーザーガイド*」の「[ルートユーザーとしてサインインする](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)」を参照してください。

1. ルートユーザーの多要素認証 (MFA) を有効にします。

   手順については、*IAM* [ユーザーガイドの AWS アカウント 「ルートユーザー (コンソール) の仮想 MFA デバイス](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)を有効にする」を参照してください。

**管理アクセスを持つユーザーを作成する**

1. IAM アイデンティティセンターを有効にします。

   手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[AWS IAM アイデンティティセンターの有効化](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)」を参照してください。

1. IAM アイデンティティセンターで、ユーザーに管理アクセスを付与します。

   を ID ソース IAM アイデンティティセンターディレクトリ として使用する方法のチュートリアルについては、*AWS IAM アイデンティティセンター 「 ユーザーガイド*」の[「デフォルトを使用してユーザーアクセスを設定する IAM アイデンティティセンターディレクトリ](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)」を参照してください。

**管理アクセス権を持つユーザーとしてサインインする**
+ IAM アイデンティティセンターのユーザーとしてサインインするには、IAM アイデンティティセンターのユーザーの作成時に E メールアドレスに送信されたサインイン URL を使用します。

  IAM Identity Center ユーザーを使用してサインインする方法については、*AWS サインイン 「 ユーザーガイド*[」の AWS 「 アクセスポータルにサインイン](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)する」を参照してください。

**追加のユーザーにアクセス権を割り当てる**

1. IAM アイデンティティセンターで、最小特権のアクセス許可を適用するというベストプラクティスに従ったアクセス許可セットを作成します。

   手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[アクセス許可セットを作成する](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)」を参照してください。

1. グループにユーザーを割り当て、そのグループにシングルサインオンアクセス権を割り当てます。

   手順については、「*AWS IAM アイデンティティセンター ユーザーガイド*」の「[グループを追加する](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)」を参照してください。

## 前提条件
<a name="python-quickstart-prereq"></a>

このガイドの手順に従うには、run commands のためのコマンドラインターミナルまたはシェルが必要になります。コマンドは、該当する場合、プロンプト記号 (\$1) と現在のディレクトリの名前が前に付けられて、リストに示されます。

```
~/eb-project$ this is a command
this is output
```

Linux および macOS では、任意のシェルとパッケージ管理者を使用できます。Windows では、[Linux 用の Windows サブシステムをインストール](https://docs.microsoft.com/en-us/windows/wsl/install-win10)して、Ubuntu および Bash の Windows に統合されたバージョンを入手できます。

### EB CLI
<a name="python-quickstart-prereq.ebcli"></a>

このチュートリアルでは、Elastic Beanstalk コマンドラインインターフェイス (EB CLI) を使用します。EB CLI をインストールおよび設定する手順の詳細については、「[セットアップスクリプトを使用して EB CLI をインストールする (推奨)](eb-cli3.md#eb-cli3-install)」および「[EB CLI の設定](eb-cli3-configuration.md)」を参照してください。

### Python および Flask フレームワーク
<a name="python-quickstart-prereq.runtime"></a>

次のコマンドを実行して、`pip` がインストールされ動作している Python バージョンがあることを確認します。

```
~$ python3 --version
Python 3.N.N
>~$ python3 -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

前のコマンドのいずれかが「*Python が見つからない*」と返す場合は、`python3` ではなく `python` を使用する次のコマンドを実行します。エイリアスとシンボリックリンクの設定は、オペレーティングシステムと個々のカスタマイズによって異なる可能性があるため、`python3` コマンドはマシンで機能しない場合があります。

```
~$ python --version
Python 3.N.N
>~$ python -m pip --version
pip X.Y.Z from ... (python 3.N.N)
```

ローカルマシンに Python がインストールされていない場合は、Python ウェブサイトの「[Python ダウンロード](https://www.python.org/downloads/)」ページからダウンロードできます。Elastic Beanstalk がサポートする Python 言語バージョンのリストについては、「*AWS Elastic Beanstalk プラットフォーム*」ガイドの「[サポートされている Python プラットフォーム](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)」を参照してください。Python ダウンロードウェブサイトには、「*Python デベロッパーガイド*」へのリンクがあり、インストールと設定の手順が記載されています。

**注記**  
Python `pip` パッケージは、デフォルトで Python 3.4 以降に含まれています。

サポートされているバージョンの Python があるが、`pip` ではないことが出力で示された場合は、*pip.pypa.io* ウェブサイトの「[インストール](https://pip.pypa.io/en/stable/installation/)」ページを参照してください。pip がない Python 環境に pip をインストールするためのガイダンスがここに記載されています。



次のコマンドを実行して、Flask がインストールされているかどうかを確認します。

```
~$ pip list | grep Flask
```

Flask がインストールされていない場合は、次のコマンドを実行してインストールできます。

```
~$ pip install Flask
```

## ステップ 1: Python アプリケーションを作成する
<a name="python-quickstart-create-app"></a>

プロジェクトディレクトリを作成します。

```
~$ mkdir eb-python
~$ cd eb-python
```

「Hello Elastic Beanstalk\$1」というサンプルを作成します。Elastic Beanstalk を使用してデプロイする Python アプリケーション。

作成したばかりのディレクトリに `application.py` という名前のテキストファイルを次の内容で作成します。

**Example `~/eb-python/application.py`**  

```
from flask import Flask
application = Flask(__name__)

@application.route('/')
def hello_elastic_beanstalk():
        return 'Hello Elastic Beanstalk!'
```

次の行がある `requirements.txt` という名前のテキストファイルを作成します。このファイルには、アプリケーションを実行するために必要な `pip` パッケージが含まれています。

**Example `~/eb-python/requirements.txt`**  

```
Flask
```

## ステップ 2: アプリケーションをローカルに実行する
<a name="python-quickstart-run-local"></a>

アプリケーションをローカルで実行するには、次のコマンドを実行します。

```
~/eb-python$ export FLASK_APP=application.py && flask run --port 5000
```

次のような出力が表示されます。

```
Serving Flask app 'application.py'
Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
Running on http://127.0.0.1:5000
Press CTRL+C to quit
127.0.0.1 - - [01/Jan/1970 00:00:00] "GET / HTTP/1.1" 200 -
```

ウェブブラウザで `http://localhost:5000` にアクセスします。ウェブブラウザに「Hello Elastic Beanstalk\$1」と表示されます。

## ステップ 3: EB CLI を使用して Python アプリケーションをデプロイする
<a name="python-quickstart-deploy"></a>

次のコマンドを実行して、このアプリケーションの Elastic Beanstalk 環境を作成します。

 

**環境を作成し、Python アプリケーションをデプロイするには**

1. **eb init** コマンドを使用して EB CLI リポジトリを初期化します。

   ```
   ~/eb-python$ eb init -p python-3.9 python-tutorial --region us-east-2
   ```

   このコマンドは、`python-tutorial` という名前のアプリケーションを作成し、ローカルリポジトリを設定して指定された Python プラットフォームバージョンで環境を作成します。

1. (オプション) **eb init** を再度実行してデフォルトのキーペアを設定し、アプリケーションを実行している EC2 インスタンスに SSH を使用して connect できるようにします。

   ```
   ~/eb-python$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   1 つのキーペアがすでにある場合はそれを選択するか、またはプロンプトに従ってキーペアを作成します。プロンプトが表示されないか設定を後で変更する必要がない場合は、**eb init -i** を実行します。

1. 環境を作成し、**eb create** を使用してそこにアプリケーションをデプロイします。Elastic Beanstalk は、アプリケーションの zip ファイルを自動的にビルドし、ポート 5000 で起動します。

   ```
   ~/eb-python$ eb create python-env
   ```

   Elastic Beanstalk が環境を作成するのに約 5 分かかります。

## ステップ 4: Elastic Beanstalk でアプリケーションを実行する
<a name="python-quickstart-run-eb-ap"></a>

環境を作成するプロセスが完了したら、**eb open** でウェブサイトを開きます。

```
~/eb-python$ eb open
```

お疲れ様でした。Elastic Beanstalk で Python アプリケーションをデプロイしました。これにより、アプリケーション用に作成されたドメイン名を使用してブラウザ Window が開きます。

## ステップ 5：クリーンアップ
<a name="go-tutorial-cleanup"></a>

アプリケーションでの作業が終了したら、環境を終了できます。Elastic Beanstalk は、環境に関連付けられているすべての AWS リソースを終了します。

EB CLI を使用して Elastic Beanstalk 環境を終了するには、次のコマンドを実行します。

```
~/eb-python$ eb terminate
```

## AWS アプリケーションの リソース
<a name="python-quickstart-eb-resources"></a>

1 つのインスタンスアプリケーションを作成しました。1 つの EC2 インスタンスを持つ簡単なサンプルアプリケーションとして動作するため、ロードバランシングや自動スケーリングは必要ありません。単一インスタンスアプリケーションの場合、Elastic Beanstalk は次の AWS リソースを作成します。
+ **EC2 インスタンス** – 選択したプラットフォームでウェブアプリケーションを実行するよう設定された Amazon EC2 仮想マシン。

  各プラットフォームは、それぞれ特定の言語バージョン、フレームワーク、ウェブコンテナ、またはそれらの組み合わせをサポートするための、さまざまなソフトウェア、設定ファイル、スクリプトを実行します。ほとんどのプラットフォームでは、ウェブアプリケーションの前にウェブトラフィックを処理するリバースプロキシとして Apache または nginx のいずれかを使用します。そのプロキシがリクエストをアプリケーションに転送し、静的アセットを提供して、アクセスログとエラーログを生成します。
+ **インスタンスセキュリティグループ** – ポート 80 上の受信トラフィックを許可するよう設定された Amazon EC2 セキュリティグループ。このリソースでは、ロードバランサーからの HTTP トラフィックが、ウェブ・アプリケーションを実行している EC2 インスタンスに達することができます。デフォルトでは、トラフィックは他のポート上で許可されません。
+ **Amazon S3 バケット** – Elastic Beanstalk の使用時に作成されるソースコード、ログ、その他のアーティファクトの保存場所。
+ **Amazon CloudWatch アラーム** – 環境内のインスタンスの負荷を監視する 2 つの CloudWatch アラーム。負荷が高すぎる、または低すぎる場合にトリガーされます。アラームがトリガーされると、Auto Scaling グループはレスポンスとしてスケールアップまたはダウンを行います。
+ **CloudFormation スタック** – Elastic Beanstalk は CloudFormation を使用して環境内のリソースを起動し、設定変更を伝達します。リソースは、[CloudFormation コンソール](https://console.aws.amazon.com/cloudformation)に表示できるテンプレートで定義されます。
+  **ドメイン名** – ウェブ・アプリケーションまでのルートとなるドメイン名であり、**subdomain*.*region*.elasticbeanstalk.com* の形式です。

Elastic Beanstalk は、これらのリソースをすべて管理します。環境を終了すると、Elastic Beanstalk は含まれているすべてのリソースを終了します。

## 次の手順
<a name="python-quickstart-next-steps"></a>

アプリケーションを実行する環境を手に入れた後、アプリケーションの新しいバージョンや、異なるアプリケーションをいつでもデプロイできるようになります。新しいアプリケーションバージョンのデプロイは、プロビジョニングや EC2 インスタンスの再開が必要ないため、非常に素早く行えます。Elastic Beanstalk コンソールを使用して新しい環境を調べることもできます。詳細な手順については、このガイドの「*開始方法*」の章の「[環境を探索する](GettingStarted.md#GettingStarted.Explore)」を参照してください。

**その他のチュートリアルを試す**  
異なるサンプルアプリケーションで他のチュートリアルを試したい場合は、以下のチュートリアルを参照してください。  
[Elastic Beanstalk への Flask アプリケーションのデプロイ](create-deploy-python-flask.md)
[Elastic Beanstalk への Django アプリケーションのデプロイ](create-deploy-python-django.md)

1 つか 2 つのサンプルアプリケーションをデプロイし、ローカルで Python アプリケーションを開発して実行する準備が整ったら、「[Elastic Beanstalk 用の Python 開発環境の設定](python-development-environment.md)」を参照します。

## Elastic Beanstalk コンソールでデプロイする
<a name="python-quickstart-console"></a>

Elastic Beanstalk コンソールを使用してサンプルアプリケーションを起動することもできます。詳細な手順については、このガイドの「*開始方法*」の章の「[サンプルアプリケーションを作成する](GettingStarted.md#GettingStarted.CreateApp)」を参照してください。

# Elastic Beanstalk 用の Python 開発環境の設定
<a name="python-development-environment"></a>

このトピックでは、Python 開発環境を設定し、アプリケーションを AWS Elastic Beanstalkにデプロイする前にローカルでテストする手順について説明します。また、便利なツールのインストール手順を提供するウェブサイトも参照します。

このガイドの手順に従うには、run commands のためのコマンドラインターミナルまたはシェルが必要になります。コマンドは、該当する場合、プロンプト記号 (\$1) と現在のディレクトリの名前が前に付けられて、リストに示されます。

```
~/eb-project$ this is a command
this is output
```

Linux および macOS では、任意のシェルとパッケージ管理者を使用できます。Windows では、[Linux 用の Windows サブシステムをインストール](https://docs.microsoft.com/en-us/windows/wsl/install-win10)して、Ubuntu および Bash の Windows に統合されたバージョンを入手できます。

**Topics**
+ [前提条件](#python-common-prereq)
+ [仮想環境の使用](#python-common-setup-venv)
+ [Elastic Beanstalk 用の Python プロジェクトの設定](#python-common-configuring)

## 前提条件
<a name="python-common-prereq"></a>

次のリストは、Elastic Beanstalk と Python アプリケーションを使用するための一般的な前提条件を示しています。
+ **Python 言語** – 選択した Elastic Beanstalk Python プラットフォームバージョンに含まれている Python 言語のバージョンをインストールします。サポートされている Python 言語バージョンのリストについては、「AWS Elastic Beanstalk プラットフォームガイド」の「[サポートされている Python プラットフォーム](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)」を参照してください。開発マシンに Python がまだ設定されていない場合は、Python ウェブサイトの「[Python ダウンロード](https://www.python.org/downloads/)」ページを参照してください。
+ **`pip` ユーティリティ** – `pip` ユーティリティは Python のパッケージインストーラです。アプリケーション環境の設定方法を Elastic Beanstalk が判断できるように、プロジェクトの依存関係をインストールし一覧表示します。`pip` の詳細については、pip.pypa.io ウェブサイトの [pip ページ](https://pip.pypa.io/en/stable/)を参照してください。
+ **(オプション) Elastic Beanstalk コマンドラインインターフェイス (EB CLI)** – [EB CLI](eb-cli3.md) は、必要なデプロイファイルを使用してアプリケーションをパッケージ化できます。また、Elastic Beanstalk 環境を作成して、そこにアプリケーションをデプロイすることもできます。Elastic Beanstalk コンソールからもデプロイできます。そのため、EB CLI が必ず必要というわけではありません。
+ **作業用 `SSH` のインストール** – SSH プロトコルを使用して実行中のインスタンスに接続し、デプロイを検査またはデバッグできます。
+ **`virtualenv` パッケージ** – この `virtualenv` ツールは、アプリケーションの開発およびテスト環境を作成します。Elastic Beanstalk は、アプリケーションで不要な追加のパッケージをインストールすることなく、この環境をレプリケートできます。詳細については、[virtualenv](https://virtualenv.pypa.io/en/latest/) のウェブサイトを参照してください。Python をインストールしたら、次のコマンドを使用して `virtualenv` パッケージをインストールできます。

  ```
  $ pip install virtualenv
  ```

## 仮想環境の使用
<a name="python-common-setup-venv"></a>

前提条件をインストールしたら、`virtualenv` を使用して仮想環境をセットアップし、アプリケーションの依存関係をインストールします。仮想環境を使用することで、アプリケーションで必要なパッケージを正確に識別し、アプリケーションを実行する EC2 インスタンスにそれらの必要なパッケージをインストールすることができます。

**仮想環境をセットアップするには**

1. コマンドライン・ウィンドウを開き、次のように入力します。

   ```
   $ virtualenv /tmp/eb_python_app
   ```

   *eb\$1python\$1app* を、アプリケーションに対応するわかりやすい名前に置き換えます (アプリケーション名を使用することをお勧めします)。`virtualenv` コマンドによって指定したディレクトリに仮想環境が作成され、アクションの結果が出力されます。

   ```
   Running virtualenv with interpreter /usr/bin/python
   New python executable in /tmp/eb_python_app/bin/python3.12
   Also creating executable in /tmp/eb_python_app/bin/python
   Installing setuptools, pip...done.
   ```

1. 仮想環境の準備が整ったら、環境の `activate` ディレクトリにある `bin` スクリプトを実行してスタートします。たとえば、前のステップで作成した **eb\$1python\$1app** 環境をスタートするには、次のように入力します。

   ```
   $ source /tmp/eb_python_app/bin/activate
   ```

   コマンドプロンプトの冒頭には毎回、仮想環境の名前（例: `(eb_python_app)`）が出力され、仮想 Python 環境を使用していることがわかるようになっています。

1. 仮想環境の使用を停止し、インストールされているすべてのライブラリを含むシステムのデフォルトの Python インタプリタに戻るには、`deactivate` コマンドを実行します。

   ```
   (eb_python_app) $ deactivate
   ```

**注記**  
仮想環境の作成後は、`activate` スクリプトを再び実行することで、いつでも再起動できます。

## Elastic Beanstalk 用の Python プロジェクトの設定
<a name="python-common-configuring"></a>

Elastic Beanstalk CLI を使用して、Elastic Beanstalk でのデプロイ用に Python アプリケーションを準備します。

**Elastic Beanstalk でのデプロイ用に Python アプリケーションを設定するには**

1. [仮想環境](#python-common-setup-venv)で、プロジェクトのディレクトリツリーの最上位 (`python_eb_app`) に戻り、次のように入力します。

   ```
   pip freeze >requirements.txt
   ```

   このコマンドは、仮想環境にインストールされているパッケージの名前とバージョンを `requirements.txt` にコピーします。たとえば、*PyYAML* パッケージ、バージョン *3.11* が仮想環境にインストールされている場合、このファイルには次の行が含まれます。

   ```
   PyYAML==3.11
   ```

   これにより、Elastic Beanstalk は、アプリケーションの開発とテストに使用されたのと同じパッケージとバージョンを使用して、アプリケーションの Python 環境をレプリケートすることができます。

1. **eb init** コマンドで EB CLI リポジトリを設定します。画面の指示に従ってリージョン、プラットフォーム、その他のオプションを選択します。

デフォルトでは、Elastic Beanstalk は、アプリケーションを開始するために `application.py` というファイルを探します。作成した Python プロジェクトにこのファイルが存在しない場合は、アプリケーション環境の調整が必要になります。また、アプリケーションのモジュールをロードできるように、環境変数を設定する必要があります。詳細については「[Elastic Beanstalk Python プラットフォームを使用する](create-deploy-python-container.md)」を参照してください。

# Elastic Beanstalk Python プラットフォームを使用する
<a name="create-deploy-python-container"></a>

このトピックでは、Elastic Beanstalk で Python アプリケーションを設定、ビルド、実行する方法について説明します。

AWS Elastic Beanstalk は、Python プログラミング言語のさまざまなバージョンで多数のプラットフォームブランチをサポートしています。完全なリストについては、「AWS Elastic Beanstalk プラットフォーム」ドキュメントの「[Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)」を参照してください。

Python ウェブアプリケーションは、WSGI を使用してプロキシサーバーの背後で実行できます。Elastic Beanstalk には、デフォルトの WSGI サーバーとして [Gunicorn](https://gunicorn.org/) が用意されています。

ソ出典バンドルに `Procfile` を追加して、アプリケーションの WSGI サーバーを指定および設定することができます。詳細については、「[Elastic Beanstalk での Procfile を使用した WSGI サーバーの設定](python-configuration-procfile.md)」を参照してください

Pipenv によって作成された `Pipfile` ファイルと `Pipfile.lock` ファイルを使用して、Python パッケージの依存関係やその他の要件を指定できます。依存関係の指定の詳細については、「[Elastic Beanstalk での要件ファイルを使用した依存関係の指定](python-configuration-requirements.md)」を参照してください。

Elastic Beanstalk には、Elastic Beanstalk 環境内の EC2 インスタンスで実行されるソフトウェアのカスタマイズに使用できる[設定オプション](command-options.md)が用意されています。アプリケーションに必要な環境変数を設定し、Amazon S3 に対してログのローテーションを有効にしたら、アプリケーションの出典で静的ファイルが含まれるフォルダを、プロキシサーバーによって提供されるパスにマッピングできます。

設定オプションは[実行中の環境の設定を変更するために](environment-configuration-methods-after.md) Elastic Beanstalk コンソールで利用できます。環境を終了したときにその設定が失われないようにするため、[保存済み設定](environment-configuration-savedconfig.md)を使用して設定を保存し、それを後で他の環境に適用することができます。

ソースコードの設定を保存する場合、[設定ファイル](ebextensions.md)を含めることができます。設定ファイルの設定は、環境を作成するたびに、またはアプリケーションをデプロイするたびに適用されます。設定ファイルを使用して、デプロイの間にパッケージをインストールしたり、スクリプトを実行したり、他のインスタンスのカスタマイズオペレーションを実行することもできます。

Elastic Beanstalk コンソールで適用される設定は、設定ファイルに同じ設定があれば、それらの設定を上書きします。これにより、設定ファイルでデフォルト設定を定義し、コンソールでそのデフォルト設定を環境固有の設定で上書きできます。設定の優先順位の詳細と設定の他の変更方法については、「[設定オプション](command-options.md)」を参照してください。

`pip` から入手可能な Python パッケージの場合、アプリケーションの出典コードのルートに要件ファイルを含めることができます。Elastic Beanstalk は、デプロイ時に要件ファイルで指定された依存関係パッケージをすべてインストールします。詳細については、「[Elastic Beanstalk での要件ファイルを使用した依存関係の指定](python-configuration-requirements.md)」を参照してください

Elastic Beanstalk Linux ベースのプラットフォームを拡張するさまざまな方法の詳細については、「[Elastic Beanstalk Linux プラットフォームの拡張](platforms-linux-extend.md)」を参照してください。

## Python 環境の設定
<a name="create-deploy-python-container-console"></a>

Python プラットフォーム設定では、Amazon EC2 インスタンスの動作を微調整できます。Elastic Beanstalk コンソールを使用して、Elastic Beanstalk 環境の Amazon EC2 インスタンス設定を編集できます。

Elastic Beanstalk コンソールを使用して、Python プロセス設定の構成、Amazon S3 への AWS X-Rayログローテーションの有効化、およびアプリケーションが環境から読み取ることができる変数の設定を行います。

**Elastic Beanstalk コンソールで Python 環境を設定するには**

1. [Elastic Beanstalk コンソール](https://console.aws.amazon.com/elasticbeanstalk)を開き、**リージョン**リストで を選択します AWS リージョン。

1. ナビゲーションペインで、[**環境**] を選択し、リストから環境の名前を選択します。

1. ナビゲーションペインで、[**設定**] を選択します。

1. **[更新、モニタリング、ログ]** の設定カテゴリで、**[編集]** を選択します。

### Python 設定
<a name="python-console-settings"></a>
+ [**プロキシサーバー**] – 環境インスタンスで使用するプロキシサーバーです。デフォルトでは、nginx が使用されます。
+ [**WSGI パス**] – メインアプリケーション・ファイルの名前またはパス。たとえば、`application.py`、`django/wsgi.py` などです。
+ [**NumProcesses**] – 各アプリケーションインスタンスで実行するプロセスの数。
+ [**NumThreads**] – 各プロセスで実行するスレッドの数。

### AWS X-Ray 設定
<a name="python-console-xray"></a>
+ **X-Ray デーモン** – AWS X-Ray デーモンを実行して、 からのトレースデータを処理します[AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)。

### ログオプション
<a name="create-deploy-python-container.console.logoptions"></a>

[ログ Options] セクションには、2 つの設定があります。
+ [**Instance profile**] – アプリケーションに関連付けられた Amazon S3 バケットへのアクセス許可が付与されているインスタンスプロファイルを指定します。
+ **[Enable log file rotation to Amazon S3]** (Amazon S3 へのログファイルのローテーションの有効化) - アプリケーションの Amazon EC2 インスタンスのログファイルを、アプリケーションに関連付けられている Amazon S3 バケットにコピーするかどうかを指定します。

### 静的ファイル
<a name="python-platform-staticfiles"></a>

パフォーマンスを向上させるために、**[Static files]** (静的ファイル) セクションを使用して、ウェブアプリケーション内のディレクトリセットから静的ファイル (HTML、イメージなど) を配信するようにプロキシサーバーを設定することができます。ディレクトリごとに、仮想パスをディレクトリマッピングに設定します。プロキシサーバーは、指定されたパスのファイルに対するリクエストを受け取ると、アプリケーションにリクエストをルーティングする代わりにファイルを直接　　処理します。

設定ファイルまたは、Elastic Beanstalk コンソールを使用した静的ファイルの設定の詳細については、「[静的ファイルの提供](environment-cfg-staticfiles.md)」を参照してください。

デフォルトでは、Python 環境のプロキシサーバーは `static` パスにある `/static` という名前のフォルダにあるすべてのファイルを提供します。たとえば、アプリケーション出典の `logo.png` という名前のフォルダに `static` というファイルが含まれている場合、プロキシサーバーは `subdomain.elasticbeanstalk.com/static/logo.png` でそれをユーザーに提供します。このセクションで説明しているように、追加のマッピングを設定できます。

### 環境プロパティ
<a name="create-deploy-python-custom-container-envprop"></a>

環境プロパティを使用して、アプリケーションに情報を渡し、環境変数を設定できます。たとえば、`CONNECTION_STRING` という名前の環境プロパティを作成し、そのプロパティで、データベースへの connect にアプリケーションが使用する接続文字列を指定できます。

Elastic Beanstalk 内で実行している Python 環境の内部では、Python の `os.environ` ディクショナリを使用してこれらの値にアクセスできます。詳細については、[http://docs.python.org/library/os.html](http://docs.python.org/library/os.html) を参照してください。

以下のようなコードを使用して、キーとパラメータにアクセスできます。

```
import os
endpoint = os.environ['API_ENDPOINT']
```

環境プロパティを使用して、フレームワークに情報を渡すこともできます。たとえば、`DJANGO_SETTINGS_MODULE` という名前のプロパティを作成して、そのプロパティで、特定の設定モジュールを使用するように Django を設定できます。環境によって、値は、`development.settings` や `production.settings` などになります。

詳細については「[環境変数とその他のソフトウェアの設定](environments-cfg-softwaresettings.md)」を参照してください。

## Python 設定の名前空間
<a name="python-namespaces"></a>

[設定ファイル](ebextensions.md)を使用して、設定オプションを設定し、デプロイの間、他のインスタンス設定タスクをパフォーマンスできます。設定オプションは、[プラットフォーム固有](command-options-specific.md)のものでも、Elastic Beanstalk サービス全体の[すべてのプラットフォーム](command-options-general.md)に適用できるものでもかまいません。設定オプションは、名前空間として整理されています。

Python プラットフォームでは、名前空間 (`aws:elasticbeanstalk:environment:proxy`、`aws:elasticbeanstalk:environment:proxy:staticfiles`、`aws:elasticbeanstalk:container:python`) のオプションを定義します。

以下の設定ファイルの例では、`DJANGO_SETTINGS_MODULE` という名前の環境プロパティを作成する設定オプションを指定し、Apache プロキシサーバーを選択して、`statichtml` という名前のディレクトリを `/html` パスにマッピングし `staticimages` という名前のディレクトリを `/images` パスにマッピングする 2 つの静的ファイルオプションを指定して、`[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)` 名前空間に追加の設定を指定しています。この名前空間には、出典コードで WSGI スクリプトの場所を指定できるオプションと、WSGI で実行するスレッドとプロセスの数を指定できるオプションが含まれています。

```
option_settings:
  aws:elasticbeanstalk:application:environment:
    DJANGO_SETTINGS_MODULE: production.settings
  aws:elasticbeanstalk:environment:proxy:
    ProxyServer: apache
  aws:elasticbeanstalk:environment:proxy:staticfiles:
    /html: statichtml
    /images: staticimages
  aws:elasticbeanstalk:container:python:
    WSGIPath: ebdjango.wsgi:application
    NumProcesses: 3
    NumThreads: 20
```

**注意事項**  
Amazon Linux AMI Python プラットフォームバージョン (Amazon Linux 2 より前の) を使用している場合は、`WSGIPath` の値を `ebdjango/wsgi.py` に置き換えます。この例の値は、Amazon Linux AMI プラットフォームバージョンでは support されていない Gunicorn WSGI サーバーで動作します。
さらに、これらの古いプラットフォームバージョンでは、静的ファイル―`aws:elasticbeanstalk:container:python:staticfiles`の設定に異なる名前空間が使用されます 。これは、スタンダードの静的ファイル名前空間と同じオプション名とセマンティクスを持っています。

設定ファイルでは、[お客様の環境のインスタンスでソフトウェアをさらに変更する](customize-containers-ec2.md)ためのキーもいくつか support されています。この例では、[packages](customize-containers-ec2.md#linux-packages) キーを使用して、Memcached をインストールし、`yum` および [コンテナ コマンド](customize-containers-ec2.md#linux-container-commands)を使用して、デプロイ時に run command にサーバーを設定します。

```
packages:
  yum:
    libmemcached-devel: '0.31'

container_commands:
  collectstatic:
    command: "django-admin.py collectstatic --noinput"
  01syncdb:
    command: "django-admin.py syncdb --noinput"
    leader_only: true
  02migrate:
    command: "django-admin.py migrate"
    leader_only: true
  03wsgipass:
    command: 'echo "WSGIPassAuthorization On" >> ../wsgi.conf'
  99customize:
    command: "scripts/customize.sh"
```

Elastic Beanstalk には、環境をカスタマイズするための多数の設定オプションが用意されています。設定ファイルに加えて、コンソール、保存された設定、EB CLI、または を使用して、設定オプションを指定することもできます AWS CLI詳細については「[設定オプション](command-options.md)」を参照してください。

## `python3` 実行可能ファイル
<a name="python3-executable"></a>

Elastic Beanstalk Python 環境の EC2 インスタンスで利用可能な `python3` 実行可能ファイルのバージョンは、プラットフォームで使用される同じ Python バージョンに必ずしも対応するとは限りません。例えば、Python 3.12 AL2023 プラットフォームでは、`/usr/bin/python3` は Python 3.9 を指します。これは、Python 3.9 が AL2023 の*システム Python* であるからです。詳細については、「*Amazon Linux 2023 ユーザーガイド*」の「[Python in AL2023](https://docs.aws.amazon.com/linux/al2023/ug/python.html)」を参照してください。プラットフォームで使用される Python バージョンに対応する実行可能ファイルには、バージョン管理された場所 (例: `/usr/bin/python3.12`) またはアプリケーション仮想環境 `bin` ディレクトリ (例: `/var/app/venv/staging-LQM1lest/bin/python3`) からアクセスできます。プラットフォームは、プラットフォームブランチに対応する正しい Python 実行可能ファイルを使用します。

# Elastic Beanstalk での Procfile を使用した WSGI サーバーの設定
<a name="python-configuration-procfile"></a>

ソースバンドルに [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) を追加して、アプリケーションの WSGI サーバーを指定および設定することができます。`Procfile` でカスタムのスタートコマンドと実行コマンドを指定できます。

`Procfile` を使用すると、設定ファイルを使用して設定した `aws:elasticbeanstalk:container:python` 名前空間オプションが上書きされます。

次の例では、`Procfile` を使用して uWSGI をサーバーとして指定し、これを設定します。

**Example [Procfile]**  

```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```

次の例では、`Procfile` を使用して、デフォルトの WSGI サーバーである Gunicorn を設定します。

**Example [Procfile]**  

```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```

**注意事項**  
Gunicorn 以外の WSGI サーバーを設定する場合は、アプリケーションの依存関係として指定して、環境インスタンスにインストールされるようにしてください。依存関係の指定の詳細については、「[Elastic Beanstalk での要件ファイルを使用した依存関係の指定](python-configuration-requirements.md)」を参照してください。
WSGI サーバーのデフォルトポートは 8000 です。`Procfile` コマンドで別のポート番号を指定する場合は、`PORT` [環境プロパティ](environments-cfg-softwaresettings.md) もこのポート番号に設定します。

# Elastic Beanstalk での要件ファイルを使用した依存関係の指定
<a name="python-configuration-requirements"></a>

このトピックでは、アプリケーションを設定して、必要な他の Python パッケージをインストールする方法について説明します。通常の Python アプリケーションには、他のサードパーティー製 Python パッケージに対する依存関係があります。Elastic Beanstalk Python プラットフォームでは、アプリケーションが依存する Python パッケージを指定する方法が複数あります。

## `pip` および `requirements.txt` を使用します。
<a name="python-configuration-requirements.txt"></a>

Python パッケージをインストールするためのスタンダードツールは `pip` です。これには、すべての必要なパッケージ (およびバージョン) を 1 つの要件ファイルで指定する特徴があります。要件ファイルの詳細については、pip ドキュメントウェブサイトの「[要件ファイル形式](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format)」を参照してください。

`requirements.txt` という名前のファイルを作成し、出典バンドルの最上位ディレクトリに置きます。次は、Django の `requirements.txt` ファイルの例です。

```
Django==2.2
mysqlclient==2.0.3
```

開発環境で、`pip freeze` コマンドを使用して要件ファイルを生成できます。

```
~/my-app$ pip freeze > requirements.txt
```

要件ファイルに、実際にアプリケーションによって使用されるパッケージのみが含まれるようにするには、それらのパッケージのみがインストールされている[仮想環境](python-development-environment.md#python-common-setup-venv)を使用します。仮想環境の外では、`pip freeze` の出力に、オペレーティングシステムに付属のパッケージを含め、開発マシンにインストール済みのすべての `pip` パッケージが含まれます。

**注記**  
Amazon Linux AMI Python プラットフォームバージョンでは、Elastic Beanstalk は Pipenv または Pipfiles をネイティブにサポートしていません。Pipenv を使用してアプリケーションの依存関係を管理する場合は、次のコマンドを実行して `requirements.txt` ファイルを生成します。  

```
~/my-app$ pipenv lock -r > requirements.txt
```
詳細については、Pipenv ドキュメントの [Generating a requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) を参照してください。

## Pipenv と `Pipfile` を使用します
<a name="python-configuration-requirements.pipenv"></a>

Pipenv は、最新の Python パッケージングツールです。これは、パッケージのインストールと依存関係ファイルの作成と管理およびアプリケーションの virtualenv を組み合わせたものです。詳細については、「[Pipenv: 人間のための Python 開発ワークフロー](https://pipenv.readthedocs.io/en/latest/)」を参照してください。

Pipenv は 2 つのファイルを維持します。
+ `Pipfile` – このファイルには、さまざまな種類の依存関係と要件が含まれています。
+ `Pipfile.lock` – このファイルには、確定的なビルドを可能にするバージョンスナップショットが含まれています。

これらのファイルを開発環境で作成し、Elastic Beanstalk にデプロイするソースバンドルの最上位ディレクトリに含めることができます。これらの 2 つのファイルの詳細については、「[Pipfile と Pipfile.lock の例](https://pipenv.pypa.io/en/latest/basics/#)」を参照してください。



次の例では、Django と Django REST フレームワークをインストールするために Pipenv を使用しています。これらのコマンドは、ファイル `Pipfile` と `Pipfile.lock` を作成します。

```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```

 

## 優先順位
<a name="python-configuration-requirements.precedence"></a>

このトピックで説明する要件ファイルを複数含めると、Elastic Beanstalk はそのうちの 1 つだけを使用します。次の表に、優先順位を降順で示します。

1. `requirements.txt`

1. `Pipfile.lock`

1. `Pipfile`

**注記**  
2023 年 3 月 7 日の Amazon Linux 2 プラットフォームリリース以降、これらのファイルを複数指定すると、Elastic Beanstalk はデプロイ中にどの依存関係ファイルが使用されたかを示すコンソールメッセージを発行します。

次のステップは、インスタンスのデプロイ時に Elastic Beanstalk が依存関係をインストールするために従うロジックです。
+ `requirements.txt` ファイルがある場合は、コマンド `pip install -r requirements.txt` を使用します。
+ 2023 年 3 月 7 日の Amazon Linux 2 プラットフォームリリース以降、`requirements.txt` ファイルはなくても `Pipfile.lock` がある場合は、コマンド `pipenv sync` を使用します。そのリリース前は、`pipenv install --ignore-pipfile` を使用していました。
+ `requirements.txt` ファイルと `Pipfile.lock` のいずれも存在しないが、`Pipfile` が存在する場合は、コマンド `pipenv install --skip-lock` を使用します。
+ 3 つの要件ファイルが見つからない場合は、アプリケーションの依存関係はインストールされません。

# Elastic Beanstalk への Flask アプリケーションのデプロイ
<a name="create-deploy-python-flask"></a>

このチュートリアルでは、Flask アプリケーションを生成して AWS Elastic Beanstalk 環境にデプロイするプロセスについて説明します。Flask は、Python のオープンソースのウェブアプリケーション・フレームワークです。

このチュートリアルでは、以下の作業を行います。
+ [Flask で Python 仮想環境を設定する](#python-flask-setup-venv)
+ [Flask アプリケーションを作成する](#python-flask-create-app)
+ [EB CLI でサイトをデプロイします](#python-flask-deploy) 
+ [クリーンアップ](#python-flask-tutorial-cleanup) 

## 前提条件
<a name="python-flask-prereq"></a>

このチュートリアルでは、基本的な Elastic Beanstalk オペレーションと Elastic Beanstalk コンソールに関する知識があることを前提としています。まだ起動していない場合は、[Elastic Beanstalk の使用を開始する方法について説明します](GettingStarted.md) の指示に従って、最初の Elastic Beanstalk 環境を起動します。

このガイドの手順に従うには、run command のためのコマンドラインターミナルまたはシェルが必要になります。コマンドは、該当する場合、プロンプト記号 (\$1) と現在のディレクトリの名前が前に付けられて、リストに示されます。

```
~/eb-project$ this is a command
this is output
```

Linux および macOS では、任意のシェルとパッケージ管理者を使用できます。Windows では、[Linux 用の Windows サブシステムをインストール](https://docs.microsoft.com/en-us/windows/wsl/install-win10)して、Ubuntu および Bash の Windows に統合されたバージョンを入手できます。

このチュートリアルでは、Python 3.11 と対応する Elastic Beanstalk プラットフォームバージョンを使用します。「[Elastic Beanstalk 用の Python 開発環境の設定](python-development-environment.md)」の手順に従って Python をインストールします

チュートリアルのパートとして [Flask](http://flask.pocoo.org/) フレームワークをインストールします。

また、このチュートリアルでは、Elastic Beanstalk コマンドラインインターフェイス (EB CLI) も使用します。EB CLI をインストールおよび設定する手順の詳細については、「[セットアップスクリプトを使用して EB CLI をインストールする (推奨)](eb-cli3.md#eb-cli3-install)」および「[EB CLI の設定](eb-cli3-configuration.md)」を参照してください。

## Flask で Python 仮想環境を設定する
<a name="python-flask-setup-venv"></a>

アプリケーション用のプロジェクトディレクトリと仮想環境を作成し、Flask をインストールします。

**プロジェクト環境をセットアップするには**

1. プロジェクトディレクトリを作成します。

   ```
   ~$ mkdir eb-flask
   ~$ cd eb-flask
   ```

1. `virt` という名前の仮想環境を作成してアクティブ化します。

   ```
   ~/eb-flask$ virtualenv virt
   ~$ source virt/bin/activate
   (virt) ~/eb-flask$
   ```

   コマンドプロンプトの先頭に `(virt)` と表示され、仮想環境を使用していることが示されます。このチュートリアルの残りの部分では、仮想環境を使用します。

1. `pip install` で Flask をインストールします

   ```
   (virt)~/eb-flask$ pip install flask==3.0.3
   ```

1. `pip freeze` で、インストールされているライブラリを表示します

   ```
   (virt)~/eb-flask$ pip freeze
   blinker==1.8.2
   click==8.1.7
   Flask==3.0.3
   importlib_metadata==8.5.0
   itsdangerous==2.2.0
   Jinja2==3.1.4
   MarkupSafe==2.1.5
   Werkzeug==3.0.4
   zipp==3.20.2
   ```

   このコマンドは、仮想環境にインストールされるすべてのパッケージを一覧します。仮想環境にいるため、EB CLI などのグローバルにインストールされたパッケージは表示されません。

1. `pip freeze` からの出力を、`requirements.txt` という名前のファイルに保存します。

   ```
   (virt)~/eb-flask$ pip freeze > requirements.txt
   ```

   このファイルは、デプロイ中にライブラリをインストールするよう Elastic Beanstalk に指示します。詳細については、「[Elastic Beanstalk での要件ファイルを使用した依存関係の指定](python-configuration-requirements.md)」を参照してください。

## Flask アプリケーションを作成する
<a name="python-flask-create-app"></a>

次に、Elastic Beanstalk を使用してデプロイするアプリケーションを作成します。ここでは、"Hello World" という RESTful ウェブサービスを作成します。

このディレクトリに、`application.py` という名前と以下の内容で新しいテキスト・ファイルを作成します。

**Example `~/eb-flask/application.py`**  

```
from flask import Flask

# print a nice greeting.
def say_hello(username = "World"):
    return '<p>Hello %s!</p>\n' % username

# some bits of text for the page.
header_text = '''
    <html>\n<head> <title>EB Flask Test</title> </head>\n<body>'''
instructions = '''
    <p><em>Hint</em>: This is a RESTful web service! Append a username
    to the URL (for example: <code>/Thelonious</code>) to say hello to
    someone specific.</p>\n'''
home_link = '<p><a href="/">Back</a></p>\n'
footer_text = '</body>\n</html>'

# EB looks for an 'application' callable by default.
application = Flask(__name__)

# add a rule for the index page.
application.add_url_rule('/', 'index', (lambda: header_text +
    say_hello() + instructions + footer_text))

# add a rule when the page is accessed with a name appended to the site
# URL.
application.add_url_rule('/<username>', 'hello', (lambda username:
    header_text + say_hello(username) + home_link + footer_text))

# run the app.
if __name__ == "__main__":
    # Setting debug to True enables debug output. This line should be
    # removed before deploying a production app.
    application.debug = True
    application.run()
```

この例では、サービスへのアクセスに使用されるパスに基づいて変更されるカスタマイズされた挨拶を出力します。

**注記**  
アプリケーションを実行する前に `application.debug = True` を追加することで、問題が発生した場合にデバッグ出力が有効になります。これは開発の場合に有用な方法ですが、デバッグ出力によってアプリケーションの内部的な側面が明らかになる可能性があるため、実稼働のコードではデバッグステートメントを削除する必要があります。

ファイル名として `application.py` を使用し、呼び出し可能な `application` オブジェクト（この場合は Flask オブジェクト）を提供することで、Elastic Beanstalk がアプリケーションコードを見つけやすくなります。

Python を使用して `application.py` を実行します。

```
(virt) ~/eb-flask$ python application.py
 * Serving Flask app "application" (lazy loading)
 * Environment: production
   WARNING: Do not use the development server in a production environment.
   Use a production WSGI server instead.
 * Debug mode: on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 313-155-123
```

ウェブ・ブラウザで `http://127.0.0.1:5000/` を開きます。実行中のアプリケーションが表示され、インデックスページが表示されます。

![\[Web browser displaying "Hello World!" message and a hint about RESTful web service usage.\]](http://docs.aws.amazon.com/ja_jp/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)


サーバーログをチェックして、リクエストからの出力を確認します。**Ctrl\$1C** を押すと、ウェブ・サーバーを停止して仮想環境に戻ることができます。

デバッグ出力が表示される場合は、Elastic Beanstalk 用に設定する前に、エラーを修正し、そのアプリケーションがローカルで実行されることを確認します。

## EB CLI でサイトをデプロイします
<a name="python-flask-deploy"></a>

Elastic Beanstalk でアプリケーションをデプロイするために必要な条件をすべて追加しました。プロジェクトディレクトリは次のようになります。

```
~/eb-flask/
|-- virt
|-- application.py
`-- requirements.txt
```

ただし、`virt` フォルダは、Elastic Beanstalk でアプリケーションを実行するために必要ありません。デプロイすると、Elastic Beanstalk によりサーバーインスタンスに新しい仮想環境が作成され、`requirements.txt` にリストされているライブラリがインストールされます。デプロイ中にアップロードする出典バンドルのサイズを最小化するには、`virt` フォルダを離れるように EB CLI に指示する [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) ファイルを追加します。

**Example \$1/eb-flask/.ebignore**  

```
virt
```

次に、アプリケーション環境を作成し、設定済みのアプリケーションを Elastic Beanstalk を使用してデプロイします。

**環境を作成し、Flask アプリケーションをデプロイするには**

1. **eb init** コマンドで EB CLI リポジトリを初期化します。

   ```
   ~/eb-flask$ eb init -p python-3.11 flask-tutorial --region us-east-2
   Application flask-tutorial has been created.
   ```

   このコマンドは、 という名前の新しいアプリケーションを作成し`flask-tutorial`、最新の Python 3.11 プラットフォームバージョンで環境を作成するようにローカルリポジトリを設定します。

1. （オプション）**eb init** を再度実行してデフォルトのキーペアを設定し、アプリケーションを実行している EC2 インスタンスに SSH で connect できるようにします。

   ```
   ~/eb-flask$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   1 つのキーペアがすでにある場合はそれを選択するか、またはプロンプトに従って新しいキーペアを作成します。プロンプトが表示されないか設定を後で変更する必要がない場合は、**eb init -i** を実行します。

1. 環境を作成し、**eb create** を使用してそこにアプリケーションをデプロイします。

   ```
   ~/eb-flask$ eb create flask-env
   ```

環境の作成の所要時間は約 5 分です。以下のリソースが作成されます。
+ **EC2 インスタンス** – 選択したプラットフォームでウェブ・アプリケーションを実行するよう設定された Amazon Elastic Compute Cloud (Amazon EC2) 仮想マシン。

  各プラットフォームは、それぞれ特定の言語バージョン、フレームワーク、ウェブコンテナ、またはそれらの組み合わせをサポートするための、特定のソフトウェア、設定ファイル、スクリプトを実行します。ほとんどのプラットフォームでは、Apache または NGINX のいずれかをウェブアプリケーションの前にリバースプロキシとして配置します。そのプロキシがリクエストをアプリケーションに転送し、静的アセットを提供し、アクセスログとエラーログを生成します。
+ **インスタンスセキュリティグループ** – ポート 80 上のインバウンドトラフィックを許可するよう設定された Amazon EC2 セキュリティグループ。このリソースでは、ロードバランサーからの HTTP トラフィックが、ウェブ・アプリケーションを実行している EC2 インスタンスに達することができます。デフォルトでは、トラフィックは他のポート上で許可されません。
+ **ロードバランサー** – アプリケーションを実行するインスタンスにリクエストを分散するよう設定された Elastic Load Balancing ロードバランサー。ロードバランサーにより、インスタンスを直接インターネットに公開する必要もなくなります。
+ **ロードバランサーセキュリティグループ** – ポート 80 上のインバウンドトラフィックを許可するよう設定された Amazon EC2 セキュリティグループ。このリソースでは、インターネットからの HTTP トラフィックが、ロードバランサーに達することができます。デフォルトでは、トラフィックは他のポート上で許可されません。
+ **Auto Scaling グループ** – インスタンスが終了されたか利用不可になった場合にそのインスタンスを置き換えるよう設定された Auto Scaling グループ。
+ **Amazon S3 バケット** – Elastic Beanstalk の使用時に作成されるソースコード、ログ、その他のアーティファクトの保存場所。
+ **Amazon CloudWatch アラーム** – 環境内のインスタンスの負荷をモニタリングする 2 つの CloudWatch アラーム。負荷が高すぎる、または低すぎる場合にトリガーされます。アラームがトリガーされると、Auto Scaling グループはレスポンスとしてスケールアップまたはダウンを行います。
+ **CloudFormation スタック** – Elastic Beanstalk は CloudFormation を使用して環境内のリソースを起動し、設定変更を伝達します。リソースは、[CloudFormation コンソール](https://console.aws.amazon.com/cloudformation)に表示できるテンプレートで定義されます。
+ **ドメイン名** – ウェブ・アプリケーションまでのルートとなるドメイン名であり、**subdomain*.*region*.elasticbeanstalk.com* の形式です。
**ドメインセキュリティ**  
Elastic Beanstalk アプリケーションのセキュリティを強化するため、*elasticbeanstalk.com* ドメインは[パブリックサフィックスリスト (PSL)](https://publicsuffix.org/) に登録されています。  
Elastic Beanstalk アプリケーションのデフォルトドメイン名に機密性のある Cookie を設定する必要がある場合は、セキュリティ強化のため `__Host-` プレフィックスの付いた Cookie の使用をお勧めします。このプラクティスは、クロスサイトリクエストフォージェリ (CSRF) 攻撃からドメインを防御します。詳細については、Mozilla 開発者ネットワークの「[Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes)」ページを参照してください。

これらのリソースはすべて Elastic Beanstalk によって管理されます。環境を終了すると、Elastic Beanstalk は含まれているすべてのリソースを終了します。

**注記**  
Elastic Beanstalk が作成する Amazon S3 バケットは、環境間で共有され、環境の終了時に削除されません。詳細については、「[Amazon S3 で Elastic Beanstalk を使用する](AWSHowTo.S3.md)」を参照してください。

環境作成プロセスが完了したら、**eb open** でウェブサイトを開きます。

```
~/eb-flask$ eb open
```

これにより、アプリケーション用に作成されたドメイン名を使用してブラウザ・ウィンドウが開きます。ローカルで作成してテストしたのと同じ Flask ウェブサイトが表示されるはずです。

![\[Browser window displaying a Flask web application with a "Hello World!" message and usage hint.\]](http://docs.aws.amazon.com/ja_jp/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)


アプリケーションが実行されていることを確認できない場合や、エラーメッセージが表示される場合は、エラーの原因を判断する方法のヒントを得るために[デプロイのトラブルシューティング](troubleshooting.md#troubleshooting-deployments)を参照してください。

アプリケーションが実行されていることを*実際に*確認できた場合は、Elastic Beanstalk での最初の Flask アプリケーションのデプロイが正常に完了しています。

## クリーンアップ
<a name="python-flask-tutorial-cleanup"></a>

デモコードの操作が完了したら、環境を終了できます。Elastic Beanstalk は、[Amazon EC2 インスタンス](using-features.managing.ec2.md)、[データベースインスタンス](using-features.managing.db.md)、[ロードバランサー](using-features.managing.elb.md)、セキュリティグループ、[アラーム](using-features.alarms.md#using-features.alarms.title)など、関連するすべての AWS リソースを削除します。

リソースを削除しても Elastic Beanstalk アプリケーションは削除されないため、いつでもアプリケーションの新しい環境を作成できます。

**コンソールから Elastic Beanstalk 環境を終了するには**

1. [Elastic Beanstalk コンソール](https://console.aws.amazon.com/elasticbeanstalk)を開き、**リージョン**リストで を選択します AWS リージョン。

1. ナビゲーションペインで、[**環境**] を選択し、リストから環境の名前を選択します。

1. **[Actions]** (アクション)、**[Terminate environment]** (環境の終了) の順に選択します。

1. 画面上のダイアログボックスを使用して、環境の終了を確認します。

EB CLI の場合:

```
~/eb-flask$ eb terminate flask-env
```

## 次の手順
<a name="python-flask-more-info"></a>

Flask の詳細については、[flask.pocoo.org](http://flask.pocoo.org/) を参照してください。

別の Python ウェブ・フレームワークを試してみる場合は、「[Elastic Beanstalk への Django アプリケーションのデプロイ](create-deploy-python-django.md)」をチェックしてください

# Elastic Beanstalk への Django アプリケーションのデプロイ
<a name="create-deploy-python-django"></a>

このチュートリアルでは、自動生成されたデフォルトの [Django](https://www.djangoproject.com/) ウェブサイトを、Python を実行している AWS Elastic Beanstalk 環境にデプロイする手順を説明します。このチュートリアルでは、Elastic Beanstalk 環境を使用して、クラウドで Python ウェブアプリケーションをホストする方法を示します。

このチュートリアルでは、以下の作業を行います。
+ [Python 仮想環境のセットアップと Django のインストール](#python-django-setup-venv)
+ [Django プロジェクトを作成する](#python-django-create-app)
+ [Elastic Beanstalk 用に Django アプリケーションを設定する](#python-django-configure-for-eb) 
+ [EB CLI でサイトをデプロイします](#python-django-deploy) 
+ [アプリケーションの更新](#python-django-update-app) 
+ [クリーンアップ](#python-django-stopping)

## 前提条件
<a name="python-django-prereq"></a>

このチュートリアルを実行するには、以下のパッケージを含む、インストールされている Python の[一般的な前提条件](python-development-environment.md)をすべて満たす必要があります。
+ Python 3.7 以降
+ `pip`
+ `virtualenv`
+ `awsebcli`

チュートリアルのパートとして [Django](https://www.djangoproject.com/) フレームワークをインストールします。

**注記**  
EB CLI を使用して環境を作成するには、[サービスロール](concepts-roles-service.md)が必要です。Elastic Beanstalk コンソールで環境を作成することで、サービスロールを作成できます。サービスロールがない場合は、`eb create` を実行すると EB CLI で作成されます。

## Python 仮想環境のセットアップと Django のインストール
<a name="python-django-setup-venv"></a>

`virtualenv` で仮想環境を作成し、それを使用して Django とその依存関係をインストールします。仮想環境を使用することで、アプリケーションで必要なパッケージを正確に識別し、アプリケーションを実行する Amazon EC2 インスタンスにそれらの必要なパッケージをインストールすることができます。

以下のステップは、Unix ベースのシステムと Windows で入力する必要があるコマンドを、それぞれ別のタブに示しています。

**開発環境を設定するには**

1. `eb-virt` という名前の仮想環境を作成します。

------
#### [ Unix-based systems ]

   ```
   ~$ virtualenv ~/eb-virt
   ```

------
#### [ Windows ]

   ```
   C:\> virtualenv %HOMEPATH%\eb-virt
   ```

------

1. 仮想環境をアクティブ化します。

------
#### [ Unix-based systems ]

   ```
   ~$ source ~/eb-virt/bin/activate
   (eb-virt) ~$
   ```

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   コマンドプロンプトの先頭に `(eb-virt)` と表示され、仮想環境を使用していることが示されます。
**注記**  
残りの手順では、ホームディレクトリ `~$` での Linux のコマンドプロンプトを示しています。Windows では、`C:\Users\USERNAME>` であり、*ユーザーネーム* は Windows ログイン名です。

1. `pip` を使用して Django をインストールします。

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**注記**  
インストールする Django のバージョンは、アプリケーションのデプロイに選択した Elastic Beanstalk の Python 設定の Python バージョンと互換性がある必要があります。デプロイの詳細については、このトピックの「[EB CLI でサイトをデプロイします](#python-django-deploy)」を参照してください。  
現在の Python プラットフォームバージョンの詳細については、*AWS Elastic Beanstalk プラットフォーム*ドキュメントの「[Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)」を参照してください。  
Django のバージョンと Python との互換性については、「[What Python version can I use with Django? (Django で使用可能な Python のバージョンを教えてください)](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)」を参照してください。

1. Django がインストールされたことを確認するには、次のように入力します。

   ```
   (eb-virt)~$ pip freeze
   Django==2.2
   ...
   ```

   このコマンドは、仮想環境にインストールされるすべてのパッケージを一覧します。後でこのコマンドの出力を使用して、プロジェクトを Elastic Beanstalk で使用するために設定します。

## Django プロジェクトを作成する
<a name="python-django-create-app"></a>

仮想環境を使用して、Django プロジェクトを作成してマシンで実行する準備ができました。

**注記**  
このチュートリアルでは、Python に含まれているデータベースエンジン、SQLite を使用します。データベースはプロジェクトファイルでデプロイされます。本番稼働用環境では、Amazon Relational Database Service (Amazon RDS) を使用して、環境を分離することをお勧めします。詳細については、「[Amazon RDS DB インスタンスを Python Elastic Beanstalk 環境に追加する](create-deploy-python-rds.md)」を参照してください。

**Django アプリケーションを作成するには**

1. 仮想環境をアクティブ化します。

------
#### [ Unix-based systems ]

   ```
   ~$ source ~/eb-virt/bin/activate
   (eb-virt) ~$
   ```

------
#### [ Windows ]

   ```
   C:\>%HOMEPATH%\eb-virt\Scripts\activate
   (eb-virt) C:\>
   ```

------

   コマンドプロンプトの先頭に `(eb-virt)` プレフィックスが表示され、仮想環境を使用していることが示されます。
**注記**  
残りの手順では、ホームディレクトリと Linux のホームディレクトリ `~/` に Linux のコマンドプロンプト `~$` を示しています。Windows では、`C:\Users\USERNAME>` であり、*ユーザーネーム* は Windows ログイン名です。

1. `django-admin startproject` コマンドを使用して、`ebdjango` という名前の Django のプロジェクトを作成します。

   ```
   (eb-virt)~$ django-admin startproject ebdjango
   ```

   このコマンドは、次のディレクトリ構造を持つ **ebdjango** というスタンダードの Django サイトを作成します。

   ```
   ~/ebdjango
     |-- ebdjango
     |   |-- __init__.py
     |   |-- settings.py
     |   |-- urls.py
     |   `-- wsgi.py
     `-- manage.py
   ```

1. `manage.py runserver` で Django サイトをローカルで実行します。

   ```
   (eb-virt) ~$ cd ebdjango
   ```

   ```
   (eb-virt) ~/ebdjango$ python manage.py runserver
   ```

1. ウェブ・ブラウザで `http://127.0.0.1:8000/` を開いて、サイトを表示します。

1. サーバーログをチェックして、リクエストからの出力を確認します。ウェブサーバーを停止して仮想環境に戻るには、 **Ctrl\$1C** を押します。

   ```
   Django version 2.2, using settings 'ebdjango.settings'
   Starting development server at http://127.0.0.1:8000/
   Quit the server with CONTROL-C.
   [07/Sep/2018 20:14:09] "GET / HTTP/1.1" 200 16348
   Ctrl+C
   ```

## Elastic Beanstalk 用に Django アプリケーションを設定する
<a name="python-django-configure-for-eb"></a>

Django を使用してローカルシステムに作成したサイトを、Elastic Beanstalk でのデプロイ用に設定します。

デフォルトでは、Elastic Beanstalk は、アプリケーションを開始するために `application.py` というファイルを探します。これは作成した Django プロジェクトには存在しないため、アプリケーションの環境を調整する必要があります。また、アプリケーションのモジュールをロードできるように、環境可変数を設定する必要もあります。

**Elastic Beanstalk 用にサイトを設定するには**

1. 仮想環境をアクティブ化します。

------
#### [ Unix-based systems ]

   ```
   ~/ebdjango$ source ~/eb-virt/bin/activate
   ```

------
#### [ Windows ]

   ```
   C:\Users\USERNAME\ebdjango>%HOMEPATH%\eb-virt\Scripts\activate
   ```

------

1. `pip freeze` を実行して、出力を `requirements.txt` という名前のファイルに保存します。

   ```
   (eb-virt) ~/ebdjango$ pip freeze > requirements.txt
   ```

   Elastic Beanstalk は `requirements.txt` を使用して、アプリケーションを実行する EC2 インスタンスにどのパッケージをインストールするかを判断します。

1. `.ebextensions` という名前のディレクトリを作成します。

   ```
   (eb-virt) ~/ebdjango$ mkdir .ebextensions
   ```

1. `.ebextensions` ディレクトリ内に、次のテキストを持つ `django.config` という名前の [設定ファイル](ebextensions.md) を追加します。  
**Example \$1/ebdjango/.ebextensions/django.config**  

   ```
   option_settings:
     aws:elasticbeanstalk:container:python:
       WSGIPath: ebdjango.wsgi:application
   ```

   この設定 `WSGIPath` は、アプリケーションを起動するのに Elastic Beanstalk が使用する WSGI スクリプトの場所を指定します。
**注記**  
Amazon Linux AMI Python プラットフォームバージョン (Amazon Linux 2 より前の) を使用している場合は、`WSGIPath` の値を `ebdjango/wsgi.py` に置き換えます。この例の値は、Amazon Linux AMI プラットフォームバージョンでは support されていない Gunicorn WSGI サーバーで動作します。

1. `deactivate` コマンドを使用して、仮想環境を非アクティブ化します。

   ```
   (eb-virt) ~/ebdjango$ deactivate
   ```

   パッケージをアプリケーションに追加するか、またはアプリケーションをローカルで実行する必要があるときは、いつでも仮想環境を再アクティブ化します。

## EB CLI でサイトをデプロイします
<a name="python-django-deploy"></a>

Elastic Beanstalk でアプリケーションをデプロイするために必要な条件をすべて追加しました。プロジェクトディレクトリは次のようになります。

```
~/ebdjango/
|-- .ebextensions
|   `-- django.config
|-- ebdjango
|   |-- __init__.py
|   |-- settings.py
|   |-- urls.py
|   `-- wsgi.py
|-- db.sqlite3
|-- manage.py
`-- requirements.txt
```

次に、アプリケーション環境を作成し、設定済みのアプリケーションを Elastic Beanstalk を使用してデプロイします。

デプロイの直後に、Django の設定を編集して Elastic Beanstalk からアプリケーションに割り当てられたドメイン名を Django の `ALLOWED_HOSTS` に追加します。次に、アプリケーションを再デプロイします。これは、HTTP `Host` ヘッダー攻撃を防ぐように設計された Django のセキュリティ要件です。詳細については、「[Host header validation (ホスト・ヘッダーの検証)](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting)」を参照してください。

**環境を作成し、Django アプリケーションをデプロイするには**
**注記**  
このチュートリアルでは、EB CLI をデプロイメントメカニズムとして使用しますが、Elastic Beanstalk コンソールを使用してプロジェクトの内容を含む .zip ファイルを展開することもできます。

1. **eb init** コマンドを使用して EB CLI リポジトリを初期化します。

   ```
   ~/ebdjango$ eb init -p python-3.7 django-tutorial
   Application django-tutorial has been created.
   ```

   このコマンドでは、`django-tutorial` という名前のアプリケーションを作成します。また、ローカルリポジトリを設定し、最新の Python 3.7 プラットフォームバージョンで環境を作成します。

1. (オプション) **eb init** を再度実行してデフォルトのキーペアを設定し、アプリケーションを実行している EC2 インスタンスに SSH を使用して connect できるようにします。

   ```
   ~/ebdjango$ eb init
   Do you want to set up SSH for your instances?
   (y/n): y
   Select a keypair.
   1) my-keypair
   2) [ Create new KeyPair ]
   ```

   1 つのキーペアがすでにある場合はそれを選択するか、またはプロンプトに従ってキーペアを作成します。プロンプトが表示されないか設定を後で変更する必要がない場合は、**eb init -i** を実行します。

1. 環境を作成し、**eb create** を使用してそこにアプリケーションをデプロイします。

   ```
   ~/ebdjango$ eb create django-env
   ```
**注記**  
「service role required」エラーメッセージが表示された場合は、`eb create` をインタラクティブに (環境名を指定せずに) 実行してください。EB CLI によってロールが作成されます。

   このコマンドは、`django-env` という名前のロードバランシング Elastic Beanstalk 環境を作成します。環境の作成には約 5 分かかります。Elastic Beanstalk はアプリケーションを実行するのに必要なリソースを作成し、EB CLI がターミナルに中継する情報メッセージを出力します。

1. 環境の作成プロセスが完了したら、**eb status** を実行して新しい環境のドメイン名を見つけます。

   ```
   ~/ebdjango$ eb status
   Environment details for: django-env
     Application name: django-tutorial
     ...
     CNAME: eb-django-app-dev.elasticbeanstalk.com
     ...
   ```

   環境のドメイン名は、`CNAME` プロパティの値です。

1. `ebdjango` ディレクトリの `settings.py` ファイルを開きます。`ALLOWED_HOSTS` 設定を見つけ、前のステップで見つけたアプリケーションのドメイン名を設定の値に追加します。この設定がファイルで見つからない場合は、それを新しい行に追加します。

   ```
   ...
   ALLOWED_HOSTS = ['eb-django-app-dev.elasticbeanstalk.com']
   ```

1. ファイルを保存し、**eb deploy** を実行してアプリケーションをデプロイします。**eb deploy** を実行すると、EB CLI はプロジェクトディレクトリのコンテンツをバンドルアップして、ユーザーの環境にデプロイします。

   ```
   ~/ebdjango$ eb deploy
   ```
**注記**  
プロジェクトで Git を使用している場合は、「[Git での EB CLI の使用](eb3-cli-git.md)」を参照してください。

1. 環境の更新プロセスが完了したら、**eb open** でウェブサイトを開きます。

   ```
   ~/ebdjango$ eb open
   ```

   これにより、アプリケーション用に作成されたドメイン名を使用してブラウザ・ウィンドウが開きます。ローカルで作成してテストしたのと同じ Django ウェブサイトが表示されます。

アプリケーションが実行されていることを確認できない場合や、エラーメッセージが表示される場合は、エラーの原因を判断する方法のヒントを得るために[デプロイのトラブルシューティング](troubleshooting.md#troubleshooting-deployments)を参照してください。

アプリケーションが実行されていることを*実際に*確認できた場合は、Elastic Beanstalk での最初の Django アプリケーションのデプロイが正常に完了しています。

## アプリケーションの更新
<a name="python-django-update-app"></a>

Elastic Beanstalk で実行中のアプリケーションまたはその設定を更新して再デプロイすることができます。この場合、インスタンスを更新して新しいアプリケーションバージョンを開始する作業は、Elastic Beanstalk が実行します。

この例では、Django の管理者コンソールを有効にして、他のいくつかの項目を設定します。

### サイト設定を変更する
<a name="python-django-modify-site"></a>

デフォルトでは、Django ウェブサイトは UTC タイムゾーンを使用して時間を表示します。`settings.py` でタイムゾーンを指定して、これを変更することができます。

**サイトのタイムゾーンを変更するには**

1. `settings.py` の `TIME_ZONE` 設定を変更します  
**Example \$1/ebdjango/ebdjango/settings.py**  

   ```
   ...
   # Internationalization
   LANGUAGE_CODE = 'en-us'
   TIME_ZONE = 'US/Pacific'
   USE_I18N = True
   USE_L10N = True
   USE_TZ = True
   ```

   タイムゾーンのリストについては、[このページ](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)を参照してください。

1. アプリケーションを Elastic Beanstalk 環境にデプロイします。

   ```
   ~/ebdjango/$ eb deploy
   ```

### サイト管理者を作成する
<a name="python-django-create-admin"></a>

Django アプリケーション用のサイト管理者を作成すると、ウェブサイトから管理者コンソールに直接アクセスできます。管理者のログインの詳細は、Django が生成したデフォルトプロジェクトに含まれるローカルデータベース・イメージに安全に保存されます。

**サイト管理者を作成するには**

1. Django アプリケーションのローカルデータベースを初期化します。

   ```
   (eb-virt) ~/ebdjango$ python manage.py migrate
   Operations to perform:
     Apply all migrations: admin, auth, contenttypes, sessions
   Running migrations:
     Applying contenttypes.0001_initial... OK
     Applying auth.0001_initial... OK
     Applying admin.0001_initial... OK
     Applying admin.0002_logentry_remove_auto_add... OK
     Applying admin.0003_logentry_add_action_flag_choices... OK
     Applying contenttypes.0002_remove_content_type_name... OK
     Applying auth.0002_alter_permission_name_max_length... OK
     Applying auth.0003_alter_user_email_max_length... OK
     Applying auth.0004_alter_user_username_opts... OK
     Applying auth.0005_alter_user_last_login_null... OK
     Applying auth.0006_require_contenttypes_0002... OK
     Applying auth.0007_alter_validators_add_error_messages... OK
     Applying auth.0008_alter_user_username_max_length... OK
     Applying auth.0009_alter_user_last_name_max_length... OK
     Applying sessions.0001_initial... OK
   ```

1. `manage.py createsuperuser` を実行して、管理者を作成します。

   ```
   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: me@mydomain.com
   Password: ********
   Password (again): ********
   Superuser created successfully.
   ```

1. 静的ファイルの保存する場所を Django に渡すには、`STATIC_ROOT` で `settings.py` を定義します。  
**Example \$1/ebdjango/ebdjango/settings.py**  

   ```
   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'
   ```

1. `manage.py collectstatic` を実行して、`static` ディレクトリに管理者サイトの静的アセット (JavaScript、CSS、イメージ) を追加します。

   ```
   (eb-virt) ~/ebdjango$ python manage.py collectstatic
   119 static files copied to ~/ebdjango/static
   ```

1. アプリケーションをデプロイします。

   ```
   ~/ebdjango$ eb deploy
   ```

1. ブラウザでサイトを開き、次のようにサイトの URL に `/admin/` を付加することで、管理者コンソールが表示されます。

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[ステップ 2 で作成したユーザーネームとパスワードを入力して管理者コンソールにログ・インします。\]](http://docs.aws.amazon.com/ja_jp/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. ステップ 2 で設定したユーザーネームとパスワードでログ・インします。  
![\[Elastic Beanstalk でデプロイした Django ウェブサイトの Django 管理コンソール\]](http://docs.aws.amazon.com/ja_jp/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

ローカルでの更新/テストと同様の手順を使用し、続けて **eb deploy** を実行することができます。実稼働サーバーの更新は Elastic Beanstalk が処理するため、ユーザーはサーバー管理ではなくアプリケーション開発に集中できます。

### データベース移行設定ファイルを追加する
<a name="python-django-migrate-site"></a>

サイトが更新されたときに実行される `.ebextensions` スクリプトに、コマンドを追加することができます。これにより、データベース・マイグレーションを自動的に生成できます。

**アプリケーションがデプロイされたときに移行ステップを追加するには**

1. 以下の内容を使用して、`db-migrate.config` と言う名前の[設定ファイル](ebextensions.md)を追加します。  
**Example \$1/ebdjango/.ebextensions/db-migrate.config**  

   ```
   container_commands:
     01_migrate:
       command: "source /var/app/venv/*/bin/activate && python3 manage.py migrate"
       leader_only: true
   option_settings:
     aws:elasticbeanstalk:application:environment:
       DJANGO_SETTINGS_MODULE: ebdjango.settings
   ```

   この設定ファイルは、サーバーの仮想環境をアクティブ化し、アプリケーションがスタートする前に、デプロイプロセスの間に `manage.py migrate` コマンドを実行します。アプリケーションがスタートする前に実行されるため、`DJANGO_SETTINGS_MODULE` 環境可変数を明確に設定する必要もあります (通常は、スタートアップ中に `wsgi.py` がこれを行います)。コマンドで `leader_only: true` を指定することで、複数のインスタンスにデプロイする場合に 1 回だけ実行するようにできます。

1. アプリケーションをデプロイします。

   ```
   ~/ebdjango$ eb deploy
   ```

## クリーンアップ
<a name="python-django-stopping"></a>

開発セッション間でインスタンス時間やその他の AWS リソースを節約するには、 を使用して Elastic Beanstalk 環境を終了します**eb terminate**。

```
~/ebdjango$ eb terminate django-env
```

このコマンドは、環境とその環境内で実行されるすべての AWS リソースを終了します。これによってアプリケーションが削除されることはありません。したがって **eb create** を再び実行することで、いつでも同じ設定でさらに環境を作成することができます。

サンプルアプリケーションが必要なくなった場合は、プロジェクトフォルダーと仮想環境を削除することもできます。

```
~$ rm -rf ~/eb-virt
~$ rm -rf ~/ebdjango
```

## 次の手順
<a name="python-django-next-steps"></a>

詳細なチュートリアルを含む Django の情報については、[公式ドキュメント](https://docs.djangoproject.com/en/2.2/)を参照してください。

別の Python ウェブフレームワークを試す場合は、「[Elastic Beanstalk への Flask アプリケーションのデプロイ](create-deploy-python-flask.md)」をチェックしてください。

# Amazon RDS DB インスタンスを Python Elastic Beanstalk 環境に追加する
<a name="create-deploy-python-rds"></a>

このトピックでは、Elastic Beanstalk コンソールを使用して Amazon RDS を作成する手順について説明します。Amazon Relational Database Service (Amazon RDS) DB インスタンスを使用して、アプリケーションによって収集および変更されたデータを保存することができます。データベースを環境に結合して Elastic Beanstalk で管理することも、分離したものとして作成して別のサービスで外部的に管理することもできます。これらの手順では、データベースは環境に結合され、Elastic Beanstalk によって管理されます。Amazon RDS と Elastic Beanstalk の統合の詳細については、「[Elastic Beanstalk 環境にデータベースを追加する](using-features.managing.db.md)」を参照してください。

**Topics**
+ [環境に DB インスタンスを追加](#python-rds-create)
+ [ドライバのダウンロード](#python-rds-drivers)
+ [データベースへの接続](#python-rds-connect)

## 環境に DB インスタンスを追加
<a name="python-rds-create"></a>

**お客様の環境に DB インスタンスを追加するには**

1. [Elastic Beanstalk コンソール](https://console.aws.amazon.com/elasticbeanstalk)を開き、**リージョン**リストで を選択します AWS リージョン。

1. ナビゲーションペインで、[**環境**] を選択し、リストから環境の名前を選択します。

1. ナビゲーションペインで、[**設定**] を選択します。

1. [**データベース**] 設定カテゴリで、[**編集**] を選択します。

1. DB エンジンを選択して、ユーザー名とパスワードを入力します。

1. ページの最下部で **[適用]** を選択し変更を保存します。

DB インスタンスの追加には約 10 分かかります。環境の更新が完了すると、DB インスタンスのホスト名とその他の接続情報は以下の環境プロパティを通じてアプリケーションに使用できるようになります。


| プロパティ名 | 説明 | プロパティ値 | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  DB インスタンスのホスト名。  |  Amazon RDS コンソールの [**Connectivity & security (Connectivityとセキュリティ)**] タブ: [**Endpoint (エンドポイント)**]。  | 
|  `RDS_PORT`  |  DB インスタンスが接続を許可するポート。デフォルト値は DB エンジンによって異なります。  |  Amazon RDS コンソールの [**Connectivity & security (接続とセキュリティ)**] タブ: [**Port (ポート)**]。  | 
|  `RDS_DB_NAME`  |  データベース名 **ebdb**。  |  Amazon RDS コンソールの [**Configuration (設定)**] タブ: [**DB Name (DB 名)**]。  | 
|  `RDS_USERNAME`  |  お客様のデータベース用に設定したユーザー名。  |  Amazon RDS コンソールの [**Configuration (設定)**] タブ: [**Master username (マスターユーザー名)**]。  | 
|  `RDS_PASSWORD`  |  お客様のデータベース用に設定したパスワード。  |  Amazon RDS コンソールではリファレンスできません。  | 

Elastic Beanstalk 環境と結合したデータベースインスタンスの設定の詳細については、「[Elastic Beanstalk 環境にデータベースを追加する](using-features.managing.db.md)」を参照してください。

## ドライバのダウンロード
<a name="python-rds-drivers"></a>

プロジェクトの[要件ファイル](python-configuration-requirements.md)にデータベース・ドライバを追加します。

**Example requirements.txt – Django with MySQL**  

```
Django==2.2
mysqlclient==2.0.3
```

**Python の共通ドライバパッケージ**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle** – `cx_Oracle`
+ **SQL Server** – `adodbapi`

詳細については、[Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) と [Django 2.2 が support するデータベース](https://docs.djangoproject.com/en/2.2/ref/databases)を参照してください。

## データベースへの接続
<a name="python-rds-connect"></a>

Elastic Beanstalk は、環境プロパティでアタッチされた DB インスタンスの接続情報を提供します。`os.environ['VARIABLE']` を使用してプロパティを読み取り、データベース接続を設定します。

**Example Django の設定ファイル – DATABASES ディクショナリ**  

```
import os

if 'RDS_HOSTNAME' in os.environ:
    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': os.environ['RDS_DB_NAME'],
            'USER': os.environ['RDS_USERNAME'],
            'PASSWORD': os.environ['RDS_PASSWORD'],
            'HOST': os.environ['RDS_HOSTNAME'],
            'PORT': os.environ['RDS_PORT'],
        }
    }
```

# Python のツールとリソース
<a name="create-deploy-python-tools-resources"></a>

Python アプリケーションのデプロイに関しては他にも参照情報があります。


****  

| [リソース]  | 説明 | 
| --- | --- | 
| [AWS SDK for Python (Boto3) GitHub の](https://github.com/boto/boto3) | GitHub から入手した Boto3 をインストールします。 | 
| [AWS SDK for Python (Boto3) ホームページ](https://aws.amazon.com//sdk-for-python/) |  AWS SDK for Python (Boto3) ホームページ。 | 
| [Python デベロッパーセンター](https://aws.amazon.com/python/) | サンプルコード、ドキュメント、ツール、追加リソースを 1 か所で入手できる場所です。 |