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á.

# Implantação de aplicações Python com o Elastic Beanstalk
<a name="create-deploy-python-apps"></a>

Este capítulo fornece instruções para configurar e implantar seu aplicativo web Python no. AWS Elastic Beanstalk O Elastic Beanstalk facilita a implantação, o gerenciamento e o dimensionamento das suas aplicações Web Python usando a Amazon Web Services.

Você pode implantar sua aplicação em apenas alguns minutos usando a Interface de Linha de Comando (EB CLI) do Elastic Beanstalk ou o console do Elastic Beanstalk. Depois de implantar seu aplicativo Elastic Beanstalk, você pode continuar usando o EB CLI para gerenciar seu aplicativo e ambiente, ou você pode usar o console do Elastic Beanstalk, ou o. AWS CLI APIs

Siga as etapas em [QuickStart para Python](python-quickstart.md) para step-by-step obter instruções sobre como criar e implantar um aplicativo web Python *Hello World* com a CLI do EB.

**Topics**
+ [QuickStart: implante um aplicativo Python no Elastic Beanstalk](python-quickstart.md)
+ [Configurar seu ambiente de desenvolvimento Python para o Elastic Beanstalk](python-development-environment.md)
+ [Usar a plataforma Python do Elastic Beanstalk](create-deploy-python-container.md)
+ [Implantar uma aplicação Flask no Elastic Beanstalk](create-deploy-python-flask.md)
+ [Implantar uma aplicação Django no Elastic Beanstalk](create-deploy-python-django.md)
+ [Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente Python Elastic Beanstalk](create-deploy-python-rds.md)
+ [Ferramentas e recursos do Python](create-deploy-python-tools-resources.md)

# QuickStart: implante um aplicativo Python no Elastic Beanstalk
<a name="python-quickstart"></a>

Este QuickStart tutorial mostra o processo de criação de um aplicativo Python e sua implantação em um ambiente. AWS Elastic Beanstalk 

**Não é para uso em produção**  
Os exemplos são destinados apenas para demonstração. Não use aplicações de exemplo na produção.

