Panel Administrativo de Django

En resumen

La aplicación de administración de Django permite crear un área de administración para gestionar los modelos del proyecto de forma sencilla, reduciendo el tiempo y esfuerzo necesarios para desarrollar estas funcionalidades manualmente.

Instrucciones: nuevo proyecto¶

A continuación, selecciona tu plataforma y sigue los pasos indicados para configurar un nuevo proyecto con Django.

Si ya tienes un proyecto

Las siguientes instrucciones están pensadas para configurar un proyecto Django desde cero. Si ya tienes un proyecto Django creado y configurado, no despliegues esta sección y continúa con el siguiente paso del post.

Ver Instrucciones

Windows Linux macOS

1. Abrir el símbolo de sistema

Presiona Win+R para abrir la ventana Ejecutar. Escribe cmd y presiona Enter para abrir el Símbolo del sistema (CMD).

Abrir CMD — Abrir el símbolo del sistema (CMD)

2. Ir a la ubicación deseada

Una vez que tengas el CMD abierto, usa el comando cd para navegar a la carpeta donde deseas crear tu proyecto. Por ejemplo, si deseas ir a la carpeta Documentos:

cd %UserProfile%\Documents #(1)!

Ingresa a la carpeta Documentos del usuario actual.

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre deseado:

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Ejecuta el siguiente comando para crear un entorno virtual en la carpeta del proyecto:

python -m venv .venv #(1)!

Crea un entorno virtual de Python llamado .venv.

5. Activar el entorno virtual

Ejecuta el siguiente comando para activar el entorno virtual:

.\.venv\Scripts\activate

Una vez activado, deberías ver (.venv) al comienzo de la línea de comandos.

(.venv) C:\Users\mcherrera\nuevo-proyecto

Ahora tenemos un entorno limpio y listo para trabajar.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

1. Abrir la terminal

Presiona las teclas Ctrl+Alt+T o busca Terminal en tu lanzador de aplicaciones para abrir una nueva Terminal.

2. Navegar a la ubicación deseada

Una vez que tengas la terminal abierta, usa el comando cd para navegar a la carpeta donde deseas crear el proyecto Django. Por ejemplo, ir a Documentos:

Terminal

cd ~/Documents

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre que deseas:

Terminal

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Terminal

python3 -m venv .venv

5. Activar el entorno virtual

Terminal

source .venv/bin/activate

Una vez activado, deberías ver (.venv) al comienzo de la terminal.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

Terminal

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

Terminal

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

1. Abrir la terminal de comandos

Presiona Cmd+Space para abrir Spotlight, luego escribe terminal y presiona Enter

Abrir Terminal en MacOS — Abrir Terminal en macOS

2. Navegar a la ubicación deseada

Una vez que tengas la terminal abierta, usa el comando cd para navegar a la carpeta donde deseas crear el proyecto Django. Por ejemplo, ir a Documentos:

Terminal

cd ~/Documents

3. Crear la carpeta del proyecto y acceder a ella

Ejecuta el siguiente comando reemplazando mi-proyecto por el nombre que deseas:

Terminal

mkdir //PROJECT// #(1)!
cd //PROJECT// #(2)!

Crea la carpeta del proyecto
Ingresa a la carpeta creada anteriormente

4. Crear el entorno virtual

Terminal

python3 -m venv .venv

5. Activar el entorno virtual

Terminal

source .venv/bin/activate

Una vez activado, deberías ver (.venv) al comienzo de la terminal.

6. Instalar Django en el entorno virtual

Una vez que el entorno virtual está activado, instala Django con el siguiente comando:

Terminal

(.venv) pip install django

7. Generar un nuevo

Con la herramienta django-admin y el comando startproject se puede generar automáticamente la estructura inicial de un nuevo proyecto Django.

Terminal

(.venv) django-admin startproject _site .

Utilizamos un punto . al final del comando para generar el proyecto en el directorio actual, evitando que Django cree una carpeta adicional con el nombre del proyecto.

8. Archivos del proyecto

