Category: Python

A dockerização de uma aplicação Django representa um avanço significativo na forma como desenvolvedores lidam com ambientes de desenvolvimento e implantação. Em vez de enfrentar problemas de compatibilidade entre sistemas operacionais, versões de bibliotecas ou configurações locais, o Docker permite encapsular toda a aplicação Django — junto com suas dependências, banco de dados, configurações e bibliotecas — dentro de um contêiner leve, portátil e padronizado.

Esse processo assegura que a aplicação funcione de maneira idêntica em qualquer ambiente, seja no computador do desenvolvedor, em um servidor de teste ou em um ambiente de produção na nuvem. Além disso, a dockerização oferece uma maneira eficiente de gerenciar múltiplos serviços, como o servidor web, o banco de dados e o cache, dentro de uma única estrutura controlada.

Com o uso do Docker Compose, por exemplo, é possível orquestrar todos os componentes de uma aplicação Django com apenas um comando, facilitando o processo de inicialização, integração e manutenção do projeto. Essa abordagem promove maior consistência, escalabilidade e agilidade no ciclo de desenvolvimento.

Em suma, a dockerização de uma aplicação Django é uma prática moderna e essencial para desenvolvedores que buscam ambientes previsíveis, implantações rápidas e colaboração eficiente entre equipes, reduzindo erros e simplificando a jornada entre o desenvolvimento e a produção.

Benefícios do Docker Para Uma Aplicação Django:

O Docker oferece uma infinidade de vantagens para desenvolvedores Django. Um benefício chave é a garantia de consistência em vários ambientes. Ao empacotar o aplicativo Django com todas as suas dependências, o Docker elimina o dilema “mas funciona na minha máquina”. Esta uniformidade se estende desde configurações de desenvolvimento local até implantações em produção, promovendo uma colaboração mais suave e reduzindo problemas de compatibilidade.

Além disso, o Docker simplifica significativamente o processo de implantação. Sua abordagem baseada em contêineres simplifica o fluxo de trabalho de implantação, permitindo que os desenvolvedores empacotem a aplicação Django junto com suas configurações e dependências em uma única unidade, facilmente implantável em diferentes servidores ou plataformas na nuvem.

Configurando o Docker para Django

Passos para Instalação do Docker:

Instalar o Docker é o primeiro passo para dockerizar sua aplicação Django. O Docker fornece guias de instalação abrangentes para vários sistemas operacionais em seu site oficial. Para a maioria dos sistemas, o Docker Desktop é a opção preferida para um processo de instalação direto.

1. Selecione Seu Sistema Operacional: Visite o site do Docker e baixe o Docker Desktop para o seu sistema operacional específico. Siga as instruções na tela para completar a instalação.
2. Verifique a Instalação: Uma vez instalado, verifique a instalação do Docker executando docker –version no seu terminal ou prompt de comando. Este comando deve exibir a versão instalada do Docker, confirmando uma instalação bem-sucedida.

Configurando o Docker para uma Aplicação Django:

Após instalar o Docker, você terá que criar um arquivo chamado Dockerfile dentro do projeto Django, onde a configuração atual será adicionada, criando como resultado a imagem que posteriormente será usada para criar o container…

1. Crie um Dockerfile: No diretório raiz do seu projeto Django, crie um arquivo chamado Dockerfile. Este arquivo conterá instruções para construir a imagem Docker para seu aplicativo Django.

project_directory/
│
├── Dockerfile # <-------------
├── DjangoProject/
├── DjangoApp/
└── manage.py

project_directory/
│
├── Dockerfile # <-------------
├── DjangoProject/
├── DjangoApp/
└── manage.py

Criando um Dockerfile para a Aplicação Django:

Um Dockerfile é um arquivo de texto que contém um conjunto de instruções necessárias para construir uma imagem Docker. Ele especifica o ambiente e a configuração necessária para que sua aplicação Django seja executada dentro de um contêiner Docker.

Os componentes necessarios para o Dockerfile para nossa Aplicação Django:

