Como Dockerizar e implantar aplicativos Django

Docker é uma plataforma para construir, executar e distribuir aplicativos. Ele permite empacotar seu aplicativo e todas as suas dependências em um único contêiner, que pode então ser executado em qualquer máquina que tenha o Docker instalado.

Isso torna o Docker ideal para implantação de aplicativos da web, pois facilita a movimentação de seu aplicativo de um ambiente para outro sem a necessidade de se preocupar com problemas de compatibilidade.

Django, por outro lado, é uma estrutura web Python que facilita a criação de aplicativos web poderosos e escaláveis. O Django fornece vários recursos prontos para uso, como um sistema de autenticação de usuário, uma camada de abstração de banco de dados e um mecanismo de modelo.

Isso facilita a introdução ao Django e a construção de aplicações web complexas de forma rápida e fácil.

Dockerizar e implantar um aplicativo Django é um processo relativamente simples. As principais etapas envolvidas são:

1. Crie um Dockerfile para seu aplicativo Django.

2. Crie uma imagem Docker a partir do seu Dockerfile.

3. Implante a imagem Docker em um ambiente de produção.

Neste artigo, orientarei você detalhadamente nas etapas envolvidas na dockerização e implantação de um aplicativo Django. Também fornecerei algumas dicas e práticas recomendadas para implantar aplicativos Django em produção.

Pré-requisitos

Para seguir este tutorial, você precisará dos seguintes pré-requisitos:

• Python 3.9 ou superior
• Pip
• Docker
• Composição do Docker
• Git

Você também precisará de um provedor de hospedagem em nuvem, como AWS, Azure ou Google Cloud Platform, se quiser implantar seu aplicativo Django em produção. Mas para este tutorial, usarei o Heroku.

Depois de instalar todos os pré-requisitos, você estará pronto para começar a dockerizar e implantar seu aplicativo Django!

Criando um projeto Django

Para iniciar um novo projeto Django, você precisa usar o comando django-admin . Este comando permite criar um diretório de projeto e alguns arquivos básicos para sua aplicação Django. Por exemplo, se quiser criar um projeto chamado my_project , você pode executar este comando em seu terminal:

django-admin startproject my_project

Isso criará um diretório chamado `my_project` com a seguinte estrutura:

meu projeto/

├── gerenciar.py

└── projeto/

├── iniciar .py

├── configurações.py

└──urls.py

O arquivo manage.py é um script que permite executar diversas tarefas em seu projeto, como executar o servidor de desenvolvimento, criar migrações de banco de dados e testar seu código. O diretório project/ contém as configurações e os arquivos de configuração do seu projeto.

O arquivo settings.py define as configurações principais do seu projeto, como a conexão do banco de dados, os aplicativos instalados e o middleware. O arquivo urls.py mapeia as URLs do seu projeto para as visualizações dos seus aplicativos.

Após criar um novo projeto Django, você pode testá-lo localmente executando o servidor de desenvolvimento. O servidor de desenvolvimento é um servidor web simples que roda em sua máquina e fornece os arquivos do seu projeto. Para iniciar o servidor de desenvolvimento, execute este comando em seu terminal:

python manage.py runserver

Isso iniciará o servidor na porta 8000 por padrão. Você pode então abrir seu navegador e ir para http://localhost:8000/ para ver a página inicial padrão do Django.

Estrutura Básica e Arquivos de um Projeto Django

Um projeto Django é composto por vários arquivos e diretórios que definem a funcionalidade e a aparência da sua aplicação web. Os principais componentes de um projeto Django são:

manage.py : um script que fornece vários comandos para gerenciar seu projeto, como criar aplicativos, migrar o banco de dados e testar seu código.

project/ : um diretório que contém as configurações e os arquivos de configuração do seu projeto. Os principais arquivos deste diretório são:

 `settings.py`: A file that defines the main settings for your project, such as the database connection, the installed apps, and the middleware. You can customize this file to suit your needs and preferences. `urls.py`: A file that maps the URLs of your project to the views of your apps. You can define different URL patterns for different parts of your web application.

apps/ : Um diretório que contém todos os aplicativos Django que compõem seu projeto. Cada aplicativo Django é um pacote Python separado que fornece uma funcionalidade ou recurso específico para seu aplicativo web. Você pode criar seus próprios aplicativos ou usar os existentes de fontes de terceiros.

Testando o projeto localmente

