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 Django no Elastic Beanstalk 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 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 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 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 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 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 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`. **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 É 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 É 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 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 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).