1 – Declaração da Imagem Base: Comece seu Dockerfile declarando a imagem base. Tipicamente, a imagem base para aplicações Django é uma imagem oficial do Python.

Por exemplo:

FROM python:3.9

FROM python:3.9

2 – Definindo o Diretório de Trabalho na Aplicação Django: Defina o diretório de trabalho dentro do contêiner onde seu projeto Django residirá:

WORKDIR /app

WORKDIR /app

3 – Copiando Requisitos e Instalando Dependências: Copie o arquivo requirements.txt para dentro do contêiner e instale as dependências. Este passo garante que os pacotes Python necessários para seu aplicativo Django sejam instalados dentro do contêiner Docker:

# Instale as dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Instale as dependências
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

4 – Copiando Arquivos da Aplicação Django: Copie todo o diretório do projeto Django para dentro do contêiner:

COPY . /app/

COPY . /app/

5 – Definindo Variáveis de Ambiente e Executando a Aplicação Django: Defina quaisquer variáveis de ambiente necessárias e o comando para iniciar a aplicação Django:

# Exponha a porta que a aplicação usará
EXPOSE 8000

# Exponha a porta que a aplicação usará
EXPOSE 8000

Guia Passo a Passo:

Aqui está um guia passo a passo para escrever um Dockerfile especificamente adaptado para aplicações Django:

1. Crie um novo arquivo chamado Dockerfile no diretório raiz do seu projeto Django.
2. Declare a imagem base usando FROM python:3.9.
3. Defina o diretório de trabalho dentro do contêiner com WORKDIR /app.
4. Copie o arquivo requirements.txt e instale as dependências.
5. Copie todo o diretório do projeto Django para dentro do contêiner COPY . /app/.
6. Exponha a porta que a aplicação usará EXPOSE 8000.

Com isso o arquivo Dockerfile precisa estar desta maneira:

FROM python:3.9

# Defina o diretorio que ira copiar os arquivos 
WORKDIR /app

# Instale as dependências no container
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copie os dados do diretorio local para o diretorio do container que foi criado acima
COPY . /app/

# Exponha a porta que a aplicação usará
EXPOSE 8000

FROM python:3.9

# Defina o diretorio que ira copiar os arquivos 
WORKDIR /app

# Instale as dependências no container
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copie os dados do diretorio local para o diretorio do container que foi criado acima
COPY . /app/

# Exponha a porta que a aplicação usará
EXPOSE 8000

Docker Compose para Aplicações Multi-Contêiner

O Docker Compose é uma ferramenta que permite aos desenvolvedores definir e gerenciar aplicações Docker multi-contêiner. Ele simplifica o processo de definição, execução e conexão de múltiplos contêineres Docker, sendo particularmente útil para aplicações complexas com serviços interconectados, como aplicações Django que dependem de bancos de dados ou outros serviços.

Neste exemplo, criaremos um arquivo docker-compose.yml para gerenciar dois contêineres: o contêiner da aplicação Python + Django e um contêiner de banco de dados para PostgreSQL.

Papel do Docker Compose em uma Aplicação Django:

Em uma configuração típica de aplicação Django, serviços adicionais como bancos de dados (por exemplo, PostgreSQL, MySQL) ou sistemas de cache (por exemplo, Redis) complementam o servidor central Django. O Docker Compose ajuda a orquestrar esses serviços, definindo suas configurações e interconexões dentro de um único arquivo YAML.

Criando um docker-compose.yml para nossa aplicação Django:

Para criar um arquivo docker-compose.yml adaptado para nossa aplicação Django, siga estes passos:

1. Crie um Novo Arquivo: Comece criando um novo arquivo chamado docker-compose.yml no diretório raiz do seu projeto Django (mesmo lugar onde voce criou o arquivo Dockerfile).
2. Definindo Serviços Django e Banco de Dados: Defina os serviços necessários para sua aplicação Django, como web para o servidor Django e db para o banco de dados. Especifique as configurações necessárias para cada serviço. Um exemplo do arquivo:

version: '3'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    depends_on:
      - db

  db:
    image: postgres:latest # <--- pegando a imagem direto do docker 
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword

