Neste artigo será apresentado as etapas iniciais do desenvolvimento do projeto, como explicado no artigo anterior, primeiro será desenvolvido a API e em seguida o app android. Antes de iniciar gostaria de deixar uma informaçõa clara, as tecnologias que serão utilizadas neste projeto foram escolhidas devido atenderem perfeitamente a ideia do projeto, serem todas open-source, além de serem as tecnologias que eu possuo o maior domínio no desenvolvimento de software neste momento.

Todo o backend será desenvolvido utilizando docker, desta forma, há um isolamento das bibliotecas instaladas, permitindo que desta forma haja o mesmo ambiente em desenvolvimento, e em produção, minimizando possíveis incompatibilidades entre máquinas. Caso você não conheça docker, recomendo este curso gratuito: Descomplicando o Docker.

As ferramentas que deverão ser instaladas no seu ambiente de desenvolvimento, serão o docker e um editor de código, recomendo o vscode. Todo o código desenvolvido da API está disponível no github: https://github.com/luisgs7/cashwallet-api.

Configurando o Docker e Docker Compose

A primeira etapa é configurar o Dockerfile, neste arquivo contém uma descição das atividades a serem realizadas para a configuração do ambiente docker, assim como o docker-compose, que será apresentado em seguida. O formato de escrita do arquivo é o yml.

FROM python:3.10-alpine

LABEL maintainer="iadevlab.com"

ENV PYTHONUNBUFFERED 1

COPY ./requirements.txt /tmp/requirements.txt

COPY ./app /app

WORKDIR /app

EXPOSE 8000

ARG DEV=false

RUN python -m venv /py && \

   /py/bin/pip install --upgrade pip && \

   apk add --update --no-cache postgresql-client jpeg-dev && \

   apk add --update --no-cache --virtual .tmp-build-deps \

   build-base postgresql-dev musl-dev zlib zlib-dev linux-headers && \

   /py/bin/pip install -r /tmp/requirements.txt && \

   rm -rf /tmp && \

   adduser \

       --disabled-password \

       --no-create-home \

       django-user && \

       chown -R $(whoami):$(whoami) /app/

ENV PATH="/py/bin:$PATH"

USER django-user

Após a configuração do Dockerfile, a próxima etapa é a configuração do docker-compose.yml, neste arquivo será detalhado quais containers serão criados, e a partir de que imagem, além de configurações como variáveis de ambiente, e volumes.

version: "3.9"

services:

 app:

   user: $UID:$GID

   build:

     context: .

     args:

       - DEV=true

   ports:

     - "8000:8000"

   volumes:

     - ./app:/app

     - dev-static-data:/vol/web

   command: >

     sh -c "python manage.py wait_for_db &&

            python manage.py migrate &&

            python manage.py runserver 0.0.0.0:8000"

   environment:

     - DB_HOST=db

     - DB_NAME=${DB_NAME}

     - DB_USER=${DB_USER}

     - DB_PASS=${DB_PASS}

     - SECRET_KEY=${SECRET_KEY}

     - ALLOWED_HOSTS=${ALLOWED_HOSTS}

     - DEBUG=${DEBUG}

   depends_on:

     - db

 db:

   image: postgres:13-alpine

   volumes:

     - ./db:/var/lib/postgresql/data

   environment:

     - POSTGRES_DB=${DB_NAME}

     - POSTGRES_USER=${DB_USER}

     - POSTGRES_PASSWORD=${DB_PASS}

volumes:

 dev-static-data:

É importante destacar que estas configurações do docker-compose são para o ambiente de desenvolvimento, em ambiente de produção haveria algumas modificações, mas isso pode ser discutido mais adiante. Todas as variáveis que possuem esta sintaxe ${DB_NAME}, são variáveis que recebem valores a partir de variáveis de ambiente, utilizando um arquivo .env criado na raiz do projeto, na mesma localização do Dockerfile e docker-compose.yml. 

A partir disso, o docker consegue ler este arquivo e enviar o valor destas variáveis para o arquivo de docker-compose e em seguida permitir que o python também possa acessar estas variáveis dentro do projeto, no .env(lê se dotenv) é adicionado configurações como informações de acesso a banco de dados, secretkey do django project, além de qualquer informação secreta, que possa comprometer a segurança da aplicação deve ser adicionada ao arquivo .env.

Para que um outro desenvolvedor saiba quais variáveis são necessárias para a aplicação, criasse um arquivo .env.example que é uma cópia do .env sem os valores secretos, somente com as variáveis a serem configuradas, esse sim deve ser adicionado ao controle de versão do git, o .env deve ser adicionado ao .gitignore. Para mais informações sobre este conceito de variáveis de ambiente, recomendo este vídeo: https://youtu.be/ManNsAeIVSc.

