Implantar uma aplicação Flask no Elastic Beanstalk - AWS Elastic Beanstalk
Pré-requisitosConfigurar um ambiente Python virtual com FlaskCriar uma aplicação FlaskImplantar o site com a CLI do EBLimpezaPróximas etapas

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

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

Neste tutorial, você fará o seguinte:

Pré-requisitos

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 Introdução ao Elastic Beanstalk 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 ($) 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 para obter uma versão do Ubuntu e Bash integrada ao Windows.

O Flask requer o Python 3.7 ou posterior. Neste tutorial, usamos Python 3.7 e a versão correspondente da plataforma do Elastic Beanstalk. Instale o Python seguindo as instruções em Configurar seu ambiente de desenvolvimento Python para o Elastic Beanstalk.

O framework Flask 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 interface de linha de comando do Elastic Beanstalk e Configurar a EB CLI.

Configurar um ambiente Python virtual com Flask

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

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

  3. Instale o Flask com pip install:

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

  4. Veja as bibliotecas instaladas com pip freeze:

    (virt)~/eb-flask$ pip freeze
click==8.1.1
Flask==2.0.3
itsdangerous==2.1.2
Jinja2==3.1.1
MarkupSafe==2.1.1
Werkzeug==2.1.0

    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.

  5. 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 ter mais informações, consulte Especificação de dependências usando um arquivo de requisitos no Elastic Beanstalk.

Criar uma aplicação Flask

Depois, crie uma aplicação a ser implantada usando o Elastic Beanstalk. Vamos criar um serviço Web RESTful "Hello World".

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

exemplo ~/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.

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+C.

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

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 que instrui a EB CLI a deixar a pasta virt de fora.

exemplo ~/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.7 flask-tutorial --region us-east-2
Application flask-tutorial has been created.

    Esse comando cria uma nova aplicação nomeada flask-tutorial e configura seu repositório local para criar ambientes com a versão da plataforma Python 3.7 mais recente.

  2. (opcional) Execute eb init novamente para configurar um par de chaves padrão para que você possa se conectar à instância do EC2 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.

  3. 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:

  • Instância do EC2: uma máquina virtual do Amazon Elastic Compute Cloud (Amazon EC2) configurada para executar aplicações Web na plataforma escolhida.

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

  • 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 de segurança do Amazon EC2 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.

  • Alarmes do Amazon CloudWatch: dois alarmes do CloudWatch que monitoram a carga nas instâncias do ambiente e são acionados quando ela está muito alta ou muito baixa. Quando um alarme é acionado, o seu grupo de Auto Scaling pode aumentar ou diminuir.

  • Pilha do AWS CloudFormation: o Elastic Beanstalk usa o AWS CloudFormation para iniciar os recursos em seu ambiente e propagar alterações de configuração. Os recursos são definidos em um modelo que você pode visualizar no console do AWS CloudFormation.

  • Nome de domínio: um nome de domínio que encaminha para a aplicação Web no formato subdomínio.região.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).

    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 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 ter mais informações, consulte Usar o Elastic Beanstalk com o Amazon S3.

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.

Se o aplicativo não aparecer em execução ou se houver uma mensagem de erro, consulte Solução de erros de implantação 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!

Limpeza

Ao terminar de trabalhar com o Elastic Beanstalk, você pode encerrar o ambiente. O Elastic Beanstalk termina todos os recursos da AWS associados ao seu ambiente, como instâncias do Amazon EC2, instâncias de banco de dados, balanceadores de carga, grupos de segurança e alarmes.

Para encerrar seu ambiente Elastic Beanstalk do console

  1. Abra o console do Elastic Beanstalk e, na lista Regions (Regiões), selecione a sua Região da AWS.

  2. No painel de navegação, selecione Ambientes e selecione o nome do ambiente na lista.

    nota

    Se você tiver muitos ambientes, use a barra de pesquisa para filtrar a lista de ambientes.

  3. Escolha Actions (Ações) e depois Terminate Environment (Encerrar ambiente).

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

Com o Elastic Beanstalk, é possível criar facilmente um ambiente para a aplicação a qualquer momento.

ou com a EB CLI:

~/eb-flask$ eb terminate flask-env

Próximas etapas

Para mais informações sobre o Flask, acesse flask.pocoo.org.

Se você deseja testar outra framework da Web para Python, consulte Implantar uma aplicação Django no Elastic Beanstalk.