version: '3'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    depends_on:
      - db

  db:
    image: postgres:latest # <--- pegando a imagem direto do docker 
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword

Explicação da Configuração YAML:

O serviço web constrói a imagem Docker a partir do diretório atual, executa o servidor de desenvolvimento Django na porta 8000 dentro do container e configura um volume para recarregamento de código em tempo real.

Ah, ja iria me esquecer voce viu que o projeto django dentro do container esta 8000? Lembra que nos espomos a porta 8000 no dockerfile tambem? Pois bem no codigo acima voce ve que estamos apontando a porta interna onde o django esta se comunicando para a porta host do container. Assim podemos ter acesso na nossa maquina.

O serviço db usa a imagem do PostgreSQL e define variáveis de ambiente para configuração do banco de dados que serão usadas para inserir nas configurações do Django posteriormente.

Executando o Docker Compose:

Execute o comando docker-compose up no mesmo diretório onde seu arquivo docker-compose.yml está localizado. O Docker Compose lê o arquivo e inicia os serviços definidos.

E qual é a relação entre Dockerfile e docker-compose.yml?

A relação entre o Dockerfile e o arquivo docker-compose.yml está em seus papéis dentro de uma aplicação baseada em Docker:

• Dockerfile: Define as instruções de configuração para construir uma única imagem Docker. Ele foca na configuração de um serviço contêinerizado específico (por exemplo, um aplicativo Django, um banco de dados). Este arquivo descreve como criar uma imagem de contêiner individual.
• docker-compose.yml: Orquestra e gerencia múltiplos contêineres como uma aplicação coesa. Este arquivo descreve as relações entre diferentes serviços, especificando como vários contêineres interagem, suas configurações, dependências, rede e volumes.

Estrutura de uma aplicação django:

Se você ja esta acostumado com a estrutura de arquivos de um projeto django. Assim que deve ficar o mesmo depois de adicionar os arquivos Docker e docker-compose.yml..

project_directory/
│
├── manage.py
├── DjangoApp/
|   └── ...
├── DjangoProject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── Dockerfile
├── requirements.txt
└── docker-compose.yml

project_directory/
│
├── manage.py
├── DjangoApp/
|   └── ...
├── DjangoProject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── Dockerfile
├── requirements.txt
└── docker-compose.yml

Conclusão

Dockerizar uma aplicação Django fornece uma maneira eficiente de encapsular, implantar e gerenciar seus projetos. Através deste passo-a-passo, nos aprofundamos nos conceitos fundamentais do Docker e demonstramos como conteinerizar um aplicativo Django usando Docker e docker-compose.

Ao aproveitar a tecnologia de conteinerização do Docker, os desenvolvedores podem garantir consistência em ambientes de desenvolvimento, teste e produção, promovendo uma colaboração mais fácil e fluxos de trabalho de implantação mais suaves.

O Docker simplifica o processo de empacotamento do seu aplicativo Django e suas dependências em um contêiner portátil, eliminando problemas relacionados ao ambiente e facilitando a escalabilidade contínua.

Ao navegar em seu aprendizado de Docker e Django, lembre-se de que este guia serve como ponto de partida. Experimente recursos adicionais do Docker, ajuste suas configurações e mergulhe em estratégias avançadas de implantação para otimizar seu pipeline de desenvolvimento.

O Django, um poderoso framework web escrito em Python, tem desempenhado um papel significativo no panorama do desenvolvimento de aplicações web.

Desde sua criação por Adrian Holovaty e Simon Willison, o Django tem sido uma ferramenta essencial para desenvolvedores que buscam construir aplicações robustas, eficientes e escaláveis.

Nesta postagem introdutória, exploraremos os fundamentos do Django. Trazendo a essência de sua arquitetura e destacando os princípios-chave que o tornam uma escolha preferencial para projetos web.

Ao compreender o funcionamento interno do framework Django, você estará preparando o terreno para um aprendizado que abrange desde a definição de modelos até a criação de interfaces de usuário dinâmicas.

