Implantar uma aplicação Django no Elastic Beanstalk

Este tutorial explica o processo de implantação de um site Django 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

• Criar um projeto Django

• Configurar a aplicação Django para o Elastic Beanstalk

• Implantar o site com a CLI do EB

• Atualizar seu aplicativo

• Limpar

Pré-requisitos

Para usar qualquer serviço da AWS, incluindo o Elastic Beanstalk, você precisa ter uma conta e credenciais da AWS. Para saber mais e se cadastrar, visite https://aws.amazon.com/.

Para seguir este tutorial, você deve ter todos os Pré-requisitos comuns para Python instalados, incluindo os seguintes pacotes:

• Python 3.7 ou posterior

• pip

• virtualenv

• awsebcli

A framework do Django será instalada como parte do tutorial.

nota

A criação de ambientes com a CLI do EB exige uma função de serviço. É 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

Crie um ambiente virtual com virtualenv e use-o para instalar o Django e suas dependências. Usando um ambiente virtual, é possível saber exatamente de quais pacotes a aplicação precisa, para que eles sejam instalados nas instâncias do Amazon EC2 que executam a aplicação.

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

2. 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, ele é C:\Users\USERNAME>, em que USERNAME é seu nome de login do Windows.

3. 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 neste tópico.

   Para obter mais informações sobre as versões atuais da plataforma Python, consulte 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?

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

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 simples 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 ambiente de aplicações Python.

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, eles são C:\Users\USERNAME>, em que USERNAME é seu nome de login do Windows.

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

3. Execute o site Django localmente com : manage.py runserver.

   (eb-virt) ~$ cd ebdjango

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

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

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

   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

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

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

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

   O Elastic Beanstalk usa o requirements.txt para determinar que pacote instalar nas instâncias do EC2 que executam a aplicação.

3. Crie um diretório chamado .ebextensions.

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

4. No diretório .ebextensions, adicione um arquivo de configuração chamado django.config com o texto a seguir.

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

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

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 do Django ALLOWED_HOSTS. 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.

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.

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

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

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

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

5. 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']

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

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

Atualizar seu aplicativo

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

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.

   exemplo ~/ebdjango/ebdjango/settings.py

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

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

   ~/ebdjango/$ eb deploy

Criar um administrador de site

É 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
   

2. Execute manage.py createsuperuser para criar um administrador.

   (eb-virt) ~/ebdjango$ python manage.py createsuperuser
   Username: admin
   Email address: [e-mail]
   Password: ********
   Password (again): ********
   Superuser created successfully.

3. Para informar ao Django onde armazenar os arquivos estáticos, defina STATIC_ROOT em settings.py.

   exemplo ~/ebdjango/ebdjango/settings.py

   # Static files (CSS, JavaScript, Images)
   # https://docs.djangoproject.com/en/2.2/howto/static-files/
   STATIC_URL = '/static/'
   STATIC_ROOT = 'static'

4. Execute manage.py collectstatic para preencher o diretório static com os ativos estáticos (JavaScript, CSS e imagens) para o site de administração.

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

5. Implante o aplicativo.

   ~/ebdjango$ eb deploy

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

   

7. Faça login com o nome de usuário e a senha que você configurou na etapa 2.

   

Você pode usar um procedimento semelhante de atualização/teste local 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

É 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 chamado db-migrate.config com o conteúdo a seguir.

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

2. Implante o aplicativo.

   ~/ebdjango$ eb deploy

Limpar

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

~/ebdjango$ eb terminate django-env

Esse comando encerra o ambiente e todos os recursos da AWS que são executados nele. Ele não exclui o aplicativo, mas você sempre pode criar mais ambientes com a mesma configuração executando eb create novamente. Para obter mais informações sobre comandos da CLI do EB, consulte Gerenciar ambientes do Elastic Beanstalk com a CLI do EB.

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

Para obter mais informações sobre o Django, incluindo um tutorial detalhado, consulte a documentação oficial.

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