Para testar o projeto localmente, você pode usar o servidor de desenvolvimento ou o framework de testes fornecido pelo Django. O servidor de desenvolvimento é um servidor web simples que roda em sua máquina e fornece os arquivos do seu projeto. A estrutura de teste é uma ferramenta que permite escrever e executar testes de unidade para seu código.

Para usar o servidor de desenvolvimento, você pode executar este comando em seu terminal:

python manage.py runserver

Isso iniciará o servidor na porta 8000 por padrão. Você pode então abrir seu navegador e ir para `http://localhost:8000/` para ver a página inicial padrão do Django.

Para usar a estrutura de teste, você pode executar este comando em seu terminal:

python manage.py test

Isso executará todos os testes de unidade do seu projeto. Se todos os testes passarem, você verá uma mensagem como esta:

 Ran 1 test in 0.001s Ok

Se algum dos testes falhar, você verá uma mensagem de erro com detalhes sobre a falha. Você pode usar essas informações para depurar e corrigir seu código.

Depois de testar o projeto localmente e estar satisfeito com os resultados, você poderá implantá-lo em um ambiente de produção.

Dockerizando o Projeto Django

O que é um Dockerfile?

Um Dockerfile é um arquivo de texto que contém instruções sobre como construir uma imagem Docker. Uma imagem Docker é um pacote executável independente que inclui tudo o que é necessário para executar um aplicativo: código, tempo de execução, ferramentas do sistema, bibliotecas do sistema e configurações.

Para criar um Dockerfile, você precisa especificar a imagem base, os comandos a serem executados para instalar os pacotes necessários e os comandos a serem executados para iniciar o aplicativo.

Exemplo de Dockerfile para um projeto Django

Aqui está um exemplo de Dockerfile para um projeto Django:

 FROM python:3.9 #Install Django and other required packages RUN pip install django # Copy the Django project files into the image COPY ./app # Set the working directory WORKDIR /app # Start the Django development server CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Este Dockerfile construirá uma imagem Docker que contém Python 3.9, Django e os arquivos de projeto Django. A imagem será configurada para iniciar o servidor de desenvolvimento Django na porta 8000.

O que é um arquivo docker-compose.yml?

Um arquivo docker-compose.yml é um arquivo YAML que define os serviços que compõem um aplicativo Dockerizado. Um serviço pode ser um único contêiner Docker ou um grupo de contêineres Docker.

Para criar um arquivo docker-compose.yml para um projeto Django, você precisa definir o serviço web e o serviço de banco de dados. O serviço web executará o aplicativo Django e o serviço de banco de dados executará o banco de dados usado pelo aplicativo Django.

Exemplo de arquivo docker-compose.yml para um projeto Django

Aqui está um exemplo de arquivo docker-compose.yml para um projeto Django:

 version: "3.9" services: web: build: ports: -"8000:8000" volumes -./:/app db: image: postgres:14.0-alpine volumes: -./postgres:/var/lib/postgresql/data

Este arquivo docker-compose.yml define dois serviços: web e db . O serviço web construirá a imagem Docker a partir do Dockerfile que criamos na seção anterior. O serviço web também exporá a porta 8000 na máquina host para que possamos acessar o servidor de desenvolvimento Django.

O serviço db usará a imagem oficial do PostgreSQL Docker. O serviço db também montará o diretório postgres na máquina host no diretório /var/lib/postgresql/data dentro do contêiner. Isso garantirá que os arquivos do banco de dados persistam entre as reinicializações do contêiner.

Construindo e executando os contêineres Docker

Para construir e executar os contêineres Docker, podemos usar o seguinte comando:

docker-compose up -d

Este comando construirá as imagens Docker para os serviços `web` e `db` se eles ainda não existirem. O comando irá então iniciar os contêineres Docker para os serviços `web` e `db`.

Testando o projeto Django Dockerizado localmente

Assim que os contêineres Docker estiverem em execução, podemos testar o projeto Dockerized Django localmente usando um navegador da web. Abra um navegador da web e navegue até `http://localhost:8000`. Agora você deve conseguir ver a página de desenvolvimento do Django.

Você também pode fazer login na página de administração do Django em http://localhost:8000/admin/ . O nome de usuário e a senha são admin e admin por padrão.

Implantando o Projeto Django

Agora é hora de implantar seu projeto Django em uma plataforma em nuvem usando Git, GitHub e Heroku. Você também testará seu aplicativo web implantado usando um navegador web.

