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

# 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).