Introdução ao Backend Django MongoDB

Instale as dependências.

Antes de instalar o Django MongoDB Backend, certifique-se de ter o Python 3.10 ou posterior instalado em seu ambiente de desenvolvimento.

Crie um ambiente virtual.

Selecione a guia correspondente ao seu sistema operacional e execute os seguintes comandos para criar e ativar um ambiente virtual para instalar o Django MongoDB Backend:

python -m venv venv
source venv/bin/activate

python -m venv venv
. venv\Scripts\activate

Instale o backend do Django MongoDB .

Com o ambiente virtual ativado, execute o seguinte comando para instalar a integração com o Django:

pip install django-mongodb-backend

Este comando também instala as versões mais recentes das seguintes dependências:

• PyMongo 4.x

• Django 6.0.x

Crie uma implantação MongoDB gratuita no Atlas.

Conclua as etapas em Introdução ao Atlas para configurar uma nova conta Atlas e uma implantação MongoDB de camada grátis. Certifique-se de carregar dados de amostra e adicionar seu endereço IP à lista de acesso IP.

Salve suas credenciais.

Depois de criar o usuário do banco de dados, salve o nome de usuário e a senha desse usuário em um local seguro para uso em uma próxima etapa.

Encontre sua string de conexão do MongoDB Atlas.

Para recuperar a string de conexão da implantação criada na etapa anterior, faça login na sua conta do Atlas e navegue até a seção Clusters e clique no botão Connect para a nova implantação.

Vá para a seção Connect your application e selecione "Python" no menu de seleção Driver e a versão que melhor corresponde à versão instalada no menu de seleção Version .

Copie a string de conexão

Clique no botão à direita da string de conexão para copiá-la para a área de transferência, como mostrado na seguinte captura de tela:

Edite suas credenciais de string de conexão .

Cole sua string de conexão em um arquivo no editor de texto de sua preferência e salve este arquivo em um local seguro para uso posterior. Sua string de conexão é semelhante ao exemplo a seguir :

mongodb+srv://<db_username>:<db_password>@samplecluster.ojeyz.mongodb.net/?retryWrites=true&w=majority&appName=SampleCluster

Substitua os espaços reservados <db_username> e <db_password> pelo nome de usuário e senha do usuário do banco de dados .

Criar um projeto Django.

A partir do seu shell, execute o seguinte comando para criar um novo projeto Django denominado quickstart com base em um modelo personalizado:

django-admin startproject quickstart --template https://github.com/mongodb-labs/django-mongodb-project/archive/refs/heads/6.0.x.zip

Após executar este comando, seu projeto quickstart terá a seguinte estrutura de arquivo:

quickstart/
   manage.py
   mongo_migrations/
       __init__.py
       contenttypes/
       auth/
       admin/
   quickstart/
       __init__.py
       apps.py
       settings.py
       urls.py
       asgi.py
       wsgi.py

Atualize suas configurações de banco de dados .

Abra seu arquivo settings.py e navegue até a configuração DATABASES. Substitua esta configuração pelo seguinte código:

 DATABASES = {
    "default": {
          "ENGINE": "django_mongodb_backend",
          "HOST": "<connection string URI>",
          "NAME": "sample_mflix",
    },
}

Substitua o placeholder <connection string URI> pela string de conexão que você copiou da etapa Criar uma string de conexão deste guia de Introdução.

Isto configura seu aplicativo Django para conectar ao seu agrupamento do Atlas e acessar o banco de dados de amostra do sample_mflix.

Inicie o servidor.

Para verificar se você instalou o Django MongoDB Backend e configurou corretamente seu projeto, execute o seguinte comando a partir da raiz do projeto :

python manage.py runserver

Em seguida, visite http://127.0.0.1:8000/. Esta página exibe um voto de "Para sempre! mensagem e uma imagem de um lançador.

Crie um aplicativo sample_mflix.

A partir do diretório raiz do seu projeto, execute o seguinte comando para criar um novo aplicativo Django chamado sample_mflix com base em um modelo personalizado:

python manage.py startapp sample_mflix