**Topics**
+ [Sua AWS conta](#python-quickstart-aws-account)
+ [Pré-requisitos](#python-quickstart-prereq)
+ [Etapa 1: criar uma aplicação Python](#python-quickstart-create-app)
+ [Etapa 2: executar a aplicação localmente](#python-quickstart-run-local)
+ [Etapa 3: implantar sua aplicação Python com a EB CLI](#python-quickstart-deploy)
+ [Etapa 4: executar a aplicação no Elastic Beanstalk](#python-quickstart-run-eb-ap)
+ [Etapa 5: limpar](#go-tutorial-cleanup)
+ [AWS recursos para seu aplicativo](#python-quickstart-eb-resources)
+ [Próximas etapas](#python-quickstart-next-steps)
+ [Implantar com o console do Elastic Beanstalk](#python-quickstart-console)

## Sua AWS conta
<a name="python-quickstart-aws-account"></a>

Se você ainda não é AWS cliente, precisa criar uma AWS conta. A inscrição permite que você acesse o Elastic Beanstalk AWS e outros serviços necessários.

Se você já tem uma AWS conta, você pode passar para[Pré-requisitos](#python-quickstart-prereq).

### Crie uma AWS conta
<a name="python-quickstart-aws-account-procedure"></a>

#### Inscreva-se para um Conta da AWS
<a name="sign-up-for-aws"></a>

Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um.

**Para se inscrever em um Conta da AWS**

1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup)

1. Siga as instruções online.

   Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone.

   Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**.

#### Criar um usuário com acesso administrativo
<a name="create-an-admin"></a>

Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias.

**Proteja seu Usuário raiz da conta da AWS**

1.  Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha.

   Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *.

1. Habilite a autenticação multifator (MFA) para o usuário-raiz.

   Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*.

**Criar um usuário com acesso administrativo**

1. Habilita o Centro de Identidade do IAM.

   Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário.

   Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*.

**Iniciar sessão como o usuário com acesso administrativo**
+ Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado.

  Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*.

**Atribuir acesso a usuários adicionais**

1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo.

   Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo.

   Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.

## Pré-requisitos
<a name="python-quickstart-prereq"></a>

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Nas listagens, os comandos são mostrados precedidos por um símbolo de prompt (\$1) e pelo nome do diretório atual, quando apropriado.

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

No Linux e no macOS, você pode usar seu gerenciador de pacotes e de shell preferido. No Windows, você pode [instalar o subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obter uma versão do Ubuntu e Bash integrada ao Windows.

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

Este tutorial também usa a Interface de Linhas de Comando do Elastic Beanstalk (CLI do EB). Para obter detalhes sobre a instalação e configuração da CLI do EB, consulte [Instalar a EB CLI com script de configuração (recomendado)](eb-cli3.md#eb-cli3-install) e [Configurar a EB CLI](eb-cli3-configuration.md).

### Framework Python e Flask
<a name="python-quickstart-prereq.runtime"></a>

Confirme que você tem uma versão funcional do Python com o `pip` instalado, executando os seguintes comandos.

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

Se algum dos comandos anteriores retornar "*Python não encontrado*", execute os seguintes comandos que usam `python` em vez de `python3`. A configuração de aliases e links simbólicos pode variar de acordo com o sistema operacional e as personalizações individuais, portanto, o comando `python3` pode não funcionar no seu computador.

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

Se você não tiver o Python instalado no computador local, poderá baixá-lo na página de [downloads do Python](https://www.python.org/downloads/) no site do Python. Para obter uma lista das versões da linguagem Python compatíveis com o Elastic Beanstalk, consulte *Plataformas* [Python compatíveis](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python) no guia de Plataformas do AWS Elastic Beanstalk . O site de downloads do Python fornece um link para o *Guia do desenvolvedor do Python*, onde você encontrará instruções de instalação e configuração.

**nota**  
O pacote Python `pip` é incluído por padrão no Python 3.4 ou versão posterior.

Se o resultado indicar que você tem uma versão compatível do Python, mas não `pip`, consulte a página de [instalação](https://pip.pypa.io/en/stable/installation/) no site *pip.pypa.io*. Ele fornece orientação para instalar o pip em um ambiente Python que não o tenha.



Confirme se o Flask está instalado executando o seguinte comando:

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

Se o Flask não estiver instalado, você poderá instalá-lo com o seguinte comando:

```
~$ pip install Flask
```

## Etapa 1: criar uma aplicação Python
<a name="python-quickstart-create-app"></a>

Crie um diretório do projeto.

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

Crie um exemplo de "Hello Elastic Beanstalk\$1" Aplicação Python que você implantará usando o Elastic Beanstalk.

Crie um arquivo de texto `application.py` no diretório que você acabou de criar com o seguinte conteúdo.

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

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

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

Crie um arquivo de texto `requirements.txt` com a seguinte linha. Esse arquivo contém os pacotes `pip` necessários para a execução da aplicação.

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

```
Flask
```

## Etapa 2: executar a aplicação localmente
<a name="python-quickstart-run-local"></a>

Execute o seguinte comando para executar sua aplicação localmente.

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

Você deve ver saída semelhante ao seguinte

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

Navegue até `http://localhost:5000` no seu navegador da Web. O navegador deve exibir “Hello Elastic Beanstalk\$1”.

## Etapa 3: implantar sua aplicação Python com a EB CLI
<a name="python-quickstart-deploy"></a>

Execute os seguintes comandos para criar um ambiente Elastic Beanstalk para essa aplicação.

 

**Para criar um ambiente e implantar sua aplicação Python**

1. Inicialize o repositório da EB CLI com o comando **eb init**:

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

   Esse comando cria uma aplicação `python-tutorial` e configura seu repositório local para criar ambientes com a versão da plataforma Python fornecida.

1. (Opcional) Execute **eb init** novamente para configurar um par de chaves padrão para que você possa usar SSH para se conectar à instância do EC2 que está executando seu aplicativo:

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

   Selecione um par de chaves se você já tiver um, ou siga os as instruções na tela para criar um. Se nenhum prompt aparecer ou se for necessário alterar as configurações posteriormente, execute **eb init -i**.

1. Crie um ambiente e implante o aplicativo nele com **eb create**. O Elastic Beanstalk cria automaticamente um arquivo zip para a aplicação e o inicia na porta 5000.

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

   O Elastic Beanstalk leva cerca de cinco minutos para criar seu ambiente.

## Etapa 4: executar a aplicação no Elastic Beanstalk
<a name="python-quickstart-run-eb-ap"></a>

Quando o processo de criação de seu ambiente for concluído, abra seu site com **eb open**.

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

Parabéns\$1 Você implantou uma aplicação Python com o Elastic Beanstalk\$1 Isso abre uma janela do navegador usando o nome de domínio criado para o seu aplicativo.

## Etapa 5: limpar
<a name="go-tutorial-cleanup"></a>

Você pode encerrar o ambiente quando terminar de trabalhar com a aplicação. O Elastic Beanstalk AWS encerra todos os recursos associados ao seu ambiente.

Para encerrar seu ambiente do Elastic Beanstalk com a CLI do EB, execute o seguinte comando.

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

## AWS recursos para seu aplicativo
<a name="python-quickstart-eb-resources"></a>

Você acabou de criar uma aplicação de instância única. Ela serve como uma aplicação de exemplo simples com uma única instância do EC2 e, portanto, não requer balanceamento de carga ou ajuste de escala automático. Para aplicativos de instância única, o Elastic Beanstalk cria os seguintes recursos: AWS 
+ **Instância do EC2**: uma máquina virtual do Amazon EC2 configurada para executar aplicações Web na plataforma de sua escolha.

  Cada plataforma executa um conjunto diferente de software, arquivos de configuração e scripts para oferecer suporte a uma versão de linguagem, framework, contêiner da Web específicos ou a uma combinação deles. A maioria das plataformas usa o Apache ou nginx como um proxy reverso que processa tráfego da web na frente do aplicativo web, encaminha solicitações para ele, atende ativos estáticos e gera logs de acesso e de erro.
+ **Grupo de segurança de instância**: um grupo de segurança do Amazon EC2 configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP do load balancer chegue à instância do EC2 que executa seu aplicativo Web. Por padrão, o tráfego não é permitido em outras portas.
+ **Bucket do Amazon S3**: um local de armazenamento do seu código-fonte, logs e outros artefatos criados quando o Elastic Beanstalk é utilizado.
+ ** CloudWatch Alarmes da Amazon** — Dois CloudWatch alarmes que monitoram a carga nas instâncias em seu ambiente e são acionados se a carga for muito alta ou muito baixa. Quando um alarme é acionado, o seu grupo de Auto Scaling pode aumentar ou diminuir.
+ **CloudFormation stack** — O Elastic CloudFormation Beanstalk usa para lançar os recursos em seu ambiente e propagar as alterações de configuração. Os recursos são definidos em um modelo que você pode visualizar no [console do CloudFormation](https://console.aws.amazon.com/cloudformation).
+  **Nome de domínio** — Um nome de domínio que é direcionado para seu aplicativo da web no formulário **subdomain*. *region*.elasticbeanstalk.com*. 

O Elastic Beanstalk gerencia todos esses recursos. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele.

## Próximas etapas
<a name="python-quickstart-next-steps"></a>

Depois que um ambiente estiver executando um aplicativo, você poderá implantar uma nova versão do aplicativo ou um aplicativo diferente a qualquer momento. A implantação de uma nova versão do aplicativo é muito rápida, pois não é necessário provisionar ou reiniciar as instâncias do EC2. Também é possível explorar o novo ambiente usando o console do Elastic Beanstalk. Para conhecer as etapas detalhadas, consulte [Explore seu ambiente](GettingStarted.md#GettingStarted.Explore), no capítulo *Primeiros passos* deste guia.

**Explore mais tutoriais**  
Se quiser experimentar outros tutoriais com diferentes aplicações de exemplo, consulte os tutoriais a seguir:  
[Implantar uma aplicação Flask no Elastic Beanstalk](create-deploy-python-flask.md)
[Implantar uma aplicação Django no Elastic Beanstalk](create-deploy-python-django.md)

Depois de implantar um ou dois aplicações de amostra e estiver pronto para começar a desenvolver e executar aplicações Python localmente, consulte [Configurar seu ambiente de desenvolvimento Python para o Elastic Beanstalk](python-development-environment.md). 

## Implantar com o console do Elastic Beanstalk
<a name="python-quickstart-console"></a>

Você também pode usar o console do Elastic Beanstalk para iniciar a aplicação de exemplo. Para conhecer as etapas detalhadas, consulte [Criar uma aplicação de exemplo](GettingStarted.md#GettingStarted.CreateApp), no capítulo *Primeiros passos* deste guia.

# Configurar seu ambiente de desenvolvimento Python para o Elastic Beanstalk
<a name="python-development-environment"></a>

Este tópico fornece instruções para configurar um ambiente de desenvolvimento Python para testar sua aplicação localmente antes de implantá-la no AWS Elastic Beanstalk. Também faz referência a sites com instruções de instalação para ferramentas úteis.

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Nas listagens, os comandos são mostrados precedidos por um símbolo de prompt (\$1) e pelo nome do diretório atual, quando apropriado.

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

No Linux e no macOS, você pode usar seu gerenciador de pacotes e de shell preferido. No Windows, você pode [instalar o subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obter uma versão do Ubuntu e Bash integrada ao Windows.

**Topics**
+ [Pré-requisitos](#python-common-prereq)
+ [Usar um ambiente virtual](#python-common-setup-venv)
+ [Configurar um projeto Python para o Elastic Beanstalk](#python-common-configuring)

## Pré-requisitos
<a name="python-common-prereq"></a>

A lista a seguir fornece os pré-requisitos comuns para trabalhar com o Elastic Beanstalk e suas aplicações Python:
+ **Linguagem Python**: instale a versão da linguagem Python que está incluída na versão da plataforma Python do Elastic Beanstalk escolhida. Para obter uma lista de nossas versões de linguagem Python compatíveis, consulte [Plataformas Python compatíveis](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.python), no guia de *Plataformas do AWS Elastic Beanstalk *. Se você ainda não tiver o Python configurado na máquina de desenvolvimento, consulte a página de [downloads do Python](https://www.python.org/downloads/) no site do Python.
+ **Utilitário `pip`**: o utilitário `pip` é o instalador de pacotes do Python. Ele instala e lista as dependências do seu projeto, para que o Elastic Beanstalk saiba como configurar o ambiente da aplicação. Para obter mais informações sobre `pip`, consulte a [página do pip](https://pip.pypa.io/en/stable/) no site *pip.pypa.io*.
+ **(Opcional) A interface de linha de comando do Elastic Beanstalk (EB CLI)**: a [EB CLI](eb-cli3.md) pode empacotar sua aplicação com os arquivos de implantação necessários. Ela também pode criar um ambiente Elastic Beanstalk e implantar sua aplicação nele. Você também pode fazer implantações por meio do console do Elastic Beanstalk e, portanto, a EB CLI não é estritamente necessária.
+ **Uma instalação funcional do `SSH`**: você pode se conectar a instâncias em execução com o protocolo SSH para examinar ou depurar uma implementação.
+ **Pacote `virtualenv`**: essa ferramenta `virtualenv` cria um ambiente de desenvolvimento e teste para sua aplicação. O Elastic Beanstalk pode replicar esse ambiente sem instalar pacotes extras que não são necessários para a aplicação. Para obter mais informações, consulte o site [virtualenv](https://virtualenv.pypa.io/en/latest/). Depois de instalar o Python, você pode instalar o pacote `virtualenv` com o seguinte comando:

  ```
  $ pip install virtualenv
  ```

## Usar um ambiente virtual
<a name="python-common-setup-venv"></a>

Quando você tiver os pré-requisitos instalados, configure um ambiente virtual com `virtualenv` para instalar as dependências de seu aplicativo. Ao usar um ambiente virtual, você pode discernir exatamente quais pacotes são necessários para seu aplicativo, de modo que os pacotes necessários sejam instalados nas EC2 instâncias que estão executando seu aplicativo.

**Para configurar um ambiente virtual**

1. Abra uma janela de linha de comando e digite:

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

   *eb\$1python\$1app*Substitua por um nome que faça sentido para seu aplicativo (usar o nome do seu aplicativo é uma boa ideia). O comando `virtualenv` cria um ambiente virtual para você no diretório especificado e imprime os resultados de suas ações:

   ```
   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. Quando seu ambiente virtual estiver pronto, inicie-o executando o script `activate` localizado no diretório `bin` do ambiente. Por exemplo, para iniciar o ambiente **eb\$1python\$1app** criado na etapa anterior, você digita:

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

   O ambiente virtual imprime o nome dele (por exemplo: `(eb_python_app)`) no início de cada prompt de comando, lembrando que você está em um ambiente Python virtual.

1. Para parar de usar seu ambiente virtual e voltar ao interpretador Python padrão do sistema com todas as bibliotecas instaladas, execute o comando `deactivate`.

   ```
   (eb_python_app) $ deactivate
   ```

**nota**  
Após a criação, você poderá reiniciar o ambiente virtual a qualquer momento executando o script `activate` novamente.

## Configurar um projeto Python para o Elastic Beanstalk
<a name="python-common-configuring"></a>

É possível usar a CLI do Elastic Beanstalk para preparar as aplicações Python para implantação com o Elastic Beanstalk.

**Como configurar uma aplicação Python para implantação com o Elastic Beanstalk**

1. Em seu [ambiente virtual](#python-common-setup-venv), volte para a parte superior da árvore de diretórios do projeto (`python_eb_app`) e digite:

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

   Este comando copia os nomes e versões dos pacotes que estão instalados em seu ambiente virtual para `requirements.txt`, Por exemplo, se o pacote *PyYAML*, versão *3.11* estiver instalado em seu ambiente virtual, o arquivo conterá a linha:

   ```
   PyYAML==3.11
   ```

   Dessa forma, o Elastic Beanstalk pode replicar o ambiente Python da aplicação usando os mesmos pacotes e as mesmas versões que você usou para desenvolver e testar a aplicação.

1. Configure o repositório da EB CLI com o comando **eb init**. Siga os prompts para escolher a região, a plataforma e outras opções.

Por padrão, o Elastic Beanstalk procura um arquivo chamado `application.py` para iniciar a aplicação. Se ele não existir no projeto Python que você criou, alguns ajustes no ambiente do seu aplicativo serão necessários. Você também precisará definir variáveis de ambiente para que os módulos do aplicativo possam ser carregados. Consulte [Usar a plataforma Python do Elastic Beanstalk](create-deploy-python-container.md) para obter mais informações.

# Usar a plataforma Python do Elastic Beanstalk
<a name="create-deploy-python-container"></a>

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
<a name="create-deploy-python-container-console"></a>

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
<a name="python-console-settings"></a>
+ **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
<a name="python-console-xray"></a>
+ **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 name="create-deploy-python-container.console.logoptions"></a>

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
<a name="python-platform-staticfiles"></a>

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
<a name="create-deploy-python-custom-container-envprop"></a>

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
<a name="python-namespaces"></a>

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 name="python3-executable"></a>

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
<a name="python-configuration-procfile"></a>

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
<a name="python-configuration-requirements"></a>

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 name="python-configuration-requirements.txt"></a>

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`
<a name="python-configuration-requirements.pipenv"></a>

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
<a name="python-configuration-requirements.precedence"></a>

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.

# Implantar uma aplicação Flask no Elastic Beanstalk
<a name="create-deploy-python-flask"></a>

Este tutorial mostra o processo de geração de um aplicativo Flask e sua implantação em um AWS Elastic Beanstalk ambiente. O Flask é uma framework de aplicativo web de código aberto para Python. 

Neste tutorial, você fará o seguinte:
+ [Configurar um ambiente Python virtual com Flask](#python-flask-setup-venv)
+ [Criar uma aplicação Flask](#python-flask-create-app)
+ [Implantar o site com a CLI do EB](#python-flask-deploy) 
+ [Limpeza](#python-flask-tutorial-cleanup) 

## Pré-requisitos
<a name="python-flask-prereq"></a>

Este tutorial pressupõe que você tenha conhecimento das operações básicas e do console do Elastic Beanstalk. Caso ainda não tenha, siga as instruções em [Saiba como começar a usar o Elastic Beanstalk](GettingStarted.md) para iniciar seu primeiro ambiente do Elastic Beanstalk.

Para seguir os procedimentos neste manual, você precisa de um terminal de linha de comando ou de um shell para executar os comandos. Nas listagens, os comandos são mostrados precedidos por um símbolo de prompt (\$1) e pelo nome do diretório atual, quando apropriado.

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

No Linux e no macOS, você pode usar seu gerenciador de pacotes e de shell preferido. No Windows, você pode [instalar o subsistema Windows para Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) para obter uma versão do Ubuntu e Bash integrada ao Windows.

Neste tutorial, usamos o Python 3.11 e a versão correspondente da plataforma Elastic Beanstalk. Instale o Python seguindo as instruções em [Configurar seu ambiente de desenvolvimento Python para o Elastic Beanstalk](python-development-environment.md).

O framework [Flask](http://flask.pocoo.org/) será instalado como parte do tutorial.

Este tutorial também usa a interface da linha de comando do Elastic Beanstalk (CLI do EB). Para obter detalhes sobre a instalação e configuração da CLI do EB, consulte [Instalar a EB CLI com script de configuração (recomendado)](eb-cli3.md#eb-cli3-install) e [Configurar a EB CLI](eb-cli3-configuration.md).

## Configurar um ambiente Python virtual com Flask
<a name="python-flask-setup-venv"></a>

Crie um diretório de projeto e um ambiente virtual para seu aplicativo e instale o Flask.

**Para configurar o ambiente de projetos**

1. Crie um diretório do projeto.

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

1. Crie e ative um ambiente virtual denominado `virt`:

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

   Você verá `(virt)` acrescentado ao prompt de comando, indicando que você está em um ambiente virtual. Use o ambiente virtual para o restante deste tutorial.

1. Instale o Flask com `pip install`:

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

1. Veja as bibliotecas instaladas com `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
   ```

   Esse comando relaciona todos os pacotes instalados em seu ambiente virtual. Como você está em um ambiente virtual, os pacotes instalados globalmente, como a EB CLI, não são mostrados.

1. Salve a saída de `pip freeze` como um arquivo chamado `requirements.txt`.

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

   Esse arquivo informa o Elastic Beanstalk para instalar as bibliotecas durante a implantação. Para obter mais informações, consulte [Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk](python-configuration-requirements.md).

## Criar uma aplicação Flask
<a name="python-flask-create-app"></a>

Depois, crie uma aplicação a ser implantada usando o Elastic Beanstalk. Criaremos um serviço RESTful web “Hello World”.

Crie um novo arquivo de texto nesse diretório chamado `application.py` com o seguinte conteúdo:

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

Este exemplo imprime uma saudação personalizada que varia de acordo com o caminho usado para acessar o serviço.

**nota**  
Com a adição de `application.debug = True` antes de executar o aplicativo, a saída da depuração é habilitada para o caso de algo der errado. É uma boa prática de desenvolvimento, mas você deve remover instruções de depuração no código de produção, já que a saída da depuração pode revelar aspectos internos do seu aplicativo.

Use `application.py` como o nome do arquivo e forneça um objeto que pode ser chamado `application` (o objeto Flask, neste caso) para que o Elastic Beanstalk possa localizar facilmente o código da aplicação.

Execute `application.py` com 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
```

Abra `http://127.0.0.1:5000/` em seu navegador da web. Você deve ver o aplicativo em execução, mostrando a página de índice:

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


Verifique o log do servidor para ver a saída da sua solicitação. Você pode interromper o servidor web e retornar ao ambiente virtual pressionando **Ctrl\$1C**.

Se você obteve a saída da depuração em vez disso, corrija os erros e verifique se a aplicação é executada localmente antes de configurá-la para o Elastic Beanstalk.

## Implantar o site com a CLI do EB
<a name="python-flask-deploy"></a>

Você adicionou tudo o que precisa para implantar a aplicação no Elastic Beanstalk. O diretório do projeto deve ter esta aparência:

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

No entanto, a pasta `virt` não é necessária para que a aplicação seja executada no Elastic Beanstalk. Quando você faz a implantação, o Elastic Beanstalk cria um ambiente virtual nas instâncias do servidor e instala as bibliotecas listadas em `requirements.txt`. Para minimizar o tamanho do pacote de origem que você carregou durante a implantação, adicione um arquivo [.ebignore](eb-cli3-configuration.md#eb-cli3-ebignore) que instrui a EB CLI a deixar a pasta `virt` de fora.

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

```
virt
```

Depois, você criará o ambiente da aplicação e implantará a aplicação configurada com o Elastic Beanstalk.

**Para criar um ambiente e implantar o aplicativo Flask**

1. Inicialize o repositório da EB CLI com o comando **eb init**:

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

   Esse comando cria um novo aplicativo chamado `flask-tutorial` e configura seu repositório local para criar ambientes com a versão mais recente da plataforma Python 3.11.

1. (opcional) Execute **eb init** novamente para configurar um par de chaves padrão para que você possa se conectar à EC2 instância que executa seu aplicativo com SSH:

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

   Selecione um par de chaves se você já tiver um ou siga os prompts para criar um novo. Se nenhum prompt aparecer ou se for necessário alterar as configurações posteriormente, execute **eb init -i**.

1. Crie um ambiente e implante seu aplicativo nele com **eb create**:

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

A criação de ambiente leva cerca de 5 minutos e cria os seguintes recursos:
+ **EC2 instância** — Uma máquina virtual Amazon Elastic Compute Cloud (Amazon EC2) configurada para executar aplicativos web na plataforma que você escolher.

  Cada plataforma executa um conjunto específico de software, arquivos de configuração e scripts para oferecer suporte a uma versão de linguagem, framework, contêiner da web específicos ou a uma combinação deles. A maioria das plataformas usa o Apache ou o NGINX como um proxy reverso que fica na frente da aplicação Web, encaminha solicitações para ela, atende ativos estáticos e gera logs de acesso e de erro.
+ **Grupo de segurança da instância** — Um grupo EC2 de segurança da Amazon configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP do balanceador de carga chegue à EC2 instância que executa seu aplicativo web. Por padrão, o tráfego não é permitido em outras portas.
+ **Balanceador de carga**: um balanceador de carga do Elastic Load Balancing configurado para distribuir solicitações para as instâncias que executam a aplicação. Um load balancer também elimina a necessidade de expor suas instâncias diretamente à Internet.
+ **Grupo de segurança do balanceador de carga** — Um grupo EC2 de segurança da Amazon configurado para permitir tráfego de entrada na porta 80. Esse recurso permite que o tráfego HTTP da Internet acesse o load balancer. Por padrão, o tráfego não é permitido em outras portas.
+ **Grupo de Auto Scaling**: grupo de Auto Scaling configurado para substituir uma instância se ela for encerrada ou ficar indisponível.
+ **Bucket do Amazon S3**: um local de armazenamento do seu código-fonte, logs e outros artefatos criados quando o Elastic Beanstalk é utilizado.
+ ** CloudWatch Alarmes da Amazon** — Dois CloudWatch alarmes que monitoram a carga nas instâncias em seu ambiente e que são acionados se a carga for muito alta ou muito baixa. Quando um alarme é acionado, o seu grupo de Auto Scaling pode aumentar ou diminuir.
+ **CloudFormation stack** — O Elastic CloudFormation Beanstalk usa para lançar os recursos em seu ambiente e propagar as alterações de configuração. Os recursos são definidos em um modelo que você pode visualizar no [console do CloudFormation](https://console.aws.amazon.com/cloudformation).
+ **Nome de domínio** — Um nome de domínio que é direcionado para seu aplicativo da web no formulário **subdomain*. *region*.elasticbeanstalk.com*.
**Segurança de domínios**  
Para aumentar a segurança de suas aplicações do Elastic Beanstalk, o domínio *elasticbeanstalk.com* é registrado na [Lista Pública de Sufixos (PSL)](https://publicsuffix.org/).  
Se precisar definir cookies confidenciais no nome de domínio padrão para suas aplicações Elastic Beanstalk, recomendamos usar cookies com um prefixo `__Host-` para maior segurança. Essa prática defende seu domínio contra tentativas de falsificação de solicitação entre sites (CSRF). Para obter mais informações, consulte a página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) na Mozilla Developer Network.

Todos esses recursos são gerenciados pelo Elastic Beanstalk. Quando você encerra o ambiente, o Elastic Beanstalk encerra todos os recursos dele.

**nota**  
O bucket do Amazon S3 que o Elastic Beanstalk cria é compartilhado entre ambientes e não é excluído durante o encerramento do ambiente. Para obter mais informações, consulte [Usar o Elastic Beanstalk com o Amazon S3](AWSHowTo.S3.md).

Quando o processo de criação do ambiente for concluído, abra o site com **eb open**:

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

Isso abrirá uma janela do navegador usando o nome de domínio criado para o seu aplicativo. Você deve ver o mesmo site Flask que criou e testou localmente.

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


Se o aplicativo não aparecer em execução ou se houver uma mensagem de erro, consulte [Solução de erros de implantação](troubleshooting.md#troubleshooting-deployments) para obter ajuda sobre como determinar a causa do erro.

Caso *veja* a aplicação em execução, você implantou sua primeira aplicação Flask com o Elastic Beanstalk. Parabéns\$1

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

Depois de terminar de trabalhar com o código de demonstração, você pode encerrar seu ambiente. [O Elastic Beanstalk exclui todos os recursos AWS relacionados, [como instâncias da EC2 Amazon](using-features.managing.ec2.md), [instâncias de banco de dados, balanceadores de carga[,](using-features.managing.elb.md)](using-features.managing.db.md) grupos de segurança e alarmes.](using-features.alarms.md#using-features.alarms.title) 

Como a remoção de recursos não exclui a aplicação Elastic Beanstalk, é possível criar ambientes para a aplicação a qualquer momento.

**Para encerrar seu ambiente Elastic Beanstalk do console**

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. Escolha **Actions** (Ações) e depois **Terminate Environment** (Encerrar ambiente).

1. Use a caixa de diálogo na tela para confirmar o encerramento do ambiente.

ou com a EB CLI:

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

## Próximas etapas
<a name="python-flask-more-info"></a>

Para mais informações sobre o Flask, acesse [flask.pocoo.org](http://flask.pocoo.org/).

Se você deseja testar outra framework da Web para Python, consulte [Implantar uma aplicação Django no Elastic Beanstalk](create-deploy-python-django.md).

# Implantar uma aplicação Django no Elastic Beanstalk
<a name="create-deploy-python-django"></a>

Este tutorial explica o processo de implantação de um site [Django](https://www.djangoproject.com/) padrão gerado automaticamente para ambientes do AWS Elastic Beanstalk que executam Python. Este tutorial mostra como hospedar uma aplicação Web Python na nuvem usando um ambiente do Elastic Beanstalk. 

Neste tutorial, você fará o seguinte:
+ [Configurar um ambiente virtual Python e instalar o Django](#python-django-setup-venv)
+ [Criar um projeto Django](#python-django-create-app)
+ [Configurar a aplicação Django para o Elastic Beanstalk](#python-django-configure-for-eb) 
+ [Implantar o site com a CLI do EB](#python-django-deploy) 
+ [Atualizar seu aplicativo](#python-django-update-app) 
+ [Limpeza](#python-django-stopping)

## Pré-requisitos
<a name="python-django-prereq"></a>

Para seguir este tutorial, você deve ter todos os [Pré-requisitos comuns](python-development-environment.md) para Python instalados, incluindo os seguintes pacotes:
+ Python 3.7 ou posterior
+ `pip`
+ `virtualenv`
+ `awsebcli`

A framework do [Django](https://www.djangoproject.com/) será instalada como parte do tutorial.

**nota**  
A criação de ambientes com a CLI do EB exige uma [função de serviço](concepts-roles-service.md). É possível criar uma função de serviço criando um ambiente no console do Elastic Beanstalk. Se você não tiver uma função de serviço, a CLI do EB tentará criar uma ao executar `eb create`.

## Configurar um ambiente virtual Python e instalar o Django
<a name="python-django-setup-venv"></a>

Crie um ambiente virtual com `virtualenv` e use-o para instalar o Django e suas dependências. Ao usar um ambiente virtual, você pode saber exatamente quais pacotes seu aplicativo precisa, para que os pacotes necessários sejam instalados nas EC2 instâncias da Amazon que estão executando seu aplicativo. 

As etapas a seguir demonstram os comandos que você deve inserir para sistemas baseados em Unix e Windows, mostrados em guias separadas.

**Para configurar o ambiente virtual**

1. Crie um ambiente virtual denominado `eb-virt`.

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

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

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

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

------

1. Ative o ambiente virtual.

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

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

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

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

------

   Você verá `(eb-virt)` acrescentado ao começo do prompt de comando, indicando que você está em um ambiente virtual.
**nota**  
O restante das instruções mostra o prompt de comando do Linux no diretório inicial `~$`. No Windows, ou seja`C:\Users\USERNAME>`, onde *USERNAME* está seu nome de login do Windows.

1. Use `pip` para instalar o Django.

   ```
   (eb-virt)~$ pip install django==2.2
   ```
**nota**  
A versão do Django que você instalar deve ser compatível com a versão do Python na configuração do Python do Elastic Beanstalk que você escolher para a implantação de seu aplicativo. Para obter informações sobre implantação, consulte [Implantar o site com a CLI do EB](#python-django-deploy) neste tópico.  
Para obter mais informações sobre as versões atuais da plataforma 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 obter informações sobre a compatibilidade de versão do Django com o Python, consulte [Qual versão do Python posso usar com o Django?](https://docs.djangoproject.com/en/3.1/faq/install/#what-python-version-can-i-use-with-django)

1. Para verificar se o Django está instalado, insira o seguinte.

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

   Esse comando relaciona todos os pacotes instalados em seu ambiente virtual. Posteriormente, você usará a saída desse comando para configurar o projeto para uso com o Elastic Beanstalk.

## Criar um projeto Django
<a name="python-django-create-app"></a>

Agora você está pronto para criar um projeto Django e executá-lo em sua máquina, usando o ambiente virtual.

**nota**  
Este tutorial usa SQLite, que é um mecanismo de banco de dados incluído no Python. O banco de dados é implantado com seus arquivos de projeto. Para ambientes de produção, recomendamos que você use o Amazon Relational Database Service (Amazon RDS) e que você o separe do ambiente. Para obter mais informações, consulte [Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente Python Elastic Beanstalk](create-deploy-python-rds.md).

**Para gerar um aplicativo Django**

1. Ative seu ambiente virtual.

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

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

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

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

------

   Você verá o prefixo `(eb-virt)` acrescentado ao prompt de comando, indicando que você está em um ambiente virtual.
**nota**  
O restante das instruções mostra o prompt de comando do Linux `~$` em seu diretório inicial e no diretório inicial do Linux `~/`. No Windows`C:\Users\USERNAME>`, onde *USERNAME* está seu nome de login do Windows.

1. Use o comando `django-admin startproject` para criar um projeto Django denominado `ebdjango`:

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

   Este comando cria um site Django padrão denominado **ebdjango** com a seguinte estrutura de diretório.

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

1. Execute o site Django localmente com `manage.py runserver`:

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

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

1. Em um navegador da web, abra `http://127.0.0.1:8000/` para visualizar o site.

1. Verifique o log do servidor para ver a saída da sua solicitação. Para interromper o servidor web e retornar ao seu ambiente virtual, pressione **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
   ```

## Configurar a aplicação Django para o Elastic Beanstalk
<a name="python-django-configure-for-eb"></a>

Agora que você tem um site desenvolvido pelo Django em sua máquina local, você pode configurá-lo para implantação com o Elastic Beanstalk.

Por padrão, o Elastic Beanstalk procura um arquivo chamado `application.py` para iniciar sua aplicação. Como isso não existe no projeto Django que você criou, é necessário fazer alguns ajustes no ambiente do aplicativo. Também é necessário definir variáveis de ambiente para que os módulos do aplicativo possam ser carregados.

**Como configurar seu site para o Elastic Beanstalk**

1. Ative seu ambiente virtual.

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

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

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

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

------

1. Execute `pip freeze` e salve a saída em um arquivo chamado `requirements.txt`.

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

   O Elastic `requirements.txt` Beanstalk usa para determinar qual pacote instalar EC2 nas instâncias que executam seu aplicativo.

1. Crie um diretório denominado `.ebextensions`.

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

1. No diretório `.ebextensions`, adicione um [arquivo de configuração](ebextensions.md) chamado `django.config` com o texto a seguir.  
**Example \$1/ebdjango/.ebextensions/django.config**  

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

   Essa configuração, `WSGIPath`, especifica o local do script WSGI que o Elastic Beanstalk usa para iniciar a aplicação.
**nota**  
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.

1. Use o comando `deactivate` para desativar o ambiente virtual.

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

   Reative o ambiente virtual sempre que for necessário adicionar pacotes ao aplicativo ou executá-lo localmente.

## Implantar o site com a CLI do EB
<a name="python-django-deploy"></a>

Você adicionou tudo o que precisa para implantar a aplicação no Elastic Beanstalk. O diretório do projeto deve ter esta aparência:

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

Depois, você criará o ambiente da aplicação e implantará a aplicação configurada com o Elastic Beanstalk.

Imediatamente após a implantação, edite a configuração do Django para adicionar o nome de domínio que o Elastic Beanstalk atribuiu à aplicação para os `ALLOWED_HOSTS` do Django. Depois, reimplante o aplicativo. Este é um requisito de segurança do Django, projetado para impedir ataques ao cabeçalho de `Host` HTTP. Para obter mais informações, consulte [Validação do cabeçalho do host](https://docs.djangoproject.com/en/2.2/topics/security/#host-headers-virtual-hosting).

**Para criar um ambiente e implantar o aplicativo Django**
**nota**  
O tutorial usa a CLI do EB como um mecanismo de implantação, mas também é possível usar o console do Elastic Beanstalk para implantar um arquivo zip com o conteúdo do seu projeto. 

1. Inicialize o repositório da EB CLI com o comando **eb init**:

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

   Esse comando cria um aplicativo chamado `django-tutorial`. Ele também configura o seu repositório local para criar ambientes com a versão mais recente da plataforma Python 3.7.

1. (Opcional) Execute **eb init** novamente para configurar um par de chaves padrão para que você possa usar o SSH para se conectar à EC2 instância que executa seu aplicativo.

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

   Selecione um par de chaves se você já tiver um, ou siga os as instruções na tela para criar um. Se nenhum prompt aparecer ou se for necessário alterar as configurações posteriormente, execute **eb init -i**.

1. Crie um ambiente e implante o aplicativo nele com **eb create**.

   ```
   ~/ebdjango$ eb create django-env
   ```
**nota**  
Se você vir uma mensagem de erro "service role required", execute `eb create` interativamente (sem especificar um nome de ambiente) e a CLI do EB cria a função para você.

   Esse comando cria um ambiente do Elastic Beanstalk com carga balanceada chamado `django-env`. A criação do ambiente leva cerca de 5 minutos. Como o Elastic Beanstalk cria os recursos necessários para executar a aplicação, ele gera mensagens informativas que a CLI do EB transmite ao terminal.

1. Quando o processo de criação do ambiente for concluído, localize o nome de domínio do seu novo ambiente executando **eb status**.

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

   Seu nome de domínio do ambiente é o valor da propriedade `CNAME`.

1. Abra o arquivo `settings.py` no diretório `ebdjango`. Localize a configuração `ALLOWED_HOSTS` e adicione o nome de domínio do aplicativo que você encontrou na etapa anterior ao valor da configuração. Se você não encontrar essa configuração no arquivo, adicione-a em uma nova linha.

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

1. Salve o arquivo e, em seguida, implante o aplicativo executando **eb deploy**. Quando você executa **eb deploy**, a EB CLI empacota o conteúdo do diretório do projeto e implanta-o em seu ambiente.

   ```
   ~/ebdjango$ eb deploy
   ```
**nota**  
Se você estiver usando o Git com seu projeto, consulte [Usar a EB CLI com o Git](eb3-cli-git.md).

1. Quando o processo de atualização do ambiente for concluído, abra o site com **eb open**.

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

   Isso abre uma janela do navegador usando o nome de domínio criado para o seu aplicativo. Você deve ver o mesmo site Django que você criou e testou localmente.

Se o aplicativo não aparecer em execução ou se houver uma mensagem de erro, consulte [Solução de erros de implantação](troubleshooting.md#troubleshooting-deployments) para obter ajuda sobre como determinar a causa do erro.

Se a aplicação *aparecer* em execução, você implantou sua primeira aplicação Django com o Elastic Beanstalk. Parabéns\$1

## Atualizar seu aplicativo
<a name="python-django-update-app"></a>

Agora que você tem uma aplicação em execução no Elastic Beanstalk, pode atualizar e reimplantar a aplicação ou sua configuração, e o Elastic Beanstalk fará o trabalho de atualizar suas instâncias e iniciar sua nova versão da aplicação.

Para este exemplo, vamos habilitar o console de administração do Django e definir algumas outras configurações.

### Modificar as configurações do site
<a name="python-django-modify-site"></a>

Por padrão, o site Django usa o fuso horário UTC para exibir a hora. Você pode alterá-lo especificando um fuso horário em `settings.py`.

**Para alterar o fuso horário do site**

1. Modifique a configuração `TIME_ZONE` em `settings.py`.  
**Example \$1/.py ebdjango/ebdjango/settings**  

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

   Para obter uma lista de fusos horários, visite [esta página](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones).

1. Implante a aplicação no ambiente do Elastic Beanstalk.

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

### Criar um administrador de site
<a name="python-django-create-admin"></a>

É possível criar um administrador de site para o aplicativo Django para acessar o console de administração diretamente do site. Os detalhes de login do administrador são armazenados de forma segura na imagem do banco de dados local incluída no projeto padrão gerado pelo Django.

**Para criar um administrador de site**

1. Inicialize o banco de dados local do aplicativo 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. Execute `manage.py createsuperuser` para criar um administrador.

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

1. Para informar ao Django onde armazenar os arquivos estáticos, defina `STATIC_ROOT` em `settings.py`.  
**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. Execute `manage.py collectstatic` para preencher o `static` diretório com ativos estáticos (JavaScriptCSS e imagens) para o site de administração.

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

1. Implante o aplicativo.

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

1. Exiba o console de administração abrindo o site em seu navegador, anexando `/admin/` ao URL do site, como o seguinte:

   ```
   http://djang-env.p33kq46sfh.us-west-2.elasticbeanstalk.com/admin/
   ```  
![\[Insira o nome de usuário e a senha que você criou na etapa 2 para fazer login no console de administração.\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/eb_django_admin_login.png)

1. Faça login com o nome de usuário e a senha que você configurou na etapa 2.  
![\[O console de administração do Django para seu site Django implantado com o Elastic Beanstalk\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/eb_django_admin_console.png)

Você pode usar um procedimento semelhante ao local updating/testing seguido por**eb deploy**. O Elastic Beanstalk cuida do processo de atualizar seus servidores em tempo real para que você possa se dedicar ao desenvolvimento de aplicações, em vez da administração de servidor.

### Adicionar um arquivo de configuração de migração de banco de dados
<a name="python-django-migrate-site"></a>

É possível adicionar comandos ao script `.ebextensions` que serão executados quando o site for atualizado. Isso permite gerar automaticamente migrações de banco de dados.

**Para adicionar uma etapa de migração quando o aplicativo é implantado**

1. Crie um [arquivo de configuração](ebextensions.md) chamado `db-migrate.config` com o conteúdo a seguir.  
**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
   ```

   Esse arquivo de configuração ativa o ambiente virtual do servidor e executa o comando `manage.py migrate` durante o processo de implantação, antes de iniciar a sua aplicação. Como ele é executado antes da inicialização do aplicativo, também é necessário configurar a variável de ambiente `DJANGO_SETTINGS_MODULE` explicitamente (em geral, o `wsgi.py` cuida desse procedimento para você durante o startup). A especificação de `leader_only: true` no comando garante que ele seja executado somente uma vez quando você faz a implantação em várias instâncias.

1. Implante o aplicativo.

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

## Limpeza
<a name="python-django-stopping"></a>

Para economizar horas de instância e outros AWS recursos entre as sessões de desenvolvimento, encerre seu ambiente do Elastic Beanstalk com. **eb terminate**

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

Esse comando encerra o ambiente e todos os AWS recursos executados nele. Ele não exclui o aplicativo, mas você sempre pode criar mais ambientes com a mesma configuração executando **eb create** novamente.

Se você já concluiu o aplicativo de exemplo, também pode remover a pasta do projeto e o ambiente virtual.

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

## Próximas etapas
<a name="python-django-next-steps"></a>

Para obter mais informações sobre o Django, incluindo um tutorial detalhado, consulte [a documentação oficial](https://docs.djangoproject.com/en/2.2/).

Se você deseja testar outra framework da Web para Python, consulte [Implantar uma aplicação Flask no Elastic Beanstalk](create-deploy-python-flask.md).

# Adicionar uma instância de banco de dados do Amazon RDS ao seu ambiente Python Elastic Beanstalk
<a name="create-deploy-python-rds"></a>

Este tópico fornece instruções para criar o Amazon RDS usando o console do Elastic Beanstalk. É possível usar uma instância de banco de dados do Amazon Relational Database Service (Amazon RDS) para armazenar dados coletados e modificados pela aplicação. O banco de dados pode ser acoplado ao seu ambiente e gerenciado pelo Elastic Beanstalk ou pode ser criado como desacoplado e gerenciado externamente por outro serviço. Nestas instruções, o banco de dados é acoplado ao ambiente e gerenciado pelo Elastic Beanstalk. Para obter mais informações sobre como integrar um Amazon RDS com o Elastic Beanstalk, consulte [Adição de um banco de dados ao seu ambiente do Elastic Beanstalk](using-features.managing.db.md).

**Topics**
+ [Adicionar uma instância de banco de dados ao seu ambiente](#python-rds-create)
+ [Download de um driver](#python-rds-drivers)
+ [Conectar-se a um banco de dados](#python-rds-connect)

## Adicionar uma instância de banco de dados ao seu ambiente
<a name="python-rds-create"></a>

**Para adicionar uma instância de banco de dados ao ambiente**

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 **Database (Banco de dados)**, escolha **Edit (Editar)**.

1. Escolha um mecanismo de banco de dados e insira um nome de usuário e senha.

1. Para salvar as alterações, escolha **Apply (Aplicar)** na parte inferior da página.

A adição de uma instância de banco de dados leva cerca de 10 minutos. Quando a atualização do ambiente for concluída, o nome de host da instância de banco de dados e outras informações de conexão estarão disponíveis para o seu aplicativo por meio das seguintes propriedades de ambiente:


| Nome da propriedade | Descrição | Valor da propriedade | 
| --- | --- | --- | 
|  `RDS_HOSTNAME`  |  O nome do host da instância de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** no console do Amazon RDS: **Endpoint**.  | 
|  `RDS_PORT`  |  A porta na qual a instância de banco de dados aceita conexões. O valor padrão varia entre os mecanismos de banco de dados.  |  Na guia **Connectivity & security (Conectividade e segurança)** do console do Amazon RDS: **Port (Porta)**.  | 
|  `RDS_DB_NAME`  |  O nome do banco de dado, **ebdb**.  |  Na guia **Configuration (Configuração)** no console do Amazon RDS: **DB Name (Nome do banco de dados)**.  | 
|  `RDS_USERNAME`  |  O nome de usuário que você configurou para seu banco de dados.  |  Na guia **Configuration (Configuração)** do console do Amazon RDS: **Nome de usuário primário**.  | 
|  `RDS_PASSWORD`  |  A senha que você configurou para seu banco de dados.  |  Não disponível para referência no console do Amazon RDS.  | 

Para obter mais informações sobre como configurar uma instância de banco de dados acoplada a um ambiente Elastic Beanstalk, consulte [Adição de um banco de dados ao seu ambiente do Elastic Beanstalk](using-features.managing.db.md).

## Download de um driver
<a name="python-rds-drivers"></a>

Adicione o driver de banco de dados ao [arquivo de requisitos](python-configuration-requirements.md) de seu projeto.

**Example requirements.txt: Django com MySQL**  

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

**Pacotes de drivers comuns para Python**
+ **MySQL** – `mysqlclient`
+ **PostgreSQL** – `psycopg2`
+ **Oracle**: `cx_Oracle`
+ **SQL Server** – `adodbapi`

Para obter mais informações, consulte [Python DatabaseInterfaces](https://wiki.python.org/moin/DatabaseInterfaces) e [Django 2.2](https://docs.djangoproject.com/en/2.2/ref/databases) - bancos de dados suportados.

## Conectar-se a um banco de dados
<a name="python-rds-connect"></a>

O Elastic Beanstalk fornece informações de conexão referentes às instâncias de banco de dados associadas nas propriedades de ambiente. Use `os.environ['VARIABLE']` para ler as propriedades e configurar uma conexão de banco de dados.

**Example Arquivo de configurações Django: dicionário de BANCOS DE DADOS**  

```
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'],
        }
    }
```

# Ferramentas e recursos do Python
<a name="create-deploy-python-tools-resources"></a>

Há vários lugares que você pode acessar para obter ajuda adicional durante o desenvolvimento de seus aplicativos Python:


****  

| Recurso | Description | 
| --- | --- | 
| [AWS SDK para Python (Boto3) em GitHub](https://github.com/boto/boto3) | Instale o Boto3 proveniente de. GitHub | 
| [AWS SDK para Python (Boto3) página inicial](https://aws.amazon.com//sdk-for-python/) | A AWS SDK para Python (Boto3) página inicial. | 
| [Centro de desenvolvedores Python](https://aws.amazon.com/python/) | Um local central para acessar código de exemplo, documentação, ferramentas e outros recursos. |