本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。

# 使用 Elastic Beanstalk 部署 Python 应用程序
<a name="create-deploy-python-apps"></a>

本章提供有关配置 Python Web 应用程序并将其部署到的说明 AWS Elastic Beanstalk。Elastic Beanstalk 让您能够使用 Amazon Web Services 轻松部署、管理和扩展您的 Python Web 应用程序。

您可以使用 Elastic Beanstalk 命令行界面（EB CLI）或 Elastic Beanstalk 控制台在几分钟内部署您的应用程序。部署 Elastic Beanstalk 应用程序后，您可以继续使用 EB CLI 来管理您的应用程序和环境，也可以使用 Elastic Beanstalk 控制台或。 AWS CLI APIs

按照中的步骤操作，[QuickStart 适用于 Python](python-quickstart.md)了解 step-by-step如何使用 EB CLI 创建和部署 Python *Hello World* Web 应用程序。

**Topics**
+ [QuickStart: 将 Python 应用程序部署到 Elastic Beanstalk](python-quickstart.md)
+ [为 Elastic Beanstalk 设置 Python 开发环境](python-development-environment.md)
+ [使用 Elastic Beanstalk Python 平台](create-deploy-python-container.md)
+ [将 Flask 应用程序部署到 Elastic Beanstalk](create-deploy-python-flask.md)
+ [将 Django 应用程序部署到 Elastic Beanstalk](create-deploy-python-django.md)
+ [将 Amazon RDS DB 实例添加到 Python Elastic Beanstalk 环境](create-deploy-python-rds.md)
+ [Python 工具和资源](create-deploy-python-tools-resources.md)