Una vez generado, tendrás disponible el archivo manage.py en el proyecto:

Archivos del proyecto

 mi-proyecto
├──  _site
│   ├──  __init__.py #(1)!
│   ├──  asgi.py #(2)!
│   ├──  settings.py #(3)!
│   ├──  urls.py #(4)!
│   └──  wsgi.py #(5)!
├──  .venv #(6)!
└──  manage.py #(7)!

Inicializa el paquete Python del proyecto Django.
Configura el punto de entrada ASGI para servidores asíncronos.
Contiene la configuración principal del proyecto Django.
Define las rutas y URLs del proyecto.
Configura el punto de entrada WSGI para servidores web tradicionales.
Contiene el entorno virtual de Python del proyecto.
Permite administrar el proyecto mediante comandos de Django.

El archivo manage.py permite administrar y ejecutar distintas tareas del proyecto Django, como iniciar el servidor de desarrollo, ejecutar migraciones y crear aplicaciones.

Habilitar el panel administrativo¶

Django incluye su propia aplicación de administración, por lo que no es necesario instalar ningún paquete adicional para utilizarla. Toda la configuración requerida para incluir la aplicación de administración de Django fue hecha automáticamente cuando creaste el esqueleto del proyecto.

Podemos comprobarlo dentro del archivo settings.py, donde aparece dentro de INSTALLED_APPS:

_site/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles'
]

Abrir el archivo settings

 ...
└──  _site
    ├──  __init__.py
    ├──  asgi.py
    ├──  settings.py
    ├──  urls.py
    └──  wsgi.py

La aplicación de administración también incluye su propia ruta de acceso, la cual Django incorpora automáticamente al crear un nuevo proyecto. Esta configuración puede comprobarse en el archivo urls.py principal del proyecto:

_site/url.py
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path("admin/", admin.site.urls),
]

Abrir el archivo urls principal

 ...
└──  _site
    ├──  __init__.py
    ├──  asgi.py
    ├──  settings.py
    ├──  urls.py
    └──  wsgi.py

La línea path("admin/", admin.site.urls) conecta la ruta /admin/ con la interfaz de administración de Django. Por lo tanto, una vez iniciado el servidor de desarrollo, podemos acceder al panel desde http://127.0.0.1:8000/admin/.

De esta manera, tanto la aplicación administrativa como su ruta de acceso ya se encuentran configuradas desde la creación del proyecto.

En este punto, si intentas introducir credenciales, Django mostrará el error de no such table: auth_user:

Ejecutar las migraciones¶

El error anterior indica que la tabla auth_user, utilizada por Django para almacenar los usuarios, todavía no existe en la base de datos. Para crear esta y las demás tablas necesarias del proyecto, debemos ejecutar las migraciones pendientes:

ComandoOutput

(.venv) python manage.py migrate #(1)!

Ejecuta las migraciones pendiente y crea las tablas en la base de datos.

(.venv) ➜ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

Las tablas ya fueron creadas, pero todavía no existe ningún usuario registrado.

Crear un superusuario¶

Para acceder al panel administrativo necesitamos un usuario con permisos de administración.

El superusuario es una cuenta con todos los permisos administrativos del proyecto y se utiliza para iniciar sesión en el panel de administración. Para crear esta cuenta, ejecuta el siguiente comando:

ComandoOutput

(.venv) python manage.py createsuperuser

(.venv) python manage.py createsuperuser
Username (leave blank to use 'marco'): admin
Email address: admin@admin.cl
Password: ******
Password (again): ******
This password is too short. It must contain at least 8 characters.
This password is too common.
This password is entirely numeric.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

Una vez que hayas completado el comando con la información requerida, se agregará un nuevo administrador a la base de datos. Ahora, reinicia el servidor de desarrollo para probar el inicio de sesión:

ComandoOutput

(.venv) python manage.py runserver

(.venv) python manage.py runserver 
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
September 06, 2026 - 23:55:22
Django version 6.1.1, using settings '_site.settings'
Starting WSGI development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/6.1/howto/deployment/

