Empieza con Django MongoDB Backend

Instala las dependencias.

Antes de instalar Django MongoDB Backend, asegúrese de tener Python 3.10 o posterior instalado en su entorno de desarrollo.

Crear un entorno virtual.

Seleccione la pestaña correspondiente a su sistema operativo y ejecute los siguientes comandos para crear y activar un entorno virtual en el que instalar Django MongoDB Backend:

python -m venv venv
source venv/bin/activate

python -m venv venv
. venv\Scripts\activate

Instalar el backend Django MongoDB.

Con el entorno virtual activado, ejecuta el siguiente comando para instalar la integración de Django:

pip install django-mongodb-backend

Este comando también instala las versiones más recientes de las siguientes dependencias:

• PyMongo 4.x

• Django 6.0.x

Crea una implementación gratuita de MongoDB en Atlas.

Completa los pasos en Cómo empezar con Atlas para configurar una nueva cuenta de Atlas y una implementación MongoDB en el nivel gratuito. Asegúrate de cargar datos de muestra y añadir tu dirección IP a la lista de acceso IP.

Guarda tus credenciales.

Después de crear un usuario de base de datos, guardar el nombre de usuario y la contraseña de ese usuario en una ubicación segura para usarlos en un paso próximo.

Encuentra tu cadena de conexión de MongoDB Atlas.

Para recuperar tu cadena de conexión para la implementación que creaste en el paso anterior, inicia sesión en tu cuenta de Atlas y navega hasta Clusters sección y haz clic en el botón Connect para tu nueva implementación.

Diríjase a la sección Connect your application y seleccione "Python" del menú de selección Driver y la versión que mejor coincida con la versión que instaló del menú de selección Version.

Copie su cadena de conexión.

Se debe hacer clic en el botón a la derecha de la cadena de conexión para copiarla al portapapeles, como se muestra en la siguiente captura de pantalla:

Edita tus credenciales de cadena de conexión.

Pega tu cadena de conexión en un archivo en tu editor de texto preferido y guarda este archivo en una ubicación segura para su uso posterior. Tu cadena de conexión se parece al siguiente ejemplo:

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

Reemplaza los marcadores de posición <db_username> y <db_password> por el nombre de usuario y la contraseña de tu usuario de base de datos.

Crear un proyecto Django.

Desde tu shell, ejecuta el siguiente comando para crear un nuevo proyecto de Django llamado quickstart basado en una plantilla personalizada:

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

Después de ejecutar este comando, tu proyecto quickstart tiene la siguiente estructura de archivos:

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

Actualiza la configuración de tu base de datos.

Abra su archivo settings.py y navegue hasta la configuración DATABASES. Reemplace esta configuración con el siguiente código:

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

Reemplace <connection string URI> el marcador de posición con la cadena de conexión que copió del paso Crear una cadena de conexión de esta guía de Introducción.

Esto configura su aplicación Django para conectarse a su clúster Atlas y acceder a la base de datos de muestra sample_mflix.

Inicia el servidor.

Para verificar que instalaste Django MongoDB Backend y configuraste correctamente tu proyecto, ejecuta el siguiente comando desde la raíz del proyecto:

python manage.py runserver

Luego, visitá http://127.0.0.1:8000/. Esta página muestra un mensaje de “¡Felicidades!” y una imagen de un cohete.

Crea una sample_mflix aplicación.

Desde el directorio raíz de tu proyecto, ejecuta el siguiente comando para crear una nueva aplicación Django llamada sample_mflix basada en una plantilla personalizada:

python manage.py startapp sample_mflix

Crea modelos para datos de películas, premios y espectadores.

Abre el archivo models.py en el directorio sample_mflix y reemplaza su contenido con el siguiente 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

El modelo Movie representa la colección sample_mflix.movies y almacena información sobre películas. Este modelo contiene un campo de modelo incrustado llamado awards, que almacena un objeto Award. El modelo también contiene un campo de arreglo llamado genres, que almacena una lista de géneros que describen la película.

El modelo Award no representa una colección independiente. En su lugar, representa los valores del documento incrustado almacenados en el modelo Movie.

El modelo Viewer representa la colección sample_mflix.users y almacena información de cuentas para los espectadores de películas.

Cree vistas para mostrar datos.

Abre el archivo views.py en tu directorio sample_mflix y reemplaza su contenido por el siguiente 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 vistas muestran un mensaje de página de inicio e información sobre tus modelos Movie y Viewer.

Configura URLs para tus vistas.

Crea un nuevo archivo llamado urls.py en tu directorio sample_mflix. Para mapear las vistas definidas en el paso anterior a URLs, pega el siguiente código en 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"),
]

Luego, navegue al archivo quickstart/urls.py y reemplace su contenido con el siguiente código:

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

Crea plantillas para formatear tus datos.

En tu directorio sample_mflix, crea un subdirectorio denominado templates. Luego, crea un archivo llamado recent_movies.html y pegue el siguiente 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>

Esta plantilla formatea los datos de película solicitados por la vista recent_movies.

Crea otro archivo en el directorio sample_mflix/templates llamado viewers_list.html y pega el siguiente 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>

Esta plantilla le da formato a los datos de usuario solicitados por la vista viewers_list.

Incluye tu aplicación en tu proyecto.

Abre el archivo settings.py en quickstart y edita tu configuración INSTALLED_APPS para que se parezca al siguiente 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',
]

Cree migraciones para sus nuevos modelos.