História da Criação do Framework Django

O framework Django foi criado por Adria e Simon quando os mesmos trabalhavam em uma radio chamada Lawrence Journal-World.

Com alta demanda de novas funcionalidades os desenvolvedores perceberam que estavam fazendo serviços repetitivos. E com isso muitas funcionalidades foram criadas para resolver esses tipos de demanda.

Por exemplo, inicialmente o django foi criado para criar sites complexos com conectividade para bancos de dados. Porem ao passar o tempo e com diferentes demandas, o projeto teve a necessidade de se focar em reutilização e a componentização do codigo.

Com isso, o django se tornou literalmente um framework com desenvolvimento rapido e sem a necessidade de repetição de código.

Estrutura MVC (Model-View-Controller) do Framework Django

MVC (Model-View-Controller) é um padrão de arquitetura de software que organizam o código de uma aplicação de maneira eficiente, separando as responsabilidades e melhorando a manutenção do código. Utilizados em contextos de desenvolvimento web, sendo MVC associado a muitos frameworks, assim como o framework Django, Ruby on Rails e Laravel por exemplo.

MVC (Model-View-Controller):

Model (Modelo):

Representa a estrutura de dados e a lógica da aplicação. Responsável por interagir com o banco de dados, realizar cálculos e processar dados.

View (Visão):

É responsável pela apresentação e exibição dos dados para o usuário. Recebe informações do modelo e apresenta ao usuário final.

Controller (Controlador):

Gerencia a interação entre o modelo e a visão. Responde a eventos do usuário e atualiza o modelo ou a visão conforme necessário.

O fluxo típico em um modelo MVC é o seguinte:

1. O usuário interage com a View.
2. A View notifica o Controller sobre a interação.
3. O Controller atualiza o Model conforme necessário.
4. O Model notifica a View sobre as alterações.
5. A View é atualizada para refletir as mudanças no Model.

Porem o django tem uma pequena variação deste padrão de arquitetura de software colocando o como MVT (Model-View-Template).

MVT (Model-View-Template):

Model (Modelo):

Similar ao MVC, representa a lógica de negócios e interage com o banco de dados.

View (Visão):

Lida com a apresentação dos dados e interação do usuário, mas, no contexto do Django, a View é mais fina que no MVC. Ela se concentra em processar a entrada e saída.

Template (Modelo de Apresentação):

Diferentemente do MVC, o MVT introduz o conceito de Template. O Template lida com a representação visual dos dados e é responsável pela geração do HTML final.

Provavelmente você percebeu que o django não tem necessariamente a camada controller em sua arquitetura. Essa é uma discussão comum na comunidade. Porém eu posso te dizer que realmente existe mas esta acoplada dentro do view.

Como assim? Como você viu acima o controller gerencia a interação entre o modelo e a visão. Responde a eventos do usuário e atualiza o modelo ou a visão conforme necessário. E é isso que o view do django faz, recebendo também a reponsabilidade do controller.

Resumindo, o view do django, ao receber a requisição pela url, faz a logica de apresentação, caso necessario a busca de dados se comunica com o model (que se comunica com o banco de dados). ao receber os dados, envia-os ao template no qual e renderizado o html e finalmente o envia como resposta para o usuario final.

Principais Componentes do Framework Django

O django, sendo um framework web Python, é composto por vários componentes que simplificam o desenvolvimento de aplicações web.

Estes são os principais componentes do framework django:

Models (Modelos):

Define a estrutura do banco de dados usando classes Python. Os modelos são mapeados para tabelas no banco de dados, proporcionando uma abstração conveniente para interação com o banco de dados.

Exemplo de codigo de models no django (models.py):

from django.db import models

class Customer(models.Model):
  customer_id = models.UUIDField(primary_key=True, editable=False)
  first_name = models.CharField(max_length=120)
  last_name = models.CharField(max_length=120)
  phone = models.CharField(max_length=20, blank=True, null=True)
  email = models.EmailField(max_length=255, **options)
  street = models.CharField(max_length=255)
  street = models.CharField(max_length=120)
  state = models.CharField(max_length=120)
  zip_code = models.CharField(max_length=120)
  
  def __str__(self):
    return self.first_name

