Para atualizar um projeto Django, na maioria das vezes você precisa de uma solução de prateleira na forma de uma biblioteca ou dependência.
Isso geralmente não é um problema e geralmente está documentado no arquivo requirements.txt .
O problema começa quando você tenta compartilhar o projeto inteiro com outro indivíduo que deseja executá-lo e testá-lo porque, infelizmente, o usuário terá que realizar a configuração do zero toda vez que você fizer alterações significativas nas bibliotecas e dependências.
O que é Docker?
É aqui que entra a conteinerização e o Docker . O Docker é uma plataforma de conteinerização incrivelmente popular que resolve as bibliotecas e o problema de dependência de uma vez por todas.
Mas qual é sua melhor característica? Independentemente do host ou da infraestrutura subjacente, seu aplicativo em contêineres sempre será executado da mesma maneira.
Este guia o orientará na configuração de um projeto Django com Docker.
Por que você deve usar o Docker?
Docker é um produto que oferece virtualização de hardware no nível do sistema operacional (SO). Essa capacidade permite que os desenvolvedores empacotem e enviem software e suas dependências para distribuir como contêineres .
Em termos simples, agora você pode agrupar todas as peças de que seu software precisa em uma única unidade chamada imagem docker e, em seguida, enviar ou compartilhar essa imagem com qualquer pessoa. E, desde que o destinatário tenha o Docker, ele poderá executar ou testar seu projeto. Já se foi o tempo de “Mas funcionou na minha máquina!”
O Docker também oferece um serviço chamado DockerHub que permite o compartilhamento e gerenciamento de imagens Docker entre desenvolvedores e comunidades-essencialmente, um “GitHub” para imagens Docker. Ele compartilha algumas semelhanças com a plataforma de repositório de código, como upload e download de imagens por meio de comandos CLI contidos no Docker CLI.
Pré-requisitos para usar Docker
- Proficiência no desenvolvimento de Django
- Nível intermediário com CLI e bash
Para este tutorial, o script do Docker é feito em arquivos YAML e os arquivos executados por meio da CLI do Docker.
Este guia explorará a configuração do Docker em uma máquina Ubuntu.
Para outras plataformas de sistema operacional comuns:
Para baixar e configurar o Docker, execute as instruções abaixo:
sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io
Aplicativo Django
Como este guia presume que você já é proficiente em Django, vamos demonstrar as etapas para executar um aplicativo Django Rest Framework básico no Docker e exibir a página padrão.
Considere-o o Hello world do Django e Docker. Depois disso, você pode encaixar qualquer projeto Django anterior ou futuro que você possa ter, especialmente um que tenha bibliotecas listadas em requirements.txt .
Para começar, execute os comandos abaixo para obter a configuração do aplicativo Django.
django-admin startproject dj_docker_drf
Navegue até a pasta do seu projeto, inicie um aplicativo chamado sample e adicione rest_framework e sample ao INSTALLED_APPS lista em settings.py .
No arquivo views.py , escreva uma função que retorne a mensagem, “OLÁ, MUNDO DO DJANGO E DOCKER”
de rest_framework.views import APIView
de django.http import JsonResponse classe HomeView (APIView): def get (self, request, format=None): return JsonResponse ({"mensagem": 'OLÁ, MUNDO DO DJANGO E DOCKER'})
Conecte o arquivo de URL principal e o arquivo de URL do aplicativo de forma que HomeView seja a visualização padrão acessada quando um usuário acessa o aplicativo no navegador.
Uma etapa crítica que muitos esquecem é configurar o ALLOWED_HOSTS para’*’a fim de permitir o acesso ao aplicativo Django de qualquer IP. O snippet de código é compartilhado abaixo
ALLOWED_HOSTS=[‘*’]
Finalmente, crie um arquivo requirements.txt na pasta raiz do projeto, onde ele normalmente reside, e adicione a biblioteca DRF:
django-rest-framework==0.1.0
O aplicativo agora está pronto para ser encaixado.
Criando os arquivos Docker e Docker CLI
Observe que o arquivo Docker tem um nome. Isso permite que a Docker CLI o rastreie.
Na raiz do seu projeto, crie um arquivo chamado Dockerfile e abra-o. As diretivas do Docker foram explicadas pelos comentários:
# imagem de base DE python: 3.8 # variável de ambiente de configuração ENV DockerHOME=/home/app/webapp # definir diretório de trabalho RUN mkdir-p $ DockerHOME # onde seu código reside WORKDIR $ DockerHOME # definir variáveis de ambiente ENV PYTHONDONTWRITEBYTECODE 1 ENV PYTHONUNBUFFERED 1 # instalar dependências RUN pip install-atualizar pip # copie o projeto inteiro para o diretório inicial do docker. CÓPIA DE. $ DockerHOME # execute este comando para instalar todas as dependências RUN pip install-r requisitos.txt # porta onde o aplicativo Django é executado EXPOR 8000 # iniciar servidor CMD python manage.py runserver
Executando o aplicativo no Docker
Para executar o aplicativo, você precisa realizar apenas duas etapas.
- Construir a imagem : isso é feito usando o comando
build, que usa oDockerfileque você acabou de criar. Para construir a imagem, execute o comandodocker build.-t docker-django-v0.0. Este comando deve ser executado no diretório onde reside o arquivo Docker. A sinalização-tmarca a imagem para que possa ser referenciada quando você deseja executar o contêiner. - Executar a imagem : isso é feito usando o comando
docker run. Isso converterá a imagem construída em um contêiner em execução
Agora, o aplicativo está pronto para uso!
Para executar o aplicativo, execute o comando docker run docker-django-v0.0 e visualize seu aplicativo no navegador em 0.0.0.0:8000.
Executando vários contêineres com Docker Compose
Com a proficiência obtida no Docker, a próxima etapa lógica é saber como executar vários contêineres e em que ordem.
Este é o caso de uso perfeito para Docker Compose , que é um ferramenta usada para definir e executar aplicativos multi-contêiner de qualquer tipo. Resumindo, se seu aplicativo tiver vários contêineres, você usará a CLI do Docker-Compose para executá-los na ordem necessária.
Considere, por exemplo, um aplicativo da web com os seguintes componentes:
- Contêiner de servidor da web, como NGINX
- Contêiner de aplicativo que hospeda o aplicativo Django
- Contêiner de banco de dados que hospeda o banco de dados de produção, como POSTGRES
- O contêiner de mensagens que hospeda o agente de mensagens, como RabbitMq
Para executar o sistema, você declarará as diretivas em um arquivo Docker-compose YAML , onde declara como as imagens serão construídas, em qual porta as imagens estarão acessíveis e, o mais importante, a ordem em que os contêineres serão executados (ou seja, qual contêiner depende de qual contêiner para o projeto ser executado).
Neste exemplo específico, você pode fazer uma estimativa calculada? Qual deve ser o primeiro contêiner a ser girado e qual contêiner depende do outro?
Para responder a essa pergunta, exploraremos o Docker Compose . Primeiro, siga este guia para instalar a ferramenta CLI em seu sistema operacional host.
Com o Docker Compose (e de forma semelhante ao Docker), um arquivo específico com um nome especial é necessário. É isso que a ferramenta CLI usa para ativar as imagens e executá-las.
Para criar um arquivo Docker Compose, crie um arquivo YAML e nomeie-o docker-compose.yml . Idealmente, ele deve existir no diretório raiz do seu projeto. Para entender melhor esse processo, vamos explorar o Docker Compose usando o cenário demonstrado acima: um aplicativo Django com um banco de dados Postgres, agente de mensagens RabbitMQ e um balanceador de carga NGINX.
Usando Docker Compose com um aplicativo Django
versão:'3.7' serviços: # as diferentes imagens que serão executadas como contêineres nginx: # nome do serviço build:./nginx # localização do dockerfile que define a imagem nginx. O dockerfile será usado para girar uma imagem durante o estágio de construção portas: -1339: 80 # mapeia a porta externa 1339 para a porta interna 80. Qualquer tráfego de 1339 externamente será passado para a porta 80 do contêiner NGINX. Para acessar este aplicativo, seria usado um endereço como 0.0.0.0:1339 volumes: # armazenamentos estáticos provisionados já que django não lida com arquivos estáticos em produção -static_volume:/home/app/microservice/static # fornece um espaço para arquivos estáticos depende de: -web # só iniciará se a web estiver instalada e funcionando reiniciar:"em falha"# reiniciar o serviço quando ele falhar web: # nome do serviço Construir:. #construa a imagem para o serviço da web a partir do dockerfile no diretório pai. # a diretiva de comando passa os parâmetros para o serviço e eles serão executados pelo serviço. Neste exemplo, esses são comandos django que serão executados no contêiner onde mora o django. comando: sh-c"python manage.py makemigrations && python manage.py migrate && gunicorn microservice_sample_app.wsgi: application--bind 0.0.0.0:${APP_PORT}"# Comandos Django para executar o aplicativo usando gunicorn volumes: -.:/microservice # mapear dados e arquivos do diretório pai no host para o diretório de microsserviço no contêiner do docker -static_volume:/home/app/microservice/static env_file: # arquivo onde as variáveis env são armazenadas. Usado como prática recomendada para não expor chaves secretas -.env # nome do arquivo env imagem: microservice_app # nome da imagem expor: # expõe a porta a outros serviços definidos aqui para que eles possam acessar esse serviço por meio da porta exposta. No caso do Django, é 8000 por padrão -$ {APP_PORT} # recuperado do arquivo.env reiniciar:"em falha" Depende_on: # não pode ser iniciado se o serviço db não estiver instalado e funcionando -db bd: # nome do serviço image: postgres: 11-alpine # nome da imagem do banco de dados postgres. durante a compilação, isso será retirado do dockerhub e um contêiner girado a partir dele volumes: -./init.sql:/docker-entrypoint-initdb.d/init.sql -postgres_data:/var/lib/postgresql/data/ ambiente: # acessar credenciais do arquivo.env -POSTGRES_PASSWORD=$ {POSTGRES_PASSWORD} -POSTGRES_DB=$ {DB_NAME} -PGPORT=$ {DB_PORT} -POSTGRES_USER=$ {POSTGRES_USER} reiniciar:"em falha" coelhomq: image: rabbitmq: 3-management-alpine # image a ser retirada do dockerhub durante a construção container_name: rabbitmq # nome do container volumes: # atribuir armazenamento estático para o rabbitmq executar rabbitmq:-./.docker/rabbitmq/etc/:/etc/rabbitmq/ -./.docker/rabbitmq/data/:/var/lib/rabbitmq/ rabbitmq_logs:-./.docker/rabbitmq/logs/:/var/log/rabbitmq/ ambiente: # variáveis de ambiente do arquivo.env referenciado RABBITMQ_ERLANG_COOKIE: $ {RABBITMQ_ERLANG_COOKIE} # auth cretendials RABBITMQ_DEFAULT_USER: $ {RABBITMQ_DEFAULT_USER} RABBITMQ_DEFAULT_PASS: $ {RABBITMQ_DEFAULT_PASS} portas: # mapeia portas externas para portas internas deste contêiner específico -5672: 5672 -15672: 15672 Depende_on: # só pode ser iniciado se o serviço da web estiver em execução -rede volumes: postgres_data: static_volume: coelhomq: rabbitmq_logs:
Um dos destaques do Docker Compose é a diretiva depends_on . A partir do script acima, podemos deduzir que:
- NGINX depende da web
- A web depende do db
- RabbitMQ depende da web
Com esta configuração, db será o primeiro a iniciar, seguido por web, seguido por RabbitMQ e por último, NGINX. Quando você decidir destruir o ambiente e interromper os contêineres em execução, a ordem será inversa. O NGINX será o primeiro a ser executado e o banco de dados o último.
Criação e execução de scripts Docker Compose
Assim como um script do Docker, o script do Docker Compose tem uma estrutura semelhante, pois possui comandos de compilação e execução. O comando build irá construir todas as imagens definidas em services na ordem da hierarquia de dependência. O comando run irá girar os contêineres na ordem da hierarquia de dependência.
Felizmente, existe um comando que combina construir e executar. É denominado up . Para executar este comando, execute o comando abaixo:
docker-compose up
Você também pode adicionar o sinalizador de construção. Isso é útil quando você já executou este comando antes e deseja construir novas imagens novamente.
docker-compose up —build
Quando terminar de usar os contêineres, você pode desligar todos eles e remover qualquer armazenamento estático que estavam usando, por exemplo, o volume estático do postgres. Para fazer isso, execute o comando abaixo:
docker-compose down-V
O sinalizador -V significa volumes. Isso garante que os contêineres e os volumes anexados sejam encerrados.
Siga a documentação oficial para saber mais sobre os vários comandos do Docker Compose e seu uso.
Arquivos de suporte no Docker
Existem alguns arquivos referenciados no script acima que tornam o arquivo menos volumoso, facilitando assim o gerenciamento do código. Isso inclui o arquivo ENV e NGINX Docker e arquivos de configuração. Abaixo estão alguns exemplos do que cada um envolve:
Arquivo ENV
O principal objetivo deste arquivo é armazenar variáveis como chaves e credenciais. Esta é uma prática de codificação segura que garante que suas chaves pessoais não sejam expostas.
#Django SECRET_KEY="my_secret_key" DEBUG=1 ALLOWED_HOSTS=localhost 127.0.0.1 0.0.0.0 [:: 1] * # credenciais de acesso ao banco de dados ENGINE=django.db.backends.postgresql DB_NAME=testdb POSTGRES_USER=testuser POSTGRES_PASSWORD=testpassword DB_HOST=db DB_PORT=5432 APP_PORT=8000 #superuser details DJANGO_SU_NAME=teste [email protected] DJANGO_SU_PASSWORD=mypass123 #rabbitmq RABBITMQ_ERLANG_COOKIE: test_cookie RABBITMQ_DEFAULT_USER: default_user RABBITMQ_DEFAULT_PASS: sample_password
Arquivo NGINX Docker
Está hospedado em uma pasta nginx no diretório raiz. Ele contém principalmente duas diretivas: o nome da imagem a ser obtido do hub Docker e a localização dos arquivos de configuração. É nomeado como qualquer outro arquivo Docker, Dockerfile .
DE nginx: 1.19.0-alpine RUN rm/etc/nginx/conf.d/default.conf COPIAR nginx.conf/etc/nginx/conf.d
Arquivo de configuração NGINX
É aqui que se escreve a lógica de configuração NGINX. Ele é colocado no mesmo local que o arquivo NGINX Docker na pasta NGINX.
Este arquivo é o que determina como o contêiner NGINX se comportará. Abaixo está um script de amostra que reside em um arquivo comumente denominado nginx.conf .
microsserviço upstream {# nome de nossa imagem da web servidor web: 8000; # porta django padrão
} servidor { escute 80; # porta externa padrão. Qualquer coisa vinda da porta 80 passará pelo NGINX localização/{ proxy_pass http://microservice_app; proxy_set_header X-Forwarded-For $ proxy_add_x_forwarded_for; proxy_set_header Host $ host; proxy_redirect off; } localização/estático/{ alias/home/app/microservice/static/; # onde nossos arquivos estáticos estão hospedados } }
Conclusão
As dicas e truques do Docker neste guia são vitais para DevOps e posições de desenvolvedor de pilha completa em qualquer organização, e o Docker também é uma ferramenta conveniente para desenvolvedores de back-end.
Como o Docker empacota dependências e bibliotecas, novos desenvolvedores não precisam necessariamente instalar várias dependências e perder um tempo precioso tentando fazer as bibliotecas e dependências funcionarem. Obrigado por ler.
A postagem Dockerizing um aplicativo Django apareceu primeiro em LogRocket Blog .