Crie modelos para dados de filmes, prêmios e visualizadores.

Abra o arquivo models.py no diretório sample_mflix e substitua seu conteúdo pelo seguinte código:

from django.db import models
from django.conf import settings
from django_mongodb_backend.fields import EmbeddedModelField, ArrayField
from django_mongodb_backend.models import EmbeddedModel
class Award(EmbeddedModel):
    wins = models.IntegerField(default=0)
    nominations = models.IntegerField(default=0)
    text = models.CharField(max_length=100)
class Movie(models.Model):
    title = models.CharField(max_length=200)
    plot = models.TextField(blank=True)
    runtime = models.IntegerField(default=0)
    released = models.DateTimeField("release date", null=True, blank=True)
    awards = EmbeddedModelField(Award, null=True, blank=True)
    genres = ArrayField(models.CharField(max_length=100), null=True, blank=True)
    class Meta:
        db_table = "movies"
        managed = False
    def __str__(self):
        return self.title
class Viewer(models.Model):
    name = models.CharField(max_length=100)
    email = models.CharField(max_length=200)
    class Meta:
        db_table = "users"
        managed = False
    def __str__(self):
        return self.name

O modelo Movie representa a collection sample_mflix.movies e armazena informações sobre filmes. Este modelo contém um campo de modelo embarcado chamado awards, que armazena um objeto Award. O modelo também contém um campo de array chamado genres, que armazena uma lista de gêneros que descrevem o filme.

O modelo Award não representa uma collection separada. Em vez disso, ele representa os valores do documento incorporado armazenados no modelo Movie.

O modelo Viewer representa a coleção sample_mflix.users e armazena informações de conta para visualizadores de filmes.

Crie visualizações para exibir dados.

Abra o arquivo views.py no seu diretório sample_mflix e substitua seu conteúdo pelo seguinte código:

from django.http import HttpResponse
from django.shortcuts import render
from .models import Movie, Viewer
def index(request):
    return HttpResponse("Hello, world. You're at the application index.")
def recent_movies(request):
    movies = Movie.objects.order_by("-released")[:5]
    return render(request, "recent_movies.html", {"movies": movies})
def viewers_list(request):
    viewers = Viewer.objects.order_by("name")[:10]
    return render(request, "viewers_list.html", {"viewers": viewers})

Estas visualizações exibem uma mensagem da página de destino e informações sobre seus modelos Movie e Viewer.

Configure URLs para suas visualizações.

Crie um novo arquivo chamado arquivo urls.py no seu diretório sample_mflix. Para mapear as visualizações definidas na etapa anterior para URLs, cole o seguinte código em urls.py:

from django.urls import path
from . import views
urlpatterns = [
    path("recent_movies/", views.recent_movies, name="recent_movies"),
    path("viewers_list/", views.viewers_list, name="viewers_list"),
    path("", views.index, name="index"),
]

Em seguida, navegue até o arquivo quickstart/urls.py e substitua seu conteúdo pelo seguinte código:

from django.contrib import admin
from django.urls import include, path
urlpatterns = [
    path("admin/", admin.site.urls),
    path("", include("sample_mflix.urls")),
]

Crie modelos para o formato dos seus dados.

No seu diretório sample_mflix, crie um subdiretório denominado templates. Em seguida, crie um arquivo chamado recent_movies.html e cole o seguinte código:

<!-- templates/recent_movies.html -->
<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Recent Movies</title>
</head>
<body>
   <h1>Five Most Recent Movies</h1>
   <ul>
      {% for movie in movies %}
            <li>
               <strong>{{ movie.title }}</strong> (Released: {{ movie.released }})
            </li>
      {% empty %}
            <li>No movies found.</li>
      {% endfor %}
   </ul>
</body>
</html>

Este modelo formata os dados do filme solicitados pela visualização recent_movies.

Crie outro arquivo no diretório sample_mflix/templates chamado viewers_list.html e cole o seguinte código:

