Creación de modelos de Django: un tutorial

Hark Labs2022-03-08 · 13 min read

Creación de modelos de Django: un tutorial

Django es un framework web muy conocido para el desarrollo rápido de sitios y aplicaciones web seguros y fáciles de mantener. Creado con Python, Django simplifica el desarrollo web, permitiendo dedicar más tiempo y atención a escribir aplicaciones sin tener que reinventar la rueda cada vez. Django es un proyecto gratuito y de código abierto con una sólida documentación oficial, un gran soporte de la comunidad y una gran cantidad de soporte gratuito y de pago.

En esta guía, nos sumergiremos en la creación de modelos de Django. En Django, un modelo es la fuente clave de información sobre sus datos. Los modelos describen los campos y el comportamiento de los datos que se van a almacenar. Django utiliza el modelo para generar las tablas de la base de datos mediante ORM (Object Relational Mapping), también denominados modelos.

Requisitos previos

Estamos trabajando en un sistema operativo basado en Unix, preferiblemente un servidor en la nube Ubuntu 20.04 como el sistema en el que hemos realizado las pruebas. Si desea configurar Django en un entorno similar, consulte nuestro tutorial, “Cómo instalar Django y configurar un entorno de desarrollo en Ubuntu 20.04.”

Paso 1. Entorno de desarrollo de Python

Django está basado en Python. Por lo tanto, necesitamos un entorno de desarrollo de Python robusto con todas las herramientas necesarias para trabajar con aplicaciones de Python. Ya lo hemos analizado en una guía dedicada. Aquí, haremos una breve demostración.

Primero, abra una terminal y ejecute los siguientes comandos:

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

A continuación, instale pip – el gestor de paquetes de Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Then, install some additional development packages:

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

Para establecer un entorno virtual, también necesitamos el módulo venv de Python:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Paso 2. Instalación de MySQL Server

MySQL es un sistema de gestión de bases de datos relacionales muy popular. Es de código abierto, estable y rico en funciones. Utilizaremos MySQL como servidor de base de datos para nuestra aplicación Django. Instale MySQL usando APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

A continuación, verifique la instalación:

$ systemctl status mysql

1	$ systemctl status mysql

Es solo una configuración básica de MySQL con las opciones predeterminadas. Consulte la guía más detallada sobre la instalación y configuración de MySQL.

Paso 3. Configuración de la aplicación Django

Ya estamos listos para crear nuestra aplicación Django. Si está interesado en una demostración más detallada de Django, consulte nuestro tutorial, “Cómo instalar el framework web Django en Ubuntu 20.04.”

A continuación, cree un directorio dedicado para la aplicación. El nombre del directorio debe reflejar el nombre del proyecto:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Dentro del directorio del proyecto, cree un entorno virtual de Python utilizando el módulo venv :

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Active el entorno virtual:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Instale Django usando pip:

$ pip install django

1	$ pip install django

A continuación, cree un nuevo proyecto de Django utilizando el comando django-admin :

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Paso 4. Configuración de la aplicación Django

La aplicación Django contiene todas las configuraciones predeterminadas. Para nuestro objetivo, necesitamos realizar algunos ajustes.

Comience editando el archivo de configuración settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

A continuación, cambie la zona horaria:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Añada las máquinas que tienen permitido acceder al servidor de la aplicación Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Después de eso, aplique los cambios:

$ python manage.py migrate

1	$ python manage.py migrate

Finalmente, cree un superusuario para nuestra aplicación web Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Paso 5. Conectar la aplicación Django a MySQL

Para conectarnos a MySQL, necesitamos una biblioteca de conectores de Python adicional que sea compatible con Django. Usaremos mysqlclient.

Primero, asegúrate de tener instalados los paquetes necesarios:

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

A continuación, instala mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Creación de una base de datos dedicada

Para nuestra aplicación, necesitamos crear una base de datos dedicada y un usuario de base de datos. Inicia el shell de MySQL como root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Crea una base de datos dedicada para nuestra aplicación Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

A continuación, crea un usuario de base de datos dedicado para la aplicación Django:

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Finalmente, otorga al usuario dedicado todos los permisos en la base de datos dedicada:

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

Cambiar la configuración de Django para usar MySQL

Ahora, necesitamos ajustar algunas configuraciones de Django para que pueda usar MySQL como servidor de base de datos. Abre settings.py en un editor de texto:

$ nano settings.py

1	$ nano settings.py

Desplázate hacia abajo hasta la sección DATABASES y pega el siguiente código:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

A continuación, edita el archivo de configuración de MySQL para que contenga las credenciales de base de datos necesarias:

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Añade el siguiente bloque al final del archivo:

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Reinicia MySQL para que los cambios surtan efecto:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

Paso 6. Creación de un modelo de Django

Ahora estamos listos para crear un nuevo modelo dentro de nuestro proyecto Django. Activa el entorno virtual:

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

En esta ubicación, indícale a Django que cree una nueva aplicación:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Después de crearla, el árbol de archivos debería verse algo así. Aquí, el archivo models.py contendrá los códigos para nuestro modelo personalizado de Django:

Comprueba el contenido actual del archivo:

$ cat models.py

1	$ cat models.py