# Database Name

DB_NAME="app_db"

# Database User

DB_USER="user_db"

# Database Password

DB_PASS=password

# True or False

DEBUG=1

# Django secret key

SECRET_KEY='1234'

# Django Allowed Hosts

ALLOWED_HOSTS='0.0.0.0'

Também é necessário criar um arquivo .gitignore, com arquivos e pastas que não devem ser adicionadas ao controle de versão do git: https://github.com/luisgs7/cashwallet-api/blob/main/.gitignore. Caso você desconheça git, recomendo este curso gratuito, que irá apresentar os fundamentos iniciais desta incrível ferramenta:  https://www.udemy.com/course/git-e-github-para-iniciantes/, e caso queira aprender git mais avançado, tem também este curso gratuito: Git e Github na vida real. 

Dependências do Projeto

Para que seja possível instalar todas as dependências no projeto, será criado um arquivo requirements.txt, que basicamente contém o nome das dependências e versões de cada uma a serem instaladas, ele é semelhante ao package.json do javascript e o gemfile do rails.

Django==3.2

djangorestframework==3.14.0

pylint==2.15.2

flake8==4.0.1

psycopg2>=2.8.6,<2.9

drf-spectacular>=0.15.1,<0.16

É importante explicar que o Django possui uma versão mais recente disponível, mas a LTS, que fornece suporte até meados de 2024, é a 3.2. Link para mais informações: https://www.djangoproject.com/download/. As outras bibliotecas instaladas, serão explicadas as suas funcionalidades no decorrer do projeto.

Caso você não conheça o Django recomendo estes tutoriais:

1 - Documentação: https://www.djangoproject.com/ 

2 - https://youtu.be/DNGI5aD9MJs (Iniciante)

3- https://youtu.be/K0pVZmw_pJU (Iniciante-Intermediário)

Agora para o desenvolvimento da API, será utilizado uma outra biblioteca, o Django Rest Framework ou DRF, para você que não conheçe recomento estes tutoriais:

1 - Documentação: https://www.django-rest-framework.org/ 

2 - https://youtu.be/gFsIGJR5R8I (Iniciante)

3 - https://youtu.be/I8IAJ3asw5w (Iniciante-Intermediário)

Caso você desconheça o conceito de Rest API, recomendo este vídeo: https://youtu.be/jvNDM5e7TFo, somente os 10 minutos iniciais são suficientes para compreender o conceito, que é análogo a tecnologia que você está utilizando.

Criando o Django Project

O framework Django possui o conceito de Project, que se refere a um pacote python, que contém todas as configurações de uma instancia do Django, neste pacote há configurações de acesso a banco de dados, middlewares, configurações especificas do Django e configurações das Apps Django, que serão explicadas mais adiante, além de vários outros recursos. 

Caso você utilize uma distribuição Linux, execute este comando antes de criar o Django project, para que você tenha permissão de acesso ao container docker.

export UID=${UID} && export GID=${GID}

Agora crie uma pasta na raiz do projeto com o nome app. Em seguida execute o comando abaixo para o docker construir os containers que descremos anteriormente, nos arquivos yml.

docker compose build

Em seguida execute o comando abaixo para criar o Django project através do docker.

docker-compose run –rm app sh -c "django-admin.py startproject app ."

Agora você terá dentro da pasta app que você criou um pacote python com o nome app, e dentro deste pacote alguns módulos python. A estrutura de arquivos será semelhante a esta.

app/

    manage.py

    app/

        __init__.py

        settings.py

        urls.py

        asgi.py

        wsgi.py

• A pasta raiz app/ é a pasta que foi criada anteriormente

• O módulo manage.py é um utilitário de linha de comando, que permite interagir com o projeto, para criar um superuser, criar apps, realizar migrations de banco de dados, dentre outras opções.

• O pacote python app/ que fica ao lado do módulo manage.py, é o pacote do projeto django.

• O app/__init__.py é um módulo python vazio, que informa ao interpretador do python que esta pasta se trata de um pacote python.

• O app/settings.py é um módulo responsável pelas definições e configurações do projeto django.

• O app/urls.py é o módulo responsável pelas rotas do projeto django.

• O app/asgi.py é o módulo de entrada para servidores ASGI do Python, utilizado durante o deploy.

• O app/wsgi.py é o módulo de entrada para servidores WSGI do Python, utilizado também apenas no deploy do projeto.

Agora para finalizar o artigo de hoje, vamos conferir se o projeto está com as configurações iniciais corretas, para isto execute o comando baixo no terminal.

docker compose up

Se tudo estiver correto você poderá ver a página inicial do Django acessando esta url: http://127.0.0.1:8000/, e verá uma mensagem. You’ll see a “Congratulations!” page, with a rocket taking off. It worked!