Tutorial Paso a Paso para Desarrollar un Sistema de Gestión de Inventario con Django y PostgreSQL
En este tutorial detallado aprenderás cómo crear un sistema de gestión de inventario utilizando Django como framework de desarrollo web y PostgreSQL como sistema de gestión de bases de datos. Este tutorial está diseñado para desarrolladores principiantes e intermedios interesados en el desarrollo backend con Python y la creación de aplicaciones web robustas.
Tabla de Contenidos
- Configuración del entorno
- Creación del proyecto y aplicación Django
- Definición de modelos: Productos y Categorías
- Implementación de vistas CRUD
- Configuración de URLs
- Integración con la base de datos PostgreSQL
- Despliegue básico
- Conclusión y buenas prácticas
Configuración del entorno
Para comenzar, asegurémonos de que tienes instalado lo siguiente:
- Python 3.8+
- PostgreSQL
- pip (gestor de paquetes de Python)
- virtualenv (opcional pero recomendado)
Paso 1: Crear y activar un entorno virtual
Esto aísla tus dependencias y evita conflictos con otros proyectos.
|
1 2 3 4 5 6 7 8 9 |
# Crear un entorno virtual llamado 'env' python3 -m venv env # Activar en Linux/MacOS source env/bin/activate # Activar en Windows env\Scripts\activate |
Paso 2: Instalar Django y psycopg2
La librería psycopg2 es el adaptador que conecta Django con PostgreSQL.
|
1 2 |
pip install django psycopg2-binary |
Si el comando de instalación falla en psycopg2-binary, asegúrate que tienes instaladas las librerías libpq-dev y python3-dev en tu sistema.
Paso 3: Instalar y configurar PostgreSQL
- Instala PostgreSQL desde https://www.postgresql.org/download/
- Crea la base de datos y el usuario para tu proyecto:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
-- Accede a PostgreSQL psql -U postgres -- Crear base de datos CREATE DATABASE inventario_db; -- Crear usuario con contraseña CREATE USER inventario_user WITH PASSWORD 'tu_contraseña_segura'; -- Dar permisos GRANT ALL PRIVILEGES ON DATABASE inventario_db TO inventario_user; -- Salir \q |
Ya estás listo para iniciar el desarrollo con Django.
Creación del proyecto y aplicación Django
Paso 1: Crear un proyecto Django
|
1 2 3 |
django-admin startproject gestion_inventario cd gestion_inventario |
Paso 2: Crear una aplicación para el inventario
|
1 2 |
python manage.py startapp inventario |
Paso 3: Añadir la app a las configuraciones
Edita el archivo gestion_inventario/settings.py y en la lista INSTALLED_APPS agrega:
|
1 2 3 4 5 |
INSTALLED_APPS = [ ... 'inventario', # Nuestra aplicación de inventario ] |
Paso 4: Configurar la base de datos PostgreSQL
En el mismo archivo settings.py, busca DATABASES y configúralo así:
|
1 2 3 4 5 6 7 8 9 10 11 |
DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': 'inventario_db', 'USER': 'inventario_user', 'PASSWORD': 'tu_contraseña_segura', 'HOST': 'localhost', 'PORT': '5432', } } |
Definición de modelos: Productos y Categorías
Los modelos representan las tablas y estructuras de datos de nuestra base.
En inventario/models.py, define los siguientes modelos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
from django.db import models class Categoria(models.Model): nombre = models.CharField(max_length=100, unique=True) def __str__(self): return self.nombre class Producto(models.Model): nombre = models.CharField(max_length=200) categoria = models.ForeignKey(Categoria, on_delete=models.CASCADE) descripcion = models.TextField(blank=True, null=True) cantidad = models.PositiveIntegerField(default=0) precio = models.DecimalField(max_digits=10, decimal_places=2) fecha_creacion = models.DateTimeField(auto_now_add=True) def __str__(self): return self.nombre |
Explicación
Categoriatiene un solo camponombre, único para evitar duplicados.Productose relaciona conCategoriamediante una clave foránea (ForeignKey).- Campos como
cantidadypreciomanejan inventario y costos.
Paso 1: Migrar los modelos para crear las tablas en PostgreSQL
|
1 2 3 |
python manage.py makemigrations python manage.py migrate |
Implementación de vistas CRUD
Django facilita la creación de vistas usando clases genéricas para operaciones CRUD.
En inventario/views.py implementaremos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
from django.shortcuts import render, get_object_or_404, redirect from django.views import View from .models import Producto, Categoria from .forms import ProductoForm, CategoriaForm # Vista para listar productos class ProductoListView(View): def get(self, request): productos = Producto.objects.all() return render(request, 'inventario/producto_list.html', {'productos': productos}) # Vista para crear producto class ProductoCreateView(View): def get(self, request): form = ProductoForm() return render(request, 'inventario/producto_form.html', {'form': form}) def post(self, request): form = ProductoForm(request.POST) if form.is_valid(): form.save() return redirect('producto_list') return render(request, 'inventario/producto_form.html', {'form': form}) # Vista para actualizar producto class ProductoUpdateView(View): def get(self, request, pk): producto = get_object_or_404(Producto, pk=pk) form = ProductoForm(instance=producto) return render(request, 'inventario/producto_form.html', {'form': form}) def post(self, request, pk): producto = get_object_or_404(Producto, pk=pk) form = ProductoForm(request.POST, instance=producto) if form.is_valid(): form.save() return redirect('producto_list') return render(request, 'inventario/producto_form.html', {'form': form}) # Vista para eliminar producto class ProductoDeleteView(View): def get(self, request, pk): producto = get_object_or_404(Producto, pk=pk) return render(request, 'inventario/producto_confirm_delete.html', {'producto': producto}) def post(self, request, pk): producto = get_object_or_404(Producto, pk=pk) producto.delete() return redirect('producto_list') |
Formularios para productos y categorías
Para que el usuario pueda crear y modificar registros, creamos formularios en inventario/forms.py:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
from django import forms from .models import Producto, Categoria class CategoriaForm(forms.ModelForm): class Meta: model = Categoria fields = ['nombre'] class ProductoForm(forms.ModelForm): class Meta: model = Producto fields = ['nombre', 'categoria', 'descripcion', 'cantidad', 'precio'] |
Configuración de URLs
Paso 1: Crear el archivo inventario/urls.py
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from django.urls import path from .views import ( ProductoListView, ProductoCreateView, ProductoUpdateView, ProductoDeleteView ) urlpatterns = [ path('', ProductoListView.as_view(), name='producto_list'), path('nuevo/', ProductoCreateView.as_view(), name='producto_crear'), path('editar/<int:pk>/', ProductoUpdateView.as_view(), name='producto_editar'), path('eliminar/<int:pk>/', ProductoDeleteView.as_view(), name='producto_eliminar'), ] |
Paso 2: Incluir las URLs en el proyecto
Edita gestion_inventario/urls.py para apuntar a la app inventario:
|
1 2 3 4 5 6 7 8 |
from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('inventario.urls')), ] |
Integración con la base de datos PostgreSQL
Para verificar que la integración funciona correctamente, inicia el servidor y crea un superusuario para acceder a la administración:
|
1 2 3 |
python manage.py createsuperuser python manage.py runserver |
Ingresa a http://127.0.0.1:8000/admin y verifica que puedes crear categorías y productos.
Plantillas HTML básicas
Crea una carpeta templates/inventario/ dentro de la app y agrega archivos HTML simples. Por ejemplo, producto_list.html:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
<!-- templates/inventario/producto_list.html --> <!DOCTYPE html> <html lang="es"> <head> <meta charset="UTF-8"> <title>Lista de Productos</title> </head> <body> <h1>Productos</h1> <a href="{% url 'producto_crear' %}">Crear Producto Nuevo</a> <ul> {% for producto in productos %} <li> {{ producto.nombre }} - {{ producto.categoria.nombre }} - ${{ producto.precio }} <a href="{% url 'producto_editar' producto.pk %}">Editar</a> <a href="{% url 'producto_eliminar' producto.pk %}">Eliminar</a> </li> {% empty %} <li>No hay productos registrados.</li> {% endfor %} </ul> </body> </html> |
Las demás plantillas pueden ser similares, en torno al uso de formularios y confirmaciones.
Despliegue básico
Para desplegar tu aplicación localmente y probar su funcionamiento:
Paso 1: Instalar Gunicorn y psycopg2
|
1 2 |
pip install gunicorn |
Paso 2: Probar Gunicorn
|
1 2 |
gunicorn gestion_inventario.wsgi |
Se iniciará el servidor en el puerto 8000.
Paso 3: Configurar variables de entorno
No olvides usar variables de entorno para contraseñas y configuraciones sensibles en producción.
Paso 4: Documentación básica
Para producción te recomendamos aprender sobre servidores como Nginx, manejar archivos estáticos, y usar Docker para contenerización.
Conclusión y buenas prácticas
En este tutorial hemos cubierto la creación de un sistema de inventario usando Django y PostgreSQL paso a paso, desde la configuración inicial hasta la implementación de funcionalidades básicas CRUD.
Buenas prácticas recomendadas:
- Usa entornos virtuales para gestionar dependencias.
- Aplica migraciones de Django para gestionar cambios en modelos.
- Usa clases basadas en vistas para mantener el código organizado.
- Protege y gestiona tus credenciales con variables de entorno.
- Separa la lógica backend y frontend para mantener el código limpio.
- Documenta tu código y mantén un control de versiones (Git).
Ahora puedes seguir ampliando este proyecto, agregar autenticación, reportes y una interfaz más amigable.
¡Manos a la obra! Desarrolla y mejora tu sistema de inventario con Django y PostgreSQL.