from django.db import models

class Customer(models.Model):
  customer_id = models.UUIDField(primary_key=True, editable=False)
  first_name = models.CharField(max_length=120)
  last_name = models.CharField(max_length=120)
  phone = models.CharField(max_length=20, blank=True, null=True)
  email = models.EmailField(max_length=255, **options)
  street = models.CharField(max_length=255)
  street = models.CharField(max_length=120)
  state = models.CharField(max_length=120)
  zip_code = models.CharField(max_length=120)
  
  def __str__(self):
    return self.first_name

Ao migrar o codigo criado acima será criado uma tabela no banco de dados SQL onde o django poderá acessa-lo usando o seu ORM.

ORM (Object-relational-mapping)

O framework django, por meio do seu ORM (Mapeamento Objeto-Relacional), adiciona uma camada de abstração ao desenvolvimento de aplicações web. Ao representar modelos Python como entidades do banco de dados.

Essa ferramenta facilita a interação com dados, permitindo operações de banco de dados sem a necessidade de consultas SQL diretas.

from .models import Customer

>>> Customer.objects.all() # retorna todos os customers (clientes)
# resultado: [<Customer: Debra>, <Customer: Kasha>, <Customer: Tameka> ...]

>>> Customer.objects.filter(state='CA') # retorna todos os customers do estado 'CA'
# resultado: [<Customer: Kasha>, <Customer: Tameka>, <Customer: Charolette> ...]

>>> Customer.objects.get(customer_id=9) # retorna um customer especifico pelo id
# resultado: <Customer: Genoveva>

from .models import Customer

>>> Customer.objects.all() # retorna todos os customers (clientes)
# resultado: [<Customer: Debra>, <Customer: Kasha>, <Customer: Tameka> ...]

>>> Customer.objects.filter(state='CA') # retorna todos os customers do estado 'CA'
# resultado: [<Customer: Kasha>, <Customer: Tameka>, <Customer: Charolette> ...]

>>> Customer.objects.get(customer_id=9) # retorna um customer especifico pelo id
# resultado: <Customer: Genoveva>

Essa integração transparente entre a programação orientada a objetos e as consultas ao bancos de dados relacionais é fundamental para a eficiência e simplicidade que o framework django oferece aos desenvolvedores.

Views (Visões):

Processa a lógica da aplicação, interagindo com o modelo e gerando uma resposta para o usuário. As Views podem renderizar templates, retornar JSON para APIs ou executar outras ações com base nas solicitações do usuário.

from django.shortcuts import render
from .models import Customer

def index(request):
    customers = Customer.objects.all() # --> retorno dos dados.
    context = {'customers': customers} # --> contexto que será passado para template.
    return render(request, 'myapp/index.html', context) # --> junção dos dados com a template.

from django.shortcuts import render
from .models import Customer

def index(request):
    customers = Customer.objects.all() # --> retorno dos dados.
    context = {'customers': customers} # --> contexto que será passado para template.
    return render(request, 'myapp/index.html', context) # --> junção dos dados com a template.

Logo no exemplo acima, você pode perceber toda a junção da listagem dos customers, a passagem desta listagem para o contexto que será passado para ser resera passado e renderizado na template.

Templates (Modelos de Apresentação):

Define a camada de apresentação da aplicação. Os templates utilizam a linguagem de template do framework django para criar páginas HTML dinâmicas, incorporando dados fornecidos pela View.

<!-- myapp/templates/myapp/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Customer List</title>
</head>
<body>
    <h1>Customer List</h1>
    
    <div class="container">
        {% for customer in customers %}
            <h3>{{ customer.first_name }} {{ customer.last_name }}</h3>
            <h4>Email: {{ customer.email }}</h4>
            <h4>Phone: {{ customer.phone }}</h4>
        {% endfor %}
    </div>
    
</body>
</html>

<!-- myapp/templates/myapp/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Customer List</title>
</head>
<body>
    <h1>Customer List</h1>
    
    <div class="container">
        {% for customer in customers %}
            <h3>{{ customer.first_name }} {{ customer.last_name }}</h3>
            <h4>Email: {{ customer.email }}</h4>
            <h4>Phone: {{ customer.phone }}</h4>
        {% endfor %}
    </div>
    
</body>
</html>

Ja no exemplo acima, você pode notar o uso da linguagem de template do framework django como tags {% %}. Onde será usada logica para renderizar os dados passados da view para a template, retornando como HTML puro.

URLs (Roteamento de URL):

Mapeia URLs da aplicação para funções ou classes de View específicas. O roteamento é configurado no arquivo urls.py e ajuda a direcionar as solicitações do usuário para as Views apropriadas.

# myapp/urls.py
from django.urls import path
from .views import index

urlpatterns = [
    path('', index, name='customer_list'),
]

# myapp/urls.py
from django.urls import path
from .views import index

urlpatterns = [
    path('', index, name='customer_list'),
]

Admin Site (Site de Administração):

Oferece uma interface administrativa pronta para uso. Os modelos registrados no admin site podem ser gerenciados de forma fácil e intuitiva, facilitando a administração do sistema.

Forms (Formulários):

Facilita a manipulação e validação de dados de formulários. Os formulários no Django podem ser gerados automaticamente a partir de modelos ou criados manualmente para processar entradas do usuário.

# myapp/forms.py
from django import forms
from .models import Customer

class CustomerForm(forms.ModelForm):
    class Meta:
        model = Customer
        fields = [
        'customer_id', 
        'first_name', 
        'last_name', 
        'email', 
        'street', 
        'state', 
        'zip_code'
      ]

# myapp/forms.py
from django import forms
from .models import Customer

class CustomerForm(forms.ModelForm):
    class Meta:
        model = Customer
        fields = [
        'customer_id', 
        'first_name', 
        'last_name', 
        'email', 
        'street', 
        'state', 
        'zip_code'
      ]

Usando o CustomerForm poderemos criar em uma nova template um formulario para criação de novos customers ou update de um customer especifico.

Com isso poderemos criar uma nova url e uma nova view para gerenciar esta criação.

# myapp/views.py
from django.shortcuts import render, redirect
from .models import Customer
from .forms import CustomerForm

def index(request):
    customers = Customer.objects.all()
    context = {'customers': customers}
    return render(request, 'myapp/index.html', context)

def create_customer(request): # --> NOVO CODIGO para gestão e controle do formulario.
    if request.method == 'POST':
        form = CustomerForm(request.POST) # --> Contexto que tambem sera passado para template
        if form.is_valid():
            form.save()
            return redirect('customer_list')
    else:
        form = CustomerForm() # --> Caso a requisição seja GET.

    return render(request, 'myapp/create_customer.html', {'form': form}) # --> contexto

# myapp/views.py
from django.shortcuts import render, redirect
from .models import Customer
from .forms import CustomerForm

def index(request):
    customers = Customer.objects.all()
    context = {'customers': customers}
    return render(request, 'myapp/index.html', context)

def create_customer(request): # --> NOVO CODIGO para gestão e controle do formulario.
    if request.method == 'POST':
        form = CustomerForm(request.POST) # --> Contexto que tambem sera passado para template
        if form.is_valid():
            form.save()
            return redirect('customer_list')
    else:
        form = CustomerForm() # --> Caso a requisição seja GET.

    return render(request, 'myapp/create_customer.html', {'form': form}) # --> contexto

Ao criar o formulario e a view com o contexto que sera enviado para o template, podemos criar a url para você entender como ira ficar:

# myapp/urls.py
from django.urls import path
from .views import index, create_customer

urlpatterns = [
    path('', index, name='customer_list'),
    path('create_customer/', create_customer, name='create_customer'), # --> nova url
]

# myapp/urls.py
from django.urls import path
from .views import index, create_customer

urlpatterns = [
    path('', index, name='customer_list'),
    path('create_customer/', create_customer, name='create_customer'), # --> nova url
]

