As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Usar a plataforma Python do Elastic Beanstalk
Este tópico descreve como configurar, criar e executar suas aplicações Python no Elastic Beanstalk.
AWS Elastic Beanstalk suporta várias ramificações de plataforma para diferentes versões da linguagem de programação Python. Consulte [Python](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) no documento *Plataformas do AWS Elastic Beanstalk * para uma lista completa.
As aplicações Web Python podem ser executadas por trás de um servidor proxy com WSGI. O Elastic Beanstalk fornece o [Gunicorn](https://gunicorn.org/) como o servidor WSGI padrão.
Você pode adicionar um `Procfile` ao seu pacote de origem para especificar e configurar o servidor WSGI para sua aplicação. Para obter detalhes, consulte [Configuração do servidor WSGI com um Procfile no Elastic Beanstalk](python-configuration-procfile.md).
Você pode usar os arquivos `Pipfile.lock` e `Pipfile` criados pelo Pipenv para especificar dependências de pacotes Python e outros requisitos. Para obter detalhes sobre como especificar dependências, consulte [Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk](python-configuration-requirements.md).
O Elastic [Beanstalk fornece](command-options.md) opções de configuração que você pode usar para personalizar o software executado EC2 nas instâncias do seu ambiente do Elastic Beanstalk. Você pode configurar variáveis de ambiente necessárias à aplicação, habilitar a alternância de logs para o Amazon S3 e mapear pastas da origem da aplicação que contenham arquivos estáticos para caminhos atendidos pelo servidor de proxy.
As opções de configuração estão disponíveis no console do Elastic Beanstalk para [modificar a configuração de um ambiente em execução](environment-configuration-methods-after.md). Para evitar a perda da configuração do ambiente quando você terminá-la, você pode usar [configurações salvas](environment-configuration-savedconfig.md) para salvar as configurações e depois aplicá-las a outro ambiente.
Para salvar as configurações no código-fonte, você pode incluir [arquivos de configuração](ebextensions.md). As definições em arquivos de configuração são aplicadas sempre que você cria um ambiente ou implementa a aplicação. Você também pode usar arquivos de configuração para instalar pacotes, executar scripts e realizar outras operações de personalização da instância em implantações.
As configurações aplicadas no console do Elastic Beanstalk substituem as mesmas configurações em arquivos de configuração, caso elas existam. Isso permite que você tenha configurações padrão em arquivos de configuração e as substitua por configurações específicas de ambiente no console. Para obter mais informações sobre precedência e outros métodos de alteração das configurações, consulte [Opções de configuração](command-options.md).
Para os pacotes do Python disponíveis no `pip`, você também pode incluir um arquivo de requisitos na raiz do código-fonte da aplicação. O Elastic Beanstalk instala todos os pacotes de dependência especificados em um arquivo de requisitos durante a implantação. Para obter detalhes, consulte [Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk](python-configuration-requirements.md).
Para obter detalhes sobre as várias maneiras de estender uma plataforma do Elastic Beanstalk baseada em Linux, consulte [Estender as plataformas Linux do Elastic Beanstalk](platforms-linux-extend.md).
## Configurar o ambiente Python
As configurações da plataforma Python permitem que você ajuste o comportamento de suas instâncias da Amazon. EC2 Você pode editar a configuração da instância Amazon do ambiente do Elastic Beanstalk usando o console EC2 do Elastic Beanstalk.
Use o console do Elastic Beanstalk para definir AWS X-Ray as configurações de processo do Python, habilitar, habilitar a rotação de logs para o Amazon S3 e configurar variáveis que seu aplicativo possa ler do ambiente.
**Como configurar o ambiente Python no console do Elastic Beanstalk**
1. Abra o console do [Elastic](https://console.aws.amazon.com/elasticbeanstalk) Beanstalk e, **na** lista Regiões, selecione sua. Região da AWS
1. No painel de navegação, selecione **Ambientes** e selecione o nome do ambiente na lista.
1. No painel de navegação, escolha **Configuration (Configuração)**.
1. Na categoria de configuração **Updates, monitoring, and logging (Atualizações, monitoramento e logs)**, escolha **Edit (Editar)**.
### Configurações do Python
+ **Proxy server (Servidor de proxy)**: o servidor de proxy a ser usado nas instâncias de ambiente. Por padrão, é usado nginx.
+ **WSGI Path (Caminho do WSGI)**: o nome ou o caminho para o arquivo de aplicação principal. Por exemplo, `application.py` ou `django/wsgi.py`.
+ **NumProcesses**— O número de processos a serem executados em cada instância do aplicativo.
+ **NumThreads**— O número de threads a serem executados em cada processo.
### AWS X-Ray configurações
+ **Daemon X-Ray** — Execute o AWS X-Ray daemon para processar dados de rastreamento do. [AWS X-Ray SDK for Python](https://docs.aws.amazon.com/xray/latest/devguide/xray-sdk-python.html)
### Opções de log
A seção Log Options tem duas configurações:
+ **Instance profile (Perfil da instância)**: especifica o perfil da instância que tem permissão para acessar o bucket do Amazon S3 associado à sua aplicação.
+ **Habilitar a rotação de arquivos de log para o Amazon S3** — Especifica se os arquivos de log das EC2 instâncias da Amazon do seu aplicativo são copiados para o bucket do Amazon S3 associado ao seu aplicativo.
### Arquivos estáticos
Para melhorar a performance, você pode usar a seção **Static files** (Arquivos estáticos) para configurar o servidor proxy para servir arquivos estáticos (por exemplo, HTML ou imagens) de um conjunto de diretórios dentro da aplicação Web. Defina, para cada diretório, o caminho virtual para mapeamento de diretórios. Quando o servidor de proxy recebe uma solicitação para um arquivo no caminho especificado, ele atende o arquivo diretamente em vez de rotear solicitação para seu aplicativo.
Para ver detalhes sobre como configurar arquivos estáticos usando arquivos de configuração ou o console do Elastic Beanstalk, consulte [Fornecer arquivos estáticos](environment-cfg-staticfiles.md).
Por padrão, o servidor de proxy em um ambiente Python atende todos os arquivos de uma pasta chamada `static` no caminho `/static`. Por exemplo, se a origem do aplicativo contiver um arquivo chamado `logo.png` em uma pasta chamada `static`, o servidor de proxy o servirá para os usuários em `subdomain.elasticbeanstalk.com/static/logo.png`. Você pode configurar mapeamentos adicionais conforme explicado nesta seção.
### Propriedades de ambiente
Você pode usar as propriedades de ambiente para fornecer informações ao aplicativo e configurar variáveis de ambiente. Por exemplo, crie uma propriedade de ambiente chamada `CONNECTION_STRING` que especifica uma string de conexão que o aplicativo pode usar para se conectar a um banco de dados.
No ambiente do Python em execução no Elastic Beanstalk, esses valores podem ser acessados usando o dicionário do Python `os.environ`. Para obter mais informações, consulte [http://docs.python. org/library/os.html](http://docs.python.org/library/os.html).
Você pode usar um código semelhante ao mostrado abaixo para acessar as chaves e os parâmetros:
```
import os
endpoint = os.environ['API_ENDPOINT']
```
As propriedades de ambiente também podem fornecer informações para uma framework. Por exemplo, crie uma propriedade chamada `DJANGO_SETTINGS_MODULE` para configurar o Django a usar um módulo de configurações específicas. Dependendo do ambiente, o valor pode ser `development.settings`, `production.settings` etc.
Consulte [Variáveis de ambiente e outras configurações de software](environments-cfg-softwaresettings.md) para obter mais informações.
## Namespaces de configuração do Python
Você pode usar um [arquivo de configuração](ebextensions.md) para definir opções de configuração e executar outras tarefas de configuração de instância durante implantações. Opções de configuração podem ser [específicas da plataforma](command-options-specific.md) ou aplicáveis a [todas as plataformas](command-options-general.md) no serviço Elastic Beanstalk como um todo. As opções de configuração são organizadas em *namespaces*.
A plataforma Python define opções nos namespaces `aws:elasticbeanstalk:environment:proxy`, `aws:elasticbeanstalk:environment:proxy:staticfiles` e `aws:elasticbeanstalk:container:python`.
O arquivo de configuração de exemplo a seguir especifica as definições da opção de configuração para criar uma propriedade de ambiente chamada `DJANGO_SETTINGS_MODULE`, selecionar o servidor de proxy Apache, especificar duas opções de arquivos estáticos que mapeiam um diretório chamado `statichtml` para o caminho `/html` e um diretório chamado `staticimages` para o caminho `/images` e especificar configurações adicionais no namespace `[aws:elasticbeanstalk:container:python](command-options-specific.md#command-options-python)`. Esse namespace contém opções que permitem especificar a localização do script de WSGI no código-fonte e o número de threads e processos para executar no 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
```
**Observações**
Se você estiver usando uma versão de plataforma Python da AMI do Amazon Linux (anterior ao Amazon Linux 2), substitua o valor `WSGIPath` por `ebdjango/wsgi.py`. O valor no exemplo funciona com o servidor WSGI do Gunicorn, que não é mais compatível nas versões da plataforma da AMI do Amazon Linux.
Além disso, essas versões de plataforma mais antigas usam um namespace diferente para configurar arquivos estáticos: `aws:elasticbeanstalk:container:python:staticfiles`. Ele tem os mesmos nomes de opção e semântica que o namespace de arquivo estático padrão.
Os arquivos de configuração também são compatíveis com várias chaves para [modificar mais o software nas instâncias do ambiente](customize-containers-ec2.md). Este exemplo usa a chave dos [pacotes](customize-containers-ec2.md#linux-packages) para instalar o Memcached com `yum` e [comandos do contêiner](customize-containers-ec2.md#linux-container-commands) para executar comandos que configuram o servidor durante a implantação:
```
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"
```
O Elastic Beanstalk oferece muitas opções de configuração para personalizar o ambiente. Além de arquivos de configuração, você também pode definir opções de configuração usando o console, configurações salvas, a EB CLI ou a AWS CLI. Consulte [Opções de configuração](command-options.md) para obter mais informações.
## O executável `python3`
A versão do `python3` executável disponível em EC2 instâncias nos ambientes Python do Elastic Beanstalk nem sempre corresponderá à mesma versão do Python usada pela plataforma. Por exemplo, na plataforma Python 3.12 AL2 023, aponta `/usr/bin/python3` para Python 3.9. Isso ocorre porque o Python 3.9 é o sistema *Python* em 023. AL2 Para obter mais informações, consulte [Python em AL2 023 no Guia](https://docs.aws.amazon.com/linux/al2023/ug/python.html) do usuário do *Amazon Linux 2023*. Você pode acessar um executável correspondente à versão do Python usada pela plataforma em um local de com versionamento (por exemplo, `/usr/bin/python3.12`) ou no diretório do `bin` do ambiente virtual da aplicação (por exemplo, `/var/app/venv/staging-LQM1lest/bin/python3`). A plataforma usa o executável correto do Python que corresponde à ramificação da plataforma.
# Configuração do servidor WSGI com um Procfile no Elastic Beanstalk
Você pode adicionar um [`Procfile`](platforms-linux-extend.build-proc.md#platforms-linux-extend.proc) ao seu pacote de origem para especificar e configurar o servidor WSGI para sua aplicação. É possível especificar comandos personalizados de inicialização e execução no `Procfile`.
Quando você usa um `Procfile`, ele substitui as opções de namespace `aws:elasticbeanstalk:container:python` definidas usando arquivos de configuração.
O exemplo a seguir usa um `Procfile` para especificar uWSGI como o servidor e configurá-lo.
**Example Procfile**
```
web: uwsgi --http :8000 --wsgi-file application.py --master --processes 4 --threads 2
```
O exemplo a seguir usa um `Procfile` para configurar o Gunicorn, o servidor WSGI padrão.
**Example Procfile**
```
web: gunicorn --bind :8000 --workers 3 --threads 2 project.wsgi:application
```
**Observações**
Se você configurar qualquer servidor WSGI que não seja Gunicorn, certifique-se de também especificá-lo como uma dependência do seu aplicativo, para que ele seja instalado em suas instâncias de ambiente. Para obter detalhes sobre a especificação de dependência, consulte [Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk](python-configuration-requirements.md).
A porta padrão para o servidor WSGI é 8000. Se você especificar um número de porta diferente no comando `Procfile`, defina a [propriedade do ambiente](environments-cfg-softwaresettings.md) `PORT` para esse número de porta também.
# Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk
Este tópico descreve como configurar sua aplicação para instalar outros pacotes Python necessários. Um aplicativo em Python típico tem dependências em outros pacotes Python de terceiros. Com a plataforma Python do Elastic Beanstalk, você tem várias maneiras de especificar pacotes Python dos quais sua aplicação depende.
## Utilizar `pip` e `requirements.txt`
A ferramenta padrão para instalar pacotes Python é `pip`. Ele tem um recurso que permite especificar todos os pacotes necessários (e suas versões) em um único arquivo de requisitos. Para obter mais informações sobre o arquivo de requisitos, consulte [Formato do arquivo de requisitos](https://pip.pypa.io/en/latest/reference/requirements-file-format/#requirements-file-format) no site de documentação do pip.
Crie um arquivo chamado `requirements.txt` e coloque-o no diretório de nível superior do pacote de origem. Veja a seguir um exemplo do arquivo `requirements.txt` para Django.
```
Django==2.2
mysqlclient==2.0.3
```
Em seu ambiente de desenvolvimento, use o comando `pip freeze` para gerar o arquivo de requisitos.
```
~/my-app$ pip freeze > requirements.txt
```
Para garantir que o arquivo de requisitos contenha apenas os pacotes realmente usados pelo aplicativo, use um [ambiente virtual](python-development-environment.md#python-common-setup-venv) que tenha somente esses pacotes instalados. Fora de um ambiente virtual, a saída de `pip freeze` incluirá todos os pacotes do `pip` instalados na máquina de desenvolvimento, bem como aqueles que acompanham o sistema operacional.
**nota**
Nas versões da plataforma Python da AMI do Amazon Linux, o Elastic Beanstalk não é compatível com Pipenv nem Pipfiles. Se você usar Pipenv para gerenciar as dependências do aplicativo, execute o seguinte comando para gerar um arquivo `requirements.txt`.
```
~/my-app$ pipenv lock -r > requirements.txt
```
Para saber mais, consulte [Gerar um requirements.txt](https://pipenv.readthedocs.io/en/latest/advanced/#generating-a-requirements-txt) na documentação do Pipenv.
## Usar Pipenv e `Pipfile`
Pipenv é uma ferramenta moderna de empacotamento Python. Ele combina a instalação do pacote com a criação e gerenciamento de um arquivo de dependência e um virtualenv para o seu aplicativo. Para obter mais informações, consulte [Pipenv: Python Dev Workflow for Humans](https://pipenv.readthedocs.io/en/latest/).
O Pipenv mantém dois arquivos:
+ `Pipfile` — Esse arquivo contém vários tipos de dependências e requisitos.
+ `Pipfile.lock` — Esse arquivo contém um instantâneo da versão que permite compilações determinísticas.
Você pode criar esses arquivos em seu ambiente de desenvolvimento e incluí-los no diretório de nível superior do pacote de origem implantado no Elastic Beanstalk. Para obter mais informações sobre esses dois arquivos, consulte [Exemplo de Pipfile e Pipfile.lock](https://pipenv.pypa.io/en/latest/basics/#).
O exemplo a seguir usa o Pipenv para instalar o Django e a framework REST do Django. Esses comandos criam os arquivos `Pipfile` e `Pipfile.lock`.
```
~/my-app$ pipenv install django
~/my-app$ pipenv install djangorestframework
```
## Precedência
Se você incluir mais de um dos arquivos de requisitos descritos neste tópico, o Elastic Beanstalk usará apenas um deles. A lista a seguir mostra a precedência, em ordem decrescente.
1. `requirements.txt`
1. `Pipfile.lock`
1. `Pipfile`
**nota**
A partir da versão da plataforma Amazon Linux 2 de 7 de março de 2023, se você fornecer mais de um desses arquivos, o Elastic Beanstalk emitirá uma mensagem do console informando qual dos arquivos de dependência foi usado durante uma implantação.
As etapas a seguir descrevem a lógica que o Elastic Beanstalk segue para instalar as dependências ao implantar uma instância.
+ Se houver um arquivo `requirements.txt`, usamos o comando `pip install -r requirements.txt`.
+ A partir do lançamento da plataforma Amazon Linux 2 em 7 de março de 2023, se não houver nenhum arquivo `requirements.txt`, mas houver um `Pipfile.lock`, usamos o comando `pipenv sync`. Antes desse lançamento, usamos `pipenv install --ignore-pipfile`.
+ Se não houver um arquivo `requirements.txt` nem um `Pipfile.lock`, mas houver um `Pipfile`, usamos o comando `pipenv install --skip-lock`.
+ Se nenhum dos três arquivos de requisitos for encontrado, não instalaremos nenhuma dependência do aplicativo.