Iniciar sesión y usar el sitio¶

Con las migraciones ejecutadas y el superusuario creado, ya podemos iniciar sesión en el panel de administración de Django. Para ello, accede nuevamente a http://127.0.0.1:8000/admin e ingresa las credenciales del superusuario.

Una vez iniciada la sesión, veremos los modelos Usuarios y Grupos, proporcionados por el sistema de autenticación integrado de Django.

A continuación, crearemos nuestra propia aplicación para definir y registrar los modelos que utilizará nuestro proyecto, permitiéndonos gestionarlos directamente desde este mismo panel de administración.

Registrar modelos el administrador¶

En este ejemplo crearemos una aplicación llamada library para gestionar una pequeña biblioteca desde el panel de administración. La aplicación tendrá distintos modelos, como Author, Category y Book, que estarán relacionados entre sí.

1. Crear la aplicación¶

Desde la carpeta donde se encuentra manage.py, ejecutamos el siguiente comando:

Comando

(.venv) python manage.py startapp library

Esto creará la estructura básica de la aplicación:

Archivos de la aplicación

 ...
├──  manage.py
├──  _site
└──  library
    ├──  migrations
    │   └──  __init__.py
    ├──  __init__.py
    ├──  admin.py
    ├──  apps.py
    ├──  models.py
    ├──  tests.py
    └──  views.py

Archivos principales

models.py

Aquí definiremos los modelos de nuestra aplicación.

admin.py

Aquí registraremos los modelos para poder gestionarlos desde el administrador de Django.

2. Registrar la aplicación¶

Para que Django reconozca la nueva aplicación y sus modelos, debemos agregarla a INSTALLED_APPS en settings.py. De esta forma, Django podrá tenerlos en cuenta al momento de crear y aplicar las migraciones.

_site/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'library'
]

Abrir el archivo settings

 ...
└──  _site
    ├──  __init__.py
    ├──  asgi.py
    ├──  settings.py
    ├──  urls.py
    └──  wsgi.py

3. Crear los modelos¶

Ahora definiremos los modelos que utilizará nuestra biblioteca.

Abrimos el modelo library/models.py y agregamos lo siguiente:

models.py
from django.db import models


class Author(models.Model):
    name = models.CharField(max_length=100)
    biography = models.TextField(blank=True)

    def __str__(self):
        return self.name


class Category(models.Model):
    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name


class Book(models.Model):
    title = models.CharField(max_length=200)
    description = models.TextField(blank=True)
    publication_date = models.DateField()
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,
        related_name="books",
    )
    categories = models.ManyToManyField(
        Category,
        related_name="books"
    )

    def __str__(self):
        return self.title

Archivos de la aplicación

 ...
├──  manage.py
├──  _site
└──  library
    ├──  migrations
    │   └──  __init__.py
    ├──  __init__.py
    ├──  admin.py
    ├──  apps.py
    ├──  models.py
    ├──  tests.py
    └──  views.py

En este caso tenemos tres modelos:

Author: almacena la información de los autores.
Category: almacena las categorías de los libros.
Book: almacena los libros y se relaciona con autores y categorías.

flowchart LR
    A[Author] -->|"1 : N"| B[Book]
    B <-->|"N : M"| C[Category]

El modelo Book utiliza una relación ForeignKey para asociar cada libro con un autor y una relación ManyToManyField para permitir que un libro tenga varias categorías y que una categoría contenga varios libros.

4. Crear las migraciones¶

Una vez definidos los modelos, debemos indicarle a Django que genere las migraciones correspondientes:

ComandoOutput

(.venv) python manage.py makemigrations

Migrations for 'library':
library/migrations/0001_initial.py
    + Create model Author
    + Create model Category
    + Create model Book

Django detectará los nuevos modelos y creará una migración en library/migrations con el nombre de 0001_initial.py. Este archivo es el que utiliza el ORM para posteriormente crear las tablas en la base de datos cuando se aplica la migración. El archivo generado se ve de la siguiente manera:

migrations/0001_initial.py