# QuickStart: 将 Python 应用程序部署到 Elastic Beanstalk
<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/注册。](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 Identity Center，启用并创建管理用户，这样您就不会使用 root 用户执行日常任务。

**保护你的 AWS 账户根用户**

1.  选择 **Root 用户**并输入您的 AWS 账户 电子邮件地址，以账户所有者的身份登录。[AWS 管理控制台](https://console.aws.amazon.com/)在下一页上，输入您的密码。

   要获取使用根用户登录方面的帮助，请参阅《AWS 登录 用户指南》**中的 [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial)。

1. 为您的根用户启用多重身份验证（MFA）。

   有关说明，请参阅 I [A *M* 用户指南中的为 AWS 账户 根用户启用虚拟 MFA 设备（控制台）](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html)。

**创建具有管理访问权限的用户**

1. 启用 IAM Identity Center。

   有关说明，请参阅**《AWS IAM Identity Center 用户指南》中的[启用 AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html)。

1. 在 IAM Identity Center 中，为用户授予管理访问权限。

   有关使用 IAM Identity Center 目录 作为身份源的教程，请参阅《[用户*指南》 IAM Identity Center 目录中的使用默认设置配置AWS IAM Identity Center 用户*访问权限](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html)。

**以具有管理访问权限的用户身份登录**
+ 要使用您的 IAM Identity Center 用户身份登录，请使用您在创建 IAM Identity Center 用户时发送到您的电子邮件地址的登录 URL。

  有关使用 IAM Identity Center 用户[登录的帮助，请参阅*AWS 登录 用户指南*中的登录 AWS 访问门户](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html)。

**将访问权限分配给其他用户**

1. 在 IAM Identity Center 中，创建一个权限集，该权限集遵循应用最低权限的最佳做法。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html)。

1. 将用户分配到一个组，然后为该组分配单点登录访问权限。

   有关说明，请参阅《AWS IAM Identity Center 用户指南》**中的 [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html)。

## 先决条件
<a name="python-quickstart-prereq"></a>

为了遵循本指南中的步骤，您需要命令行终端或 Shell，以便运行命令。命令显示在列表中，以提示符（\$1）和当前目录名称（如果有）开头。

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

在 Linux 和 macOS 中，您可使用您首选的 Shell 和程序包管理器。在 Windows 上，您可以[安装适用于 Linux 的 Windows 子系统](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，以获取与 Windows 集成的 Ubuntu 和 Bash 版本。

### 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 was not found*”，请运行以下命令，使用 `python` 而不是 `python3`。别名和符号链接的设置可能因操作系统和个人自定义设置而异，因此 `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 平台*指南中的[Supported Python platforms](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python)。Python 下载网站提供了《*Python 开发人员指南》的链接，您可以在其中找到安装和设置说明。*

**注意**  
Python 3.4 或更高版本默认包含 Python `pip` 包。

如果输出表明您有受支持的 Python 版本，但没有 `pip`，请参阅 *pip.pypa.io* 网站上的 [Installation](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 -
```

在 Web 浏览器中导航到 `http://localhost:5000`。Web 浏览器应显示“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** 以配置默认密钥对，以便使用 SSH 连接到运行您的应用程序的 EC2 实例。

   ```
   ~/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 ]
   ```

   如果您已有密钥对，请选择一个，或按提示创建一个。如果您没有看到提示或需要以后更改设置，请运行 **eb init -i**。

1. 创建环境并使用 **eb create** 将应用程序部署到此环境中。Elastic Beanstalk 会自动为您的应用程序生成一个 zip 文件，并在端口 5000 上启动该文件。

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

   Elastic Beanstalk 大约需要五分钟来创建您的环境。

## 步骤 4：在 Elastic Beanstalk 上运行应用程序
<a name="python-quickstart-run-eb-ap"></a>

当创建环境的过程完成后，使用 **eb open** 打开您的网站。

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

恭喜您！您已使用 Elastic Beanstalk 部署了 Python 应用程序！这将使用为应用程序创建的域名打开一个浏览器窗口。

## 第 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>

您刚刚创建了一个单实例应用程序。它可用作带有单个 EC2 实例的简单示例应用程序，因此不需要负载平衡或自动扩缩。对于单实例应用程序，Elastic Beanstalk 会创建以下资源： AWS 
+ **EC2 实例** - 配置来在您选择的平台上运行 Web 应用程序的 Amazon EC2 虚拟机。

  各平台运行一组不同的软件、配置文件和脚本以支持特定的语言版本、框架、Web 容器或其组合。大多数平台使用 Apache 或 nginx 作为在 Web 应用程序前处理 Web 流量的反向代理，向其转发请求、提供静态资产以及生成访问和错误日志。
+ **实例安全组** - 配置为允许端口 80 上的传入流量的 Amazon EC2 安全组。通过此资源，HTTP 流量可以从负载均衡器到达运行您的 Web 应用程序的 EC2 实例。默认情况下，其他端口不允许流量进入。
+ **Amazon S3 存储桶** – 使用 Elastic Beanstalk 时创建的源代码、日志和其他构件的存储位置。
+ **Amazon CloudWatch CloudWatch 警**报 — 两个警报，用于监控您环境中实例的负载，并在负载过高或过低时触发。警报触发后，您的 Auto Scaling 组会扩展或收缩以进行响应。
+ **CloudFormation 堆栈** — Elastic CloudFormation Beanstalk 用于在您的环境中启动资源并传播配置更改。这些资源在您可通过 [CloudFormation 控制台](https://console.aws.amazon.com/cloudformation)查看的模板中定义。
+  **域名**-以表单形式路由到您的 Web 应用程序的域名**subdomain*。 *region*.elasticbeanstalk.com。*

Elastic Beanstalk 管理所有这些资源。当您终止环境时，Elastic Beanstalk 会终止其包含的所有资源。

## 后续步骤
<a name="python-quickstart-next-steps"></a>

有了运行应用程序的环境以后，您随时可以部署新的应用程序版本或不同的应用程序。部署新应用程序版本非常快，因为不需要配置或重新启动 EC2 实例。您还可以使用 Elastic Beanstalk 控制台探索新环境。有关详细步骤，请参阅本指南*入门*一章中的[探索您的环境](GettingStarted.md#GettingStarted.Explore)。

**尝试更多教程**  
如果您想尝试包含不同示例应用程序的其他教程，请参阅以下教程：  
[将 Flask 应用程序部署到 Elastic Beanstalk](create-deploy-python-flask.md)
[将 Django 应用程序部署到 Elastic Beanstalk](create-deploy-python-django.md)

部署一到两个示例应用程序并准备好开始在本地开发和运行 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之前在本地对其进行测试的说明。它还引用了提供有用工具安装说明的网站。

为了遵循本指南中的步骤，您需要命令行终端或 Shell，以便运行命令。命令显示在列表中，以提示符（\$1）和当前目录名称（如果有）开头。

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

在 Linux 和 macOS 中，您可使用您首选的 Shell 和程序包管理器。在 Windows 上，您可以[安装适用于 Linux 的 Windows 子系统](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，以获取与 Windows 集成的 Ubuntu 和 Bash 版本。

**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 平台指南*中的 [Supported Python platforms](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` package** – 此 `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 来准备 Python 应用程序，以便与 Elastic Beanstalk 一起部署。

**将 Python 应用程序配置为随 Elastic Beanstalk 一起部署**

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 Web 应用程序可以在具有 WSGI 的代理服务器后面运行。Elastic Beanstalk 提供 [Gunicorn](https://gunicorn.org/) 作为默认 WSGI 服务器。

您可以将 `Procfile` 添加到源捆绑包，以指定和配置应用程序的 WSGI 服务器。有关更多信息，请参阅 [在 Elastic Beanstalk 上使用 Procfile 配置 WSGI 服务器](python-configuration-procfile.md)。

您可以使用通过 Pipenv 创建的 `Pipfile` 和 `Pipfile.lock` 文件，指定 Python 包依赖项和其他要求。有关指定依赖项的详细信息，请参阅[在 Elastic Beanstalk 上使用要求文件指定依赖项](python-configuration-requirements.md)。

Elastic [Beanstalk 提供了](command-options.md)配置选项，您可以使用这些选项来自定义在 Elastic Beanstalk 环境中的实例 EC2 上运行的软件。您可配置应用程序所需的环境变量，启用日志轮换至 Amazon S3，并将应用程序源中包含静态文件的文件夹映射至代理服务器所提供的路径。

Elastic Beanstalk 控制台中提供了配置选项，可用于[修改运行环境的配置](environment-configuration-methods-after.md)。要避免在终止环境时丢失环境配置，可以使用[保存的配置](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 平台设置允许您微调亚马逊 EC2 实例的行为。您可以使用 Elastic Beanstalk 控制台编辑 Elastic Beanstalk 环境 EC2 的亚马逊实例配置。

使用 Elastic Beanstalk 控制台配置 Python 进程 AWS X-Ray设置，启用和启用 Amazon S3 的日志轮换，以及配置应用程序可以从环境中读取的变量。

**在 Elastic Beanstalk 控制台中配置 Python 环境**

1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域

1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。

1. 在导航窗格中，选择 **Configuration**（配置）。

1. 在 **Updates, monitoring, and logging**（更新、监控和日志记录）配置类别中，选择 **Edit**（编辑）。

### Python 设置
<a name="python-console-settings"></a>
+ **Proxy server**（代理服务器）– 要在环境实例上使用的代理服务器。默认情况下，使用 nginx。
+ **WSGI Path**（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>

“日志选项”部分有两个设置：
+ **Instance profile**（实例配置文件）– 指定有权访问与应用程序关联的 Amazon S3 存储桶的实例配置文件。
+ **启用向 Amazon S3 的日志文件轮换-指定是否将**应用程序的 Amazon EC2 实例的日志文件复制到与您的应用程序关联的 Amazon S3 存储桶中。

### 静态文件
<a name="python-platform-staticfiles"></a>

为了提高性能，您可以使用 **Static files**（静态文件）部分配置代理服务器，以便从 Web 应用程序内的一组目录提供静态文件（例如 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` 的环境属性，指定应用程序可用于连接数据库的连接字符串。

在 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`）以及指定 `[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`。示例中的值适用于 Gunicorn WSGI 服务器，该服务器在 Amazon Linux AMI 平台版本上不受支持。
此外，这些较旧的平台版本使用不同的命名空间来配置静态文件 - `aws:elasticbeanstalk:container:python:staticfiles`。它与标准静态文件命名空间具有相同的选项名称和语义。

配置文件还支持多个密钥，以便进一步[在环境实例上修改软件](customize-containers-ec2.md)。此示例使用[程序包](customize-containers-ec2.md#linux-packages)密钥，以使用 `yum` 和[容器命令](customize-containers-ec2.md#linux-container-commands)安装 Memcached，从而在部署期间运行配置服务器的命令。

```
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 AL2 023 平台上，`/usr/bin/python3`指向 Python 3.9。这是因为 Python 3.9 是 AL2 023 上的 *Python 系统*。有关更多信息，请参阅《*亚马逊 Linux 2023 用户指南》*[中的 AL2 023 年中的 P](https://docs.aws.amazon.com/linux/al2023/ug/python.html) ython。您可以在版本控制位置（例如 `/usr/bin/python3.12`）或应用程序虚拟环境 `bin` 目录（例如 `/var/app/venv/staging-LQM1lest/bin/python3`）中访问与平台使用的 Python 版本相对应的可执行文件。平台使用的是与平台分支相对应的正确 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` 配置 Gunicorn（即默认 WSGI 服务器）。

**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`。该工具有一个功能，可让您在一个要求文件中指定所有必需的包（及其版本）。有关需求文件的更多信息，请参阅 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 文档中的[生成 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 维护两个文件：
+ `Pipfile` – 此文件包含各种类型的依赖项和要求。
+ `Pipfile.lock` – 此文件包含启用确定性构建的版本快照。

您可以在开发环境中创建这些文件，并将这些文件包含在部署到 Elastic Beanstalk 的源包的顶级目录中。有关这两个文件的更多信息，请参阅[示例 Pipfile 和 Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#)。



下面的示例使用 Pipenv 来安装 Django 和 Django REST 框架。这些命令会创建 `Pipfile` 和 `Pipfile.lock` 文件。

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

 

## 优先级
<a name="python-configuration-requirements.precedence"></a>

如果您包含此主题中描述的多个要求文件，则 Elastic Beanstalk 只使用其中一个文件。下面的列表按降序顺序显示优先级。

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`。
+ 如果找不到三个需求文件中的任何一个，则将不会安装任何应用程序依赖项。

# 将 Flask 应用程序部署到 Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

本教程将引导您完成生成 Flask 应用程序并将其部署到 AWS Elastic Beanstalk 环境的过程。Flask 是一种适用于 Python 的开源 Web 应用程序框架。

在本教程中，您将执行以下操作：
+ [通过 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 环境。

为了遵循本指南中的步骤，您需要命令行终端或 Shell，以便运行命令。命令显示在列表中，以提示符（\$1）和当前目录名称（如果有）开头。

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

在 Linux 和 macOS 中，您可使用您首选的 Shell 和程序包管理器。在 Windows 上，您可以[安装适用于 Linux 的 Windows 子系统](https://docs.microsoft.com/en-us/windows/wsl/install-win10)，以获取与 Windows 集成的 Ubuntu 和 Bash 版本。

在本教程中，我们使用 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 轻松地找到您的应用程序代码。

将 `application.py` 与 Python 一起运行：

```
(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
```

在您的 Web 浏览器中打开 `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/zh_cn/elasticbeanstalk/latest/dg/images/eb_flask_test_local.png)


检查服务器日志，查看请求的输出。您可键入 **Ctrl\$1C**，停止 Web 服务器并返回到虚拟环境。

如果您看到的是调试输出，请修复错误并确保应用程序正在本地运行，然后再为 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` 中列出的库。要最大程度地减小部署期间上传的源包的大小，请添加 [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) 文件，此文件告知 EB CLI 忽略 `virt` 文件夹。

**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**再次运行以配置默认密钥对，这样您就可以通过 SSH 连接到运行应用程序的 EC2 实例：

   ```
   ~/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 ]
   ```

   如果您已有密钥对，请选择一个密钥对，或按提示创建新密钥对。如果您没有看到提示或需要以后更改设置，请运行 **eb init -i**。

1. 使用 **eb create** 创建环境并将应用程序部署到此环境中：

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

环境创建大约需要 5 分钟，将创建以下资源：
+ **EC2 实例** — 配置为在您选择的平台上运行 Web 应用程序的亚马逊弹性计算云 (Amazon EC2) 虚拟机。

  各平台运行一组特定软件、配置文件和脚本以支持特定的语言版本、框架、Web 容器或其组合。大多数平台使用 Apache 或 NGINX 作为 Web 应用程序前的反向代理，向其转发请求、提供静态资产以及生成访问和错误日志。
+ **实例安全组** — 配置为允许端口 80 上的入站流量的 Amazon EC2 安全组。此资源允许来自负载均衡器的 HTTP 流量到达运行您的 Web 应用程序的 EC2 实例。默认情况下，其他端口不允许流量进入。
+ **负载均衡器** – 配置为向运行您的应用程序的实例分配请求的 Elastic Load Balancing 负载均衡器。负载均衡器还使您无需将实例直接公开在 Internet 上。
+ **负载均衡器安全组**-配置为允许端口 80 上的入站流量的 Amazon EC2 安全组。利用此资源，HTTP 流量可从 Internet 到达负载均衡器。默认情况下，其他端口不允许流量进入。
+ **Auto Scaling 组** – 配置为在实例终止或不可用时替换实例的 Auto Scaling 组。
+ **Amazon S3 存储桶** – 使用 Elastic Beanstalk 时创建的源代码、日志和其他构件的存储位置。
+ **Amazon CloudWatch CloudWatch 警**报 — 两个警报，用于监控环境中实例的负载，并在负载过高或过低时触发。警报触发后，您的 Auto Scaling 组会扩展或收缩以进行响应。
+ **CloudFormation 堆栈** — Elastic CloudFormation Beanstalk 用于在您的环境中启动资源并传播配置更改。这些资源在您可通过 [CloudFormation 控制台](https://console.aws.amazon.com/cloudformation)查看的模板中定义。
+ **域名**-以表单形式路由到您的 Web 应用程序的域名**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 存储桶将在多个环境之间共享并且在环境终止期间不会被删除。有关更多信息，请参阅 [将 Elastic Beanstalk 和 Amazon S3 结合使用](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/zh_cn/elasticbeanstalk/latest/dg/images/eb_flask_deployed.png)


如果您没有看到应用程序运行，或者出现错误消息，请查看[排查部署问题](troubleshooting.md#troubleshooting-deployments)以获取有关如何确定错误原因的帮助。

如果您*确实* 看到应用程序在运行，那么恭喜，您已使用 Elastic Beanstalk 部署了第一个 Flask 应用程序！

## 清理
<a name="python-flask-tutorial-cleanup"></a>

演示代码使用完毕后，您可以终止环境。[Elastic Beanstalk 会删除 AWS 所有相关资源，[例如 EC2 亚马逊](using-features.managing.ec2.md)[实例、数据库实例、](using-features.managing.db.md)负载均衡器[、安全组](using-features.managing.elb.md)和警报。](using-features.alarms.md#using-features.alarms.title)

移除资源不会删除 Elastic Beanstalk 应用程序，因此您可以随时为您的应用程序创建新环境。

**从控制台终止 Elastic Beanstalk 环境**

1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域

1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。

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 Web 框架，请参阅[将 Django 应用程序部署到 Elastic Beanstalk](create-deploy-python-django.md)。

# 将 Django 应用程序部署到 Elastic Beanstalk
<a name="create-deploy-python-django"></a>

本教程演练如何将默认的自动生成的 [Django](https://www.djangoproject.com/) 网站部署到运行 Python 的 AWS Elastic Beanstalk 环境。本教程向您展示如何通过使用 Elastic Beanstalk 环境在云中托管 Python Web 应用程序。

在本教程中，您将执行以下操作：
+ [设置 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 CLI 会尝试在您运行 `eb create` 时创建一个。

## 设置 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>`，你*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 的版本兼容性问题，请参阅[我可以将哪个 Python 版本与 Django 一起使用？](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 项目并在计算机上运行。

**注意**  
本教程使用 SQLite的是 Python 中包含的数据库引擎。使用您的项目文件部署数据库。对于生产环境，我们建议您使用 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>`，这些*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. 在 Web 浏览器中，打开 `http://127.0.0.1:8000/` 以查看站点。

1. 检查服务器日志，查看请求的输出。要停止 Web 服务器并返回到虚拟环境，请按 **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 `requirements.txt` Beanstalk 用于确定要在运行您的应用程序的实例 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`。示例中的值适用于 Gunicorn WSGI 服务器，该服务器在 Amazon Linux AMI 平台版本上不受支持。

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`。然后，您将重新部署您的应用程序。这是一个 Django 安全要求，旨在防止 HTTP `Host` 标头攻击。有关更多信息，请参阅[主机标头验证](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**再次运行以配置默认密钥对，以便您可以使用 SSH 连接到运行应用程序的 EC2 实例。

   ```
   ~/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 ]
   ```

   如果您已有密钥对，请选择一个，或按提示创建一个。如果您没有看到提示或需要以后更改设置，请运行 **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. 打开 `settings.py` 目录中的 `ebdjango` 文件。找到 `ALLOWED_HOSTS` 设置，然后将您在上一步中找到的应用程序域名添加到该设置的值。如果您在该文件中找不到此设置，请将此设置添加到一个新行。

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

1. 部署该文件，然后通过运行 **eb deploy** 部署您的应用程序。运行 **eb deploy** 时，EB CLI 会捆绑项目目录中的内容并将其部署到环境中。

   ```
   ~/ebdjango$ eb deploy
   ```
**注意**  
如果您将 Git 用于您的项目，请参阅[将 EB CLI 与 Git 配合使用](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/ .py ebdjango/ebdjango/settings**  

   ```
   ...
   # 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 在哪里存储静态文件，请在 `settings.py` 中定义 `STATIC_ROOT`。  
**Example \$1/ .py ebdjango/ebdjango/settings**  

   ```
   # 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. 在您的浏览器中打开站点，并且将 `/admin/` 附加到站点 URL，以此查看管理控制台，如下所示。

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[输入您在步骤 2 中创建的用户名和密码来登录管理控制台。\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. 使用您在步骤 2 中配置的用户名和密码登录。  
![\[使用 Elastic Beanstalk 部署的 Django 网站的 Django 管理控制台\]](http://docs.aws.amazon.com/zh_cn/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

你可以使用类似的本地程序， updating/testing 然后使用**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. 部署您的应用程序。

   ```
   ~/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 Web 框架，请参阅[将 Flask 应用程序部署到 Elastic Beanstalk](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）数据库实例来存储由应用程序收集和修改的数据。数据库可以耦合到您的环境并由 Elastic Beanstalk 进行管理，也可以被创建为解耦数据库并由另一项服务进行外部管理。在这些说明中，数据库与您的环境耦合并由 Elastic Beanstalk 管理。有关将 Amazon RDS 与 Elastic Beanstalk 集成的更多信息，请参阅 [将数据库添加到 Elastic Beanstalk 环境](using-features.managing.db.md)。

**Topics**
+ [向环境中添加数据库实例](#python-rds-create)
+ [下载驱动程序](#python-rds-drivers)
+ [连接到数据库](#python-rds-connect)

## 向环境中添加数据库实例
<a name="python-rds-create"></a>

**向环境添加数据库实例**

1. 打开 [Elastic Beanstalk](https://console.aws.amazon.com/elasticbeanstalk) 控制台，然后**在 “区域” 列表中，选择您**的。 AWS 区域

1. 在导航窗格中，选择 **Environments**（环境），然后从列表中选择环境的名称。

1. 在导航窗格中，选择 **Configuration (配置)**。

1. 在 **Database**（数据库）配置类别中，选择 **Edit**（编辑）。

1. 选择数据库引擎，然后输入用户名和密码。

1. 要保存更改，请选择页面底部的 **Apply**（应用）。

添加一个数据库实例大约需要 10 分钟。环境更新完成后，您的应用程序就可以通过以下环境属性访问数据库实例的主机名和其他连接信息：


| 属性名称 | 描述 | 属性值 | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  数据库实例的主机名。  |  在 Amazon RDS 控制台的 **Connectivity & security**（连接和安全）选项卡上：**Endpoint**（端点）。  | 
|  `RDS_PORT`  |  数据库实例接受连接的端口。默认值因数据库引擎而异。  |  在 Amazon RDS 控制台的 **Connectivity & security**（连接和安全）选项卡上：**Port**（端口）。  | 
|  `RDS_DB_NAME`  |  数据库名称 **ebdb**。  |  在 Amazon RDS 控制台的 **Configuration**（配置）选项卡上：**DB Name**（数据库名称）。  | 
|  `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 - 使用 MySQL 的 Django**  

```
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-支持的数据库](https://docs.djangoproject.com/en/2.2/ref/databases)。

## 连接到数据库
<a name="python-rds-connect"></a>

Elastic Beanstalk 在环境属性中提供所连数据库实例的连接信息。使用 `os.environ['VARIABLE']` 可读取这些属性并配置数据库连接。

**Example Django 设置文件 - 数据库词典**  

```
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 应用程序时，您可以在多个地方获取额外的帮助：


****  

| 资源 | 说明 | 
| --- | --- | 
| [适用于 Python (Boto3) 的 AWS SDK on GitHub](https://github.com/boto/boto3) | 安装源自的 Boto3。 GitHub | 
| [适用于 Python (Boto3) 的 AWS SDK 主页](https://aws.amazon.com//sdk-for-python/) |  适用于 Python (Boto3) 的 AWS SDK 主页。 | 
| [Python 开发者中心](https://aws.amazon.com/python/) | 示例代码、文档、工具和其他资源的一站式商店。 |