O que é Git e por que precisamos dele?

Git é uma ferramenta de software que pode ajudá-lo a gerenciar o código-fonte do seu projeto. Ele permite que você acompanhe as alterações feitas em seu código, colabore com outros desenvolvedores e reverta para versões anteriores se algo der errado.

O Git também pode permitir que você envie seu código para repositórios remotos, como o GitHub, onde você pode armazenar e compartilhar seu código com outras pessoas.

Como criar um repositório GitHub e enviar nosso código para o GitHub?

Para criar um repositório GitHub para seu projeto Django, você precisa seguir estas etapas:

- Crie uma conta gratuita no GitHub

- Vá para a página do seu perfil e clique no botão Novo ao lado de Repositórios .

- Dê um nome ao seu repositório, como django-docker-app e, opcionalmente, adicione uma descrição.

- Clique no botão Criar repositório .

Agora que você criou um repositório vazio no GitHub. Para enviar seu código para este repositório, você precisa usar o comando `git` em seu terminal. Presumo que você já instalou o Git em sua máquina local e inicializou um repositório Git na pasta do projeto Django. Caso contrário, siga a documentação oficial para fazê-lo.

Para enviar seu código ao GitHub, você precisa seguir estas etapas:

- Vá para a pasta do seu projeto Django no terminal e digite git status para ver o estado atual do seu repositório. Você deverá ver algo assim:

 On branch main Your branch is up to date with 'origin/main'. Changes not staged for commit: (use "git add <file>..." to update what will be committed) (use "git restore <file>..." to discard changes in working directory) modified: Dockerfile modified: docker-compose.yml modified: requirements.txt no changes added to commit (use "git add" and/or "git commit -a")

Isso significa que você tem alguns arquivos modificados que não estão preparados para confirmação. Para prepará-los para commit, você precisa usar o comando git add .

- Digite git add . para preparar todos os arquivos modificados para confirmação. Alternativamente, você pode especificar os nomes dos arquivos que queremos preparar, como git add Dockerfile docker-compose.yml requirements.txt .

- Digite git status novamente para ver o estado atualizado do nosso repositório. Você deverá ver algo assim:

 On branch main Your branch is up to date with 'origin/main'. Changes to be committed: (use "git restore --staged <file>..." to unstage) modified: Dockerfile modified: docker-compose.yml modified: requirements.txt

Isso significa que você tem algumas alterações preparadas para confirmação. Para confirmá-los, você precisa usar o comando git commit .

- Digite git commit -m "Add Docker configuration files" para confirmar as alterações preparadas com uma mensagem descrevendo o que fizemos. Alternativamente, você pode omitir o sinalizador -m e inserir uma mensagem mais longa em um editor que será aberto após digitar git commit .

- Digite git status novamente para ver o estado final do nosso repositório. Você deverá ver algo assim:

 On branch main Your branch is ahead of 'origin/main' by 1 commit. (use "git push" to publish your local commits) nothing to commit, working tree clean

Isso significa que você tem um commit que ainda não foi enviado ao repositório remoto. Para enviá-lo, você precisa usar o comando git push .

- Digite git push origin main para enviar seu commit local para o repositório remoto no GitHub.

Como alternativa, você pode especificar o nome remoto e o nome da ramificação que deseja enviar, como git push origin main .

Pode ser solicitado que você insira seu nome de usuário e senha do GitHub ou use um token de acesso pessoal para se autenticar.

- Vá para a página do repositório GitHub e atualize-a. Você deverá ver seu código e mensagem de commit na página.

Você enviou seu código com sucesso para o GitHub. Agora você pode passar para a próxima etapa, que é implantar seu projeto Django no Heroku.

O que é Heroku e por que você precisa dele?

Heroku é uma plataforma em nuvem que permite implantar, gerenciar e dimensionar aplicativos da web. Suporta várias linguagens de programação, estruturas e bancos de dados, como Python, Django e PostgreSQL.

Ele também fornece vários recursos e complementos que aprimoram nossa experiência de desenvolvimento web, como registro, monitoramento, cache, segurança, etc.

Você precisa do Heroku porque ele torna seu processo de implantação mais fácil e rápido. Você pode usar o Heroku para implantar seu projeto Django sem se preocupar com a infraestrutura subjacente, como servidores, redes ou sistemas operacionais.