# Generated by Django 6.1.1 on 2026-09-08 08:22

import django.db.models.deletion
from django.db import migrations, models


class Migration(migrations.Migration):

    initial = True

    dependencies = [
    ]

    operations = [
        migrations.CreateModel(
            name='Author',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=100)),
                ('biography', models.TextField(blank=True)),
            ],
        ),
        migrations.CreateModel(
            name='Category',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('name', models.CharField(max_length=100)),
            ],
        ),
        migrations.CreateModel(
            name='Book',
            fields=[
                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
                ('title', models.CharField(max_length=200)),
                ('description', models.TextField(blank=True)),
                ('publication_date', models.DateField()),
                ('author', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='books', to='library.author')),
                ('categories', models.ManyToManyField(related_name='books', to='library.category')),
            ],
        ),
    ]

5. Aplicar las migraciones¶

Ahora aplicamos las migraciones a la base de datos:

ComandoOutput

python manage.py migrate

Operations to perform:
Apply all migrations: admin, auth, contenttypes, library, sessions
Running migrations:
Applying library.0001_initial... OK

Con esto, Django creará las tablas necesarias para Author, Category y Book, además de las tablas utilizadas para gestionar sus relaciones.

Ver las tablas en la base de datos

Podemos abrir la base de datos utilizando una herramienta como SQLite CLI y comprobar que las tablas de nuestros modelos se crearon correctamente.

Terminal

(.venv) ➜ sqlite3 db.sqlite3
-- Loading resources from /home/marco/.sqliterc
SQLite version 3.45.1 2024-01-30 16:01:20
Enter ".help" for usage hints.
sqlite> .tables
auth_group                  django_content_type
auth_group_permissions      django_migrations
auth_permission             django_session
auth_user                   library_author
auth_user_groups            library_book
auth_user_user_permissions  library_book_categories
django_admin_log            library_category
sqlite>

6. Registrar los modelos en el administrador¶

Para administrar estos modelos desde Django Admin, debemos registrarlos en library/admin.py:

library/admin.py
from django.contrib import admin
from .models import Author, Book, Category

admin.site.register(Author)
admin.site.register(Category)
admin.site.register(Book)

Archivos de la aplicación

 ...
├──  manage.py
├──  _site
└──  library
    ├──  migrations
    │   └──  __init__.py
    │   └──  0001_initial.py
    ├──  __init__.py
    ├──  admin.py
    ├──  apps.py
    ├──  models.py
    ├──  tests.py
    └──  views.py

También podemos utilizar @admin.register() para registrar cada modelo:

library/admin.py
from django.contrib import admin
from .models import Author, Book, Category


@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    list_display = ("name",)

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ("name",)

@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
    list_display = ("title", "author", "publication_date")

Esta segunda alternativa permite personalizar la forma en que cada modelo se muestra dentro del administrador.

7. Acceder al administrador¶

Iniciamos el servidor:

ComandoOutput

(.venv) python manage.py runserver

(.venv) ➜ python manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
September 10, 2026 - 00:15:04
Django version 6.1.1, using settings '_site.settings'
Starting WSGI development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/6.1/howto/deployment/

Luego ingresamos a: http://127.0.0.1:8000/admin/

Tener el usuario administrador habilitado

Si todavía no tienes un usuario administrador, vuelve a la sección de crear un superusuario

Después de iniciar sesión, veremos los modelos registrados de nuestra aplicación:

Desde aquí podremos crear autores, categorías y libros.

8. Registrar datos¶

Primero podemos crear algunos autores, por ejemplo:

Luego creamos algunas categorías:

Finalmente, podemos crear un libro y asociarlo con el autor y las categorías correspondientes:

De esta manera, los modelos no solo quedan definidos en el código, sino que también pueden utilizarse para almacenar y relacionar información en la base de datos, gestionándola de forma sencilla mediante la interfaz de administración de Django.

Información

Cada vez que se modifique la estructura de un modelo, debemos ejecutar nuevamente makemigrations y migrate para que los cambios se reflejen en la base de datos.