Desde la raíz del proyecto, ejecuta el siguiente comando para crear migraciones para los modelos Movie, Award y Viewer, y aplicar los cambios a la base de datos:

python manage.py makemigrations sample_mflix
python manage.py migrate

Inicie un shell de Python.

Desde el directorio raíz de su proyecto, ejecute el siguiente comando para entrar en el shell de Python:

python manage.py shell

Importe las clases y módulos necesarios.

Desde su shell de Python, ejecute el siguiente código para importar sus modelos y el módulo para crear un objeto datetime:

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

Inserta un objeto Movie en la base de datos.

Ejecute el siguiente c\u00f3digo para crear un objeto Movie que almacene datos sobre una pel\u00edcula titulada "Minari", incluidos sus premios en un 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"]
)

Actualiza tu objeto Movie.

El objeto Movie creado en el paso anterior tiene datos inexactos: El valor runtime es 217, pero el valor correcto de runtime es 117.

Ejecutar el siguiente código para actualizar el valor runtime del objeto:

movie.runtime = 117
movie.save()

Inserta un objeto Viewer en la base de datos.

También puedes utilizar tu modelo Viewer para insertar documentos en la colección sample_mflix.users. Ejecuta el siguiente código para crear un objeto Viewer que almacene datos sobre un espectador de películas llamado "Abigail Carter":

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

Borrar un objeto Viewer.

Un visor de películas llamado "Alliser Thorne" ya no usa el sitio de streaming. Para eliminar el documento correspondiente de la base de datos, ejecute el siguiente código:

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

Inicia el servidor de desarrollo.

Sal del shell de Python ejecutando el siguiente código:

exit()

Luego, inicia tu servidor ejecutando el siguiente comando desde el directorio raíz de tu proyecto:

python manage.py runserver

Renderiza tus nuevos objetos.

Para garantizar que se insertó un objeto Movie en la base de datos, visita el http://127.0.0.1:8000/recent_movies/ URL. Puedes ver una lista de cinco películas en la base de datos sample_mflix.movies, con tu nueva película en la parte superior.

Asegúrate de haber insertado un objeto Viewer en la base de datos visitando el http://127.0.0.1:8000/viewers_list/ URL. Puedes ver una lista de diez nombres de espectadores en la base de datos sample_mflix.users, con tu nuevo espectador en la parte superior de la lista. Asegúrese de que el espectador llamado "Alliser Thorne", eliminado en un paso anterior, no aparezca en esta lista.

Query la colección de users para un correo electrónico especificado.

Inicie un shell de Python ejecutando el siguiente comando:

python manage.py shell

Luego, ejecuta el siguiente código para query la colección sample_mflix.users en busca de un espectador de películas cuyo correo electrónico sea "jason_momoa@gameofthron.es":

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

Este código devuelve el nombre del usuario coincidente:

<Viewer: Khal Drogo>

Query la colección movies para obtener los valores de tiempo de ejecución especificados.

Ejecute el siguiente código para consultar la colección sample_mflix.movies en busca de películas que tengan un valor runtime menor que 10:

Movie.objects.filter(runtime__lt=10)

Este código devuelve una lista truncada de las películas coincidentes:

<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)...']>

Crea un usuario administrador.

Antes de crear un sitio de administración, debe crear un usuario que pueda iniciar sesión en el sitio.

Desde el directorio raíz de su proyecto, ejecute el siguiente comando para crear un usuario administrador:

python manage.py createsuperuser

A continuación, tu terminal te solicita un nombre de usuario, dirección de correo electrónico y contraseña. Para cada solicitud, introduce la siguiente información para crear un usuario con las credenciales especificadas y presiona "enter" después de cada entrada:

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

Reemplaza el marcador de posición <admin-password> por la contraseña de tu usuario.

Ingresa al sitio de administración.

Ejecute el siguiente código para iniciar su servidor:

python manage.py runserver

Una vez que el servidor esté en funcionamiento, visita el http://127.0.0.1:8000/admin/ URL para ver el sitio de administración. Este sitio muestra la siguiente pantalla de inicio de sesión:

Ingresa el nombre de usuario y la contraseña creados en el paso anterior para iniciar sesión en el sitio.

Acceda a su sample_mflix aplicación desde el sitio de administración.

Después de iniciar sesión en el sitio de administración, puede ver la siguiente información:

Puedes editar la configuración de autenticación de tu proyecto seleccionando la fila Groups o Users en la tabla Authentication and Authorization.

Para editar los datos en la users colección de muestras, representados por tu modelo Viewer, navega hasta el archivo sample_mflix/admin.py de tu proyecto y pega el siguiente código:

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

Ahora, tu sitio de administrador muestra la siguiente información:

Seleccione un objeto Viewer.

Puedes visualizar los datos almacenados en un objeto Viewer que tiene un valor name de "Abigail Carter". Creaste este objeto en el paso Escribir datos en MongoDB de este tutorial.

Haz clic en la fila Viewers de la tabla SAMPLE_MFLIX para ver una lista de visualizadores. El sitio de administración muestra la siguiente lista:

Luego, haga clic en Abigail Carter en la parte superior de la lista. El sitio muestra los Name y Email del espectador seleccionado:

Editar los datos en un Viewer objeto.

Para editar el campo email del visor, selecciona la casilla que contiene el texto "abigail.carter@fakegmail.com". Borra este texto y reemplázalo por "acarter1@fakegmail.com", como se muestra en la siguiente imagen:

Luego, haz clic en el botón SAVE debajo de la información del visor para guardar tus cambios.