Você também pode usar o Heroku para dimensionar seu aplicativo da web de acordo com o tráfego e a demanda. Heroku lida com todas as complexidades e desafios da implantação da web para você.

Como criar uma conta Heroku e instalar a ferramenta Heroku CLI?

Para criar uma conta Heroku, você precisa seguir estas etapas:

- Vá para Heroku e clique no botão Cadastre-se .

- Preencha as informações necessárias, como nome, email, senha, etc.

- Escolha uma linguagem de desenvolvimento primária, como Python.

- Clique no botão Criar conta gratuita .

- Verifique nosso e-mail e clique no link para verificar nossa conta.

Agora você criou uma conta Heroku gratuita. Para instalar a ferramenta Heroku CLI, você precisa seguir estas etapas:

- Vá para [ Heroku CLI e escolha o instalador apropriado para nosso sistema operacional, como Windows, Mac OS X ou Linux.

- Baixe e execute o instalador e siga as instruções na tela.

- Abra um terminal e digite heroku --version para verificar se a instalação foi bem-sucedida. Você deverá ver algo assim:

heroku/7.59.0 win32-x64 node-v12.21.0

Agora você instalou a ferramenta Heroku CLI em sua máquina local. Você pode usar esta ferramenta para interagir com o Heroku a partir do terminal.

Como criar um aplicativo Heroku e definir as configurações necessárias?

Para criar um aplicativo Heroku para nosso projeto Django, precisamos seguir estas etapas:

- Vá para a pasta do projeto Django no terminal e digite heroku login para fazer login na sua conta Heroku usando a ferramenta Heroku CLI. Poderá ser solicitado que você insira seu e-mail e senha ou use um navegador da web para se autenticar.

- Digite heroku create django-docker-app para criar um novo aplicativo Heroku com o nome django-docker-app . Alternativamente, você pode omitir o nome e deixar o Heroku gerar um nome aleatório para você. Você deverá ver algo assim:

 Creating ⬢ django-docker-app... done https://django-docker-app.herokuapp.com/ | https://git.heroku.com/django-docker-app.git

Isso significa que você criou um novo aplicativo Heroku com uma URL da web e uma URL do Git. O URL da web é onde você pode acessar seu aplicativo da web implantado, e o URL do Git é onde você pode enviar seu código para o Heroku.

- Digite heroku config:set SECRET_KEY=<your_secret_key> para definir uma variável de ambiente para a configuração SECRET_KEY do nosso projeto Django. Você precisa substituir <your_secret_key> por uma string aleatória que você pode gerar usando uma ferramenta como Django Secret Key Generator .

Como alternativa, você pode usar a chave secreta existente em seu arquivo settings.py , mas isso não é recomendado por motivos de segurança.

- Digite heroku addons:create heroku-postgresql:hobby-dev para adicionar um complemento de banco de dados PostgreSQL gratuito ao seu aplicativo Heroku. Isto criará um novo banco de dados para o seu projeto Django e definirá uma variável de ambiente para a configuração DATABASE_URL do seu projeto Django. Você deverá ver algo assim:

 Creating heroku-postgresql:hobby-dev on ⬢ django-docker-app... free Database has been created and is available ! This database is empty. If upgrading, you can transfer ! data from another database with pg:copy Created postgresql-curved-12345 as DATABASE_URL Use heroku addons:docs heroku-postgresql to view documentation

Isso significa que você adicionou um complemento de banco de dados PostgreSQL com o nome PostgreSQL-curved-12345 e a URL DATABASE_URL .

- Digite heroku config para ver a lista de variáveis de ambiente que você definiu para seu aplicativo Heroku. Você deverá ver algo assim:

 === django-docker-app Config Vars DATABASE_URL: postgres://<username>: <password>@<host>:<port>/<database> SECRET_KEY: <your_secret_key>

Isso significa que você tem duas variáveis de ambiente, DATABASE_URL e SECRET_KEY , que você pode usar nas configurações do seu projeto Django.

Agora que você criou um aplicativo Heroku e definiu as configurações necessárias para nosso projeto Django, você pode passar para a próxima etapa, que é implantar seu projeto Django no Heroku.

Como implantar seu projeto Django no Heroku usando o comando ` heroku `?

Para implantar nosso projeto Django no Heroku usando o comando heroku , você precisa seguir estas etapas:

- Vá para a pasta do projeto Django no terminal e digite heroku container:login para fazer login no Heroku Container Registry usando a ferramenta Heroku CLI. Isso permitirá que você envie nossa imagem Docker para o Heroku.

- Digite heroku container:push web -a django-docker-app para construir e enviar sua imagem Docker para o Heroku. Você precisa especificar o nome do seu aplicativo Heroku, que neste caso é django-docker-app . Você deverá ver algo assim:

 === Building web (Dockerfile) Sending build context to Docker daemon 1.024kB Step 1/9 : FROM python:3.9-slim ---> 7f5b6ccd03e9 Step 2/9 : ENV PYTHONUNBUFFERED 1 ---> Using cache ---> 64b5d0e40a22 Step 3/9 : RUN mkdir /code ---> Using cache ---> 4d8c638f2b6c Step 4/9 : WORKDIR /code ---> Using cache ---> e69c02a028cd Step 5/9 : COPY requirements.txt /code/ ---> Using cache ---> 8f0f3e0f2d8c Step 6/9 : RUN pip install -r requirements.txt ---> Using cache ---> 0f7b497d81ed Step 7/9 : COPY . /code/ ---> Using cache ---> c0a8e9a32b16 Step 8/9 : EXPOSE 8000 ---> Using cache ---> a1d36a4a2da4 Step 9/9 : CMD ["gunicorn", "django_docker.wsgi", "--bind", "0.0.0.0:8000"] ---> Using cache ---> f7f3c0418a1d Successfully built f7f3c0418a1d Successfully tagged registry.heroku.com/django-docker-app/web:latest === Pushing web (Dockerfile) The push refers to repository [registry.heroku.com/django-docker-app/web] f7f3c0418a1d: Pushed latest: digest: sha256:6cbbf22cf6aa60e0343e6d8e7c4c2eeb2e cb8fd5e82a42dfe5f4aeeb15af89ec size: 528 Your image has been successfully pushed. You can now release it with the 'container:release' command.

Isso significa que você construiu e enviou sua imagem Docker para o Heroku.

- Digite heroku container:release web -a django-docker-app para liberar nossa imagem Docker em nosso aplicativo Heroku. Você deverá ver algo assim:

 Releasing images web to django-docker-app... done

Isso significa que você liberou sua imagem Docker para seu aplicativo Heroku.

- Digite heroku run python manage.py migrate -a django-docker-app para executar as migrações de banco de dados em seu aplicativo Heroku. Isto criará as tabelas e índices necessários para o seu projeto Django no banco de dados PostgreSQL. Você deverá ver algo assim:

 Running python manage.py migrate on ⬢ django-docker-app... up, run.1234 (Free) Operations to perform: Apply all migrations: admin, auth, contenttypes, sessions, polls 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 auth.0010_alter_group_name_max_length... OK Applying auth.0011_update_proxy_permissions... OK Applying auth.0012_alter_user_first_name_max_length... OK Applying polls.0001_initial... OK Applying sessions.0001_initial... OK

Isso significa que você executou as migrações de banco de dados em seu aplicativo Heroku.

- Digite heroku open -a django-docker-app para abrir nosso aplicativo web implantado em um navegador web. Você deverá ver nosso projeto Django rodando no Heroku.

Você implantou com sucesso seu projeto Django no Heroku usando o comando heroku . Agora você pode aproveitar seu aplicativo da web e compartilhá-lo com outras pessoas.

Conclusão

Neste tutorial, você aprendeu como dockerizar e implantar aplicativos Django usando Docker, Django e Heroku. Você viu como o Docker pode ajudá-lo a criar ambientes isolados e reproduzíveis para seus aplicativos e como o Heroku pode simplificar o processo de implantação.

Você também aprendeu como usar o Docker Compose para gerenciar vários contêineres e serviços e como definir as configurações do Django para diferentes ambientes.

Dockerizar e implantar aplicativos Django pode trazer muitos benefícios, como:

- Ciclos de desenvolvimento e teste mais rápidos

- Colaboração e compartilhamento de código mais fáceis

- Desempenho consistente e confiável em todas as plataformas

- Escalabilidade e flexibilidade de recursos

- Segurança e isolamento de dependências

Recursos adicionais

- Documentação do Docker : A documentação oficial do Docker, onde você pode encontrar guias, tutoriais, materiais de referência e muito mais.

- Documentação do Django : A documentação oficial do Django, onde você pode encontrar tópicos, guias de procedimentos, materiais de referência e muito mais.