E com isso ficamos com a template onde será renderizado como um formulario HTML.

<!-- myapp/templates/myapp/create_customer.html -->
{% extends 'base.html' %}

{% block content %}
  <h2>Create Customer</h2>
  <form method="post" action="{% url 'create_customer' %}">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Save</button>
  </form>
{% endblock %}

<!-- myapp/templates/myapp/create_customer.html -->
{% extends 'base.html' %}

{% block content %}
  <h2>Create Customer</h2>
  <form method="post" action="{% url 'create_customer' %}">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Save</button>
  </form>
{% endblock %}

Middleware:

No framework django, middlewares são componentes que processam requisições HTTP antes de chegarem às views e também processam respostas antes de serem enviadas de volta ao cliente.

Eles fornecem uma maneira flexível de modificar o comportamento do framework django, adicionando ou removendo funcionalidades em diferentes partes do processo de processamento de uma requisição.

No django, ja existe algumas middlewares que cuidam da segurança das requisições e trata sessões para autenticação por exemplo.

E muito raro a necessidade de criar um novo middleware no framework django. Com isso, inicialmente você não precisa se preocupar com isso agora.

Static Files (Arquivos Estáticos):

Gerencia arquivos estáticos, como CSS, JavaScript e imagens. O django fornece uma estrutura organizada para armazenar e servir esses arquivos durante o desenvolvimento e produção.

Test Framework (Framework de Testes):

O django também oferece ferramentas robustas para escrever e executar testes automatizados. Os testes são fundamentais para garantir a qualidade e integridade do código.

No exemplo abaixo são criados testes do model Customer e também da view index() para entender se as funcionalidades adiciona a mesma estão funcionando corretamente.

# myapp/tests.py
from django.test import TestCase
from django.urls import reverse
from .models import Customer

class CustomerModelTest(TestCase):
    # testa o model Customer.
    
    def setUp(self):
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_customer_str_method(self):
        customer = Customer.objects.get(customer_id=1)
        self.assertEqual(customer.first_name, "John")
        self.assertEqual(customer.last_name, "Doe")

class CustomerViewTest(TestCase):
    # testa se a view esta funcionando corretamente.
    
    def setUp(self):
        # criação de um objeto <Customer: Jhon>
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_index_view(self):
        # teste se a view retorna como requerida.
        response = self.client.get(reverse('index'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "John")
        self.assertTemplateUsed(response, 'myapp/index.html')

# myapp/tests.py
from django.test import TestCase
from django.urls import reverse
from .models import Customer

class CustomerModelTest(TestCase):
    # testa o model Customer.
    
    def setUp(self):
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_customer_str_method(self):
        customer = Customer.objects.get(customer_id=1)
        self.assertEqual(customer.first_name, "John")
        self.assertEqual(customer.last_name, "Doe")

class CustomerViewTest(TestCase):
    # testa se a view esta funcionando corretamente.
    
    def setUp(self):
        # criação de um objeto <Customer: Jhon>
        Customer.objects.create(
            first_name="John",
            last_name="Doe",
            email="john.doe@example.com",
            street="123 Main St",
            state="CA",
            zip_code="12345"
        )

    def test_index_view(self):
        # teste se a view retorna como requerida.
        response = self.client.get(reverse('index'))
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "John")
        self.assertTemplateUsed(response, 'myapp/index.html')

Conclusão

Em síntese, o framework django representa a essência da eficiência no desenvolvimento web.

Criado a partir da necessidade de superar tarefas repetitivas, evoluiu para um framework ágil e descomplicado.

Sua arquitetura, inicialmente associada ao padrão MVC, adotou a abordagem MVT, simplificando a estrutura e centralizando responsabilidades na camada View.

Explorando os principais componentes, como Models, Views e Templates, percebemos uma engrenagem coesa que impulsiona a eficiência no desenvolvimento.

O framework django não é apenas um framework; é uma jornada técnica que capacita desde a definição de modelos até a criação de interfaces dinâmicas, redefine o cenário do desenvolvimento web de maneira pragmática e inteligente.