Pesquisa de sites

Como Dockerizar uma Aplicação Django no Linux

Neste tutorial, vou mostrar como configurar um ambiente Docker para o seu projeto Django enquanto ainda está na fase de desenvolvimento. Embora eu esteja a usar o Ubuntu 18.04, os passos continuam os mesmos para qualquer distribuição Linux que utilize, com exceção da instalação do Docker e do docker-compose.

Em qualquer projeto típico de desenvolvimento de software, geralmente temos um processo de desenvolvimento que normalmente começa no ambiente do programador, passa pelo VCS e vai até à produção. Vamos tentar seguir as regras para que compreenda onde cada ferramenta DevOps entra.

DevOps trata-se de eliminar a frase dos anos passados: «Mas funciona no meu portátil!». A conteinerização com Docker cria o ambiente de produção para a sua aplicação de forma a que ela possa ser implantada em qualquer lugar. Desenvolva uma vez, implemente em qualquer lugar!

1) Instalar o Docker Engine

Precisa de ter um motor de execução Docker instalado no seu servidor/desktop. Os nossos guias de instalação do Docker deverão ser de grande ajuda.

Como instalar o Docker no CentOS/Debian/Ubuntu

2) Configuração do Ambiente

Criei um repositório no GitHub para este projeto chamado django-docker-dev-app. Sinta-se à vontade para fazer um fork ou clonar/descarregar.

Primeiro, crie a pasta para guardar o seu projeto. A minha pasta de trabalho chama-se django-docker-dev-app. Entre na pasta e depois abra-a no seu IDE.

Dockerfile

Num ambiente conteinerizado, todas as aplicações vivem num contentor. Os próprios contentores são constituídos por várias imagens. Pode criar a sua própria imagem ou usar outras imagens do Docker Hub. Um Dockerfile é um documento de texto do Docker que o Docker lê para criar/construir automaticamente uma imagem. O nosso Dockerfile irá listar todas as dependências necessárias para o nosso projeto.

Crie um ficheiro chamado Dockerfile.

nano Dockerfile

No tipo de ficheiro escreva o seguinte:

#base image
FROM python:3.9-alpine

#maintainer
LABEL Author="CodeGenes"

# The enviroment variable ensures that the python output is set straight
# to the terminal with out buffering it first
ENV PYTHONBUFFERED 1

#copy requirements file to image 
COPY ./requirements.txt /requirements.txt

#let pip install required packages
RUN pip install -r requirements.txt

#directory to store app source code
RUN mkdir /app

#switch to /app directory so that everything runs from here
WORKDIR /app

#copy the app code to image working directory
COPY ./app /app

#create user to run the app(it is not recommended to use root)
#we create user called user with -D -> meaning no need for home directory
RUN adduser -D user

#switch from root to user to run our app
USER user

Crie o ficheiro requirements.txt e adicione os requisitos do seu projeto.

Django
djangorestframework

Crie a pasta app que irá conter o código-fonte. Agora estamos prontos para criar a nossa imagem!

mkdir app

Abra um terminal no seu projeto e digite o seguinte comando para construir a nossa imagem:

 docker build .

No final, diz ao Docker para verificar se existe um Dockerfile na mesma diretoria; se o tivesse num local diferente, teríamos escrito o caminho para esse ficheiro. O Docker irá então chamar as imagens necessárias do Docker Hub para criar a sua imagem.

A utilizar o Docker Compose

A partir da documentação do Docker; o Compose é uma ferramenta para definir e executar aplicações Docker com múltiplos contêineres. Com o Compose, você utiliza um ficheiro YAML para configurar os serviços da sua aplicação. Depois, com um único comando, cria e inicia todos os serviços a partir da sua configuração.

  • Instalar o Docker Compose no Linux

Como o nosso projeto vai necessitar de muitos serviços no futuro, é melhor criar um ambiente com vários contentores. Por exemplo, podemos precisar de um contentor para alojar o nosso front-end, outro para alojar uma base de dados e outro para alojar o back-end quando mudarmos para uma arquitetura de microsserviços. Vamos criar um ficheiro docker-compose que definirá os vários serviços e contentores que o nosso projeto vai necessitar.

Crie um ficheiro chamado docker-compose.yml

version: "3"
services:
  ddda:
    build:
      context: .
    ports:
      - "8000:8000"
    volumes:
      - ./app:/app
    command: >
      sh -c "python manage.py runserver 0.0.0.0:8000"

Repara no formato de ficheiro YAML!!! Temos um serviço chamado ddda (Django Docker Dev App).

Estamos agora prontos para criar o nosso serviço:

docker-compose build

Após uma construção bem-sucedida, verá: Successfully tagged djangodockerdevapp_ddda:latest

Significa que a nossa imagem se chama djangodockerdevapp_ddda:latest e o nosso serviço chama-se ddda

Note que ainda não criámos o nosso projeto Django! Se seguiu o procedimento acima com sucesso, então parabéns, configurou o ambiente Docker para o seu projeto!. De seguida, comece o seu desenvolvimento fazendo o seguinte:

Cria o projeto Django:

 docker-compose run ddda sh -c “django-admin.py startproject app .”

Para executar o seu contentor:

docker-compose up

Então visite http://localhost:8000/

Executar migrações

$ docker-compose exec ddda python manage.py migrate

De agora em diante, irá executar comandos Django como o comando acima, adicionando o seu comando após o nome do serviço ddda.

É tudo por agora. Sei que é simples e há muitas funcionalidades que não abordámos, como uma base de dados, mas isto é um começo!

O projeto está disponível no GitHub aqui.

Mais sobre o Docker:

  • Exportar e Importar Imagens/Contêineres Docker
  • Instalar o Harbor Docker Image Registry no CentOS/Debian/Ubuntu
  • Como executar clusters Kubernetes locais no Docker