A modo de demostración, vamos a crear un modelo para publicaciones de blog llamado Post. Contendrá los siguientes campos:

title: Título de la publicación del blog.
slug: Almacena y genera URL válidas para páginas web.
content: El texto de la publicación del blog.
created_on: Fecha de creación de la publicación.
author: El usuario que creó la publicación.

Abre el archivo models.py en un editor de texto:

$ nano models.py

1	$ nano models.py

Importemos algunas API necesarias para nuestro modelo. Por defecto, importa la API de modelos. También necesitaremos la API slugify para generar slugs, User para la autenticación, y reverse para una creación de URL mejor y más flexible:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

A continuación, añade el método de clase llamado Post. Contendrá los campos de base de datos necesarios como title, slug, content, created_on, y author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Necesitamos la funcionalidad para la generación de URL y el guardado de la publicación. Es importante ya que genera enlaces únicos que coinciden con publicaciones únicas:

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

La siguiente sección le indicará al modelo cómo ordenar la publicación y mostrarla en la página web. Codificaremos la lógica utilizando una clase interna, Meta. Contendrá lógica de modelo adicional que no concierne a la definición de los campos de la base de datos:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Finalmente, tendremos la característica del modelo Comment en este archivo. Requiere agregar otra clase Comment utilizando models.Model como su firma. Contendrá los siguientes campos de base de datos:

name: Nombre del comentarista.
email: Dirección de correo electrónico del comentarista.
text: Contenido del comentario en sí.
post: La publicación en la que se realizó el comentario.
created_on: Hora de creación del comentario.

El código se verá algo así:

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

At este punto, nuestro archivo models.py se verá así:

Finalmente, guarda el archivo y cierra el editor.

Paso 7. Actualización de la configuración de Django

El modelo está creado. Sin embargo, necesitamos ajustar algunos archivos de configuración para poner el modelo en acción. Dentro de settings.py, necesitamos agregar nuestro modelo bajo INSTALLED_APPS.

Abre settings.py en un editor de texto:

$ nano settings.py

1	$ nano settings.py

Registra el nuevo módulo bajo la sección INSTALLED_APPS:

Guarda el archivo y cierra el editor.

Paso 8. Migración de cambios

Ahora que hemos agregado todos los modelos deseados, el siguiente paso es aplicar estos cambios. Django aplicará estos esquemas a nuestra base de datos MySQL.

El siguiente comando generará todos los archivos de migración necesarios. La salida mostrará las ubicaciones de todos esos archivos dentro del directorio del proyecto:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

El siguiente comando listará todas las migraciones existentes:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Ten en cuenta que todas las migraciones están marcadas excepto 0001_initial que se creó como parte de los modelos Post y Comment.

El siguiente comando mostrará qué consulta SQL ejecutará Django para realizar las migraciones:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Todo lo que necesitamos ahora es aplicar las migraciones. Estas migraciones escribirán los cambios en la base de datos:

$ python manage.py migrate

1	$ python manage.py migrate

Paso 9. Verificación de cambios

Para verificar los cambios, echemos un vistazo a nuestra base de datos MySQL. Inicie la consola de MySQL como el usuario de Django:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

A continuación, cambie la base de datos activa actual a la base de datos de la aplicación Django:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Liste todas las tablas de la base de datos:

$ SHOW TABLES;

1	$ SHOW TABLES;

Por último, para ver el contenido de cualquiera de las tablas, use la consulta DESCRIBE:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Limitaciones de Django con MySQL

Al usar MySQL como servidor de base de datos para su aplicación Django, hay algunas cosas que debe tener en cuenta:

No hay mucho soporte para transacciones en procesos que alteran el esquema. Esto significa que, si una migración falla, se requiere deshacer manualmente todos los cambios antes de intentar otra migración. No hay forma de revertir a un punto anterior en el que la migración fallida no se hubiera llevado a cabo.
Para la mayoría de los procesos que alteran el esquema, MySQL reescribe completamente las tablas. En ciertas situaciones, esto puede consumir mucho tiempo. En el peor de los casos, la complejidad temporal será proporcional al número de filas a añadir o columnas a eliminar. Según la documentación oficial de Django, podría tomar un minuto por cada millón de filas.
MySQL impone un límite de caracteres para la longitud de los nombres de columnas, tablas e índices. También hay un límite en el tamaño total de todas las columnas y coberturas de índices. Django puede superar ese límite. Algunos backends distintos de MySQL pueden manejar el límite más alto de Django.

Por eso se recomienda encarecidamente sopesar sus opciones y elegir la adecuada.

Reflexiones finales

Esta guía demuestra con éxito cómo agregar módulos a una aplicación Django existente. Usamos MySQL como backend para la aplicación. También muestra algunos conceptos clave de Django como los modelos, cómo funcionan las migraciones y cómo Django traduce los modelos en tablas de bases de datos MySQL.

¡Feliz computación!

Hark Labs

Autor · CloudSigma

Preslav Dobrev es diseñador creativo en CloudSigma, centrado en una identidad empresarial coherente mediante el uso de canales de marketing tradicionales e innovadores. Es experto en fusionar la visión artística con el marketing estratégico para crear narrativas de marca impactantes.