<!-- templates/viewers_list.html -->
<!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Viewers List</title>
</head>
<body>
   <h1>Alphabetical Viewers List</h1>
   <table>
      <thead>
            <tr>
               <th>Name</th>
               <th>Email</th>
            </tr>
      </thead>
      <tbody>
            {% for viewer in viewers %}
               <tr>
                  <td>{{ viewer.name }}</td>
                  <td>{{ viewer.email }}</td>
               </tr>
            {% empty %}
               <tr>
                  <td colspan="2">No viewer found.</td>
               </tr>
            {% endfor %}
      </tbody>
   </table>
</body>
</html>

Este modelo formata os dados de usuário solicitados pela visualização viewers_list.

Inclua seu aplicativo em seu projeto.

Abra o arquivo settings.py em quickstart e edite sua configuração INSTALLED_APPS para se assemelhar ao seguinte código:

INSTALLED_APPS = [
    'sample_mflix.apps.SampleMflixConfig',
    'quickstart.apps.MongoAdminConfig',
    'quickstart.apps.MongoAuthConfig',
    'quickstart.apps.MongoContentTypesConfig',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

Crie migrações para seus novos modelos.

A partir da raiz do projeto , execute o seguinte comando para criar migrações para os modelos Movie, Award e Viewer e aplicar as alterações no banco de dados:

python manage.py makemigrations sample_mflix
python manage.py migrate

Inicie uma shell Python.

No diretório raiz do seu projeto, execute o seguinte comando para entrar no shell do Python:

python manage.py shell

Importe as classes e os módulos necessários.

A partir do shell do Python, execute o seguinte código para importar seus modelos e o módulo para criar um objeto datetime :

from sample_mflix.models import Movie, Award, Viewer
from django.utils import timezone
from datetime import datetime

Insira um objeto Movie no banco de dados.

Execute o código a seguir para criar um objeto Movie que armazena dados sobre um filme intitulado "Minari", incluindo seus prêmios em um objeto Award :

movie_awards = Award(wins=122, nominations=245, text="Won 1 Oscar")
movie = Movie.objects.create(
    title="Minari",
    plot="A Korean-American family moves to an Arkansas farm in search of their own American Dream",
    runtime=217,
    released=timezone.make_aware(datetime(2020, 1, 26)),
    awards=movie_awards,
    genres=["Drama", "Comedy"]
)

Atualize seu Movie objeto.

O objeto Movie criado na etapa anterior tem dados imprecisos: o valor runtime é 217, mas o valor runtime correto é 117.

Execute o seguinte código para atualizar o valor de runtime do objeto:

movie.runtime = 117
movie.save()

Insira um objeto Viewer no banco de dados.

Você também pode usar seu modelo Viewer para inserir documentos na coleção sample_mflix.users. Execute o seguinte código para criar um objeto Viewer que armazena dados sobre um visualizador de filme denominado "Abigail Carter":

viewer = Viewer.objects.create(
    name="Abigail Carter",
    email="abigail.carter@fakegmail.com"
)

Exclua um Viewer objeto.

Um visualizador de filmes chamado "Allizer Throne" não usa mais o site de streaming de filmes. Para remover do banco de dados o documento correspondente deste visualizador, execute o seguinte código:

old_viewer = Viewer.objects.filter(name="Alliser Thorne").first()
old_viewer.delete()

Inicie o servidor de desenvolvimento .

Saia da shell Python executando o seguinte código:

exit()

Em seguida, inicie seu servidor executando o seguinte comando no diretório raiz do seu projeto:

python manage.py runserver

Renderize seus novos objetos.

Para garantir que você inseriu um objeto Movie no banco de dados, visite o site http://127.0.0.1:8000/recent_movies/ URL. Você pode ver uma lista de cinco filmes no banco de dados sample_mflix.movies , com seu novo filme listado na parte superior.

Em seguida, certifique-se de inserir um Viewer objeto no banco de dados acessando o site http://:127.0.0.1 8000/viewers_list/ URL. Você pode ver uma lista de dez nomes de visualizador no banco de dados sample_mflix.users , com seu novo visualizador listado na parte superior. Certifique-se de que o visualizador chamado "Allizer Throne", excluído em uma etapa anterior, não apareça nesta lista.

Faça uma query na coleção users para um e-mail especificado.

Inicie uma shell Python executando o seguinte comando:

python manage.py shell

Em seguida, execute o seguinte código para fazer a query da collection sample_mflix.users de um visualizador de filme cujo e-mail é "jason_momoa@gameofthron.es":

from sample_mflix.models import Movie, Viewer
Viewer.objects.filter(email="jason_momoa@gameofthron.es").first()

Este código retorna o nome do usuário correspondente:

<Viewer: Khal Drogo>

Query a coleção movies para obter valores de tempo de execução especificados.

Execute o seguinte código para consultar a collection sample_mflix.movies para filmes que tenham um valor de runtime menor que 10:

Movie.objects.filter(runtime__lt=10)

Este código retorna uma lista truncada dos filmes correspondentes:

<QuerySet [<Movie: Winsor McCay, the Famous Cartoonist of the N.Y.
Herald and His Moving Comics>, <Movie: Steamboat Willie>, <Movie:
Three Little Pigs>, <Movie: The Band Concert>, <Movie: Who Killed Cock Robin?>,
<Movie: Dots>, <Movie: The Cat Concerto>, <Movie: Begone Dull Care>,
<Movie: Mi adorado Juan>, <Movie: Neighbours>, <Movie: A Phantasy>,
<Movie: Duck Amuck>, <Movie: Duck Dodgers in the 24èth Century>,
<Movie: Blinkity Blank>, <Movie: One Froggy Evening>,
<Movie: What's Opera, Doc?>, <Movie: Lines: Horizontal>,
<Movie: Il fornaretto di Venezia>, <Movie: Dog Star Man: Part IV>,
<Movie: Now>, '...(remaining elements truncated)...']>

Crie um usuário administrador.

Antes de criar um site de administração, você deve criar um usuário que possa fazer login no site.

No diretório raiz do seu projeto, execute o seguinte comando para criar um usuário administrador:

python manage.py createsuperuser

Em seguida, o terminal solicita um nome de usuário, endereço de e-mail e senha. Para cada prompt, insira as seguintes informações para criar um usuário com as credenciais especificadas e pressione "enter" após cada entrada:

Username: admin
Email address: admin@example.com
Password: <admin-password>
Password (again): <admin-password>

Substitua o placeholder <admin-password> pela sua senha de usuário.

Entre no site de administração.

Execute o seguinte código para iniciar seu servidor:

python manage.py runserver

Após seu servidor estar executando, visite o http://127.0.0.1:8000/admin/ URL para ver o site de administração. Este site exibe a seguinte tela de login:

Insira o nome de usuário e senha criados na etapa anterior para iniciar sessão no site.

Acesse seu aplicativo sample_mflix no site de administração.

Após fazer login no site de administração, você pode ver as seguintes informações:

Você pode editar a configuração de autenticação do seu projeto selecionando a linha Groups ou Users na tabela Authentication and Authorization.

Para editar os dados na coleção de amostra do users, representado pelo seu modelo do Viewer, navegue até o arquivo sample_mflix/admin.py do seu projeto e cole o seguinte código:

from django.contrib import admin
from .models import Viewer
admin.site.register(Viewer)

Agora, seu site de administração exibe as seguintes informações:

Selecione um Viewer objeto .

Você pode visualizar os dados armazenados em um objeto Viewer que tem um valor name de "Abigail Carter". Você criou este objeto na etapa Gravar dados no MongoDB deste tutorial.

Clique na linha Viewers da tabela SAMPLE_MFLIX para ver uma lista de visualizadores. O site de administração exibe a seguinte lista:

Em seguida, clique em Abigail Carter no topo da lista. O site exibe o Name e Email do visualizador selecionado:

Edite os dados em um objeto Viewer.

Para editar o campo email do visualizador, selecione a caixa que contém o texto "abigail.carter@fakegmail.com". Exclua este texto e substitua-o por "acarter1@fakegmail.com", como mostrado na seguinte imagem:

Em seguida, clique no botão SAVE abaixo das informações do visualizador para salvar suas alterações.