Esta guía te enseña cómo crear una API RESTful con Django, Django REST Framework (DRF) y MySQL para gestionar datos relacionados con personas, como nombre, edad, sexo, nacionalidad, profesión y hobby. Implementa operaciones CRUD (Crear, Leer, Actualizar, Eliminar) de manera eficiente y segura.
Antes de comenzar, asegúrate de tener instalados los siguientes componentes en tu sistema:
- Python 3.x
- MySQL
- pip (gestor de paquetes de Python)
Crear un Entorno Virtual Primero, crea un entorno virtual para tu proyecto.
pip install virtualenv
Instalar virtualenv globalmente virtualenv env # Crear entorno virtual
virtualenv --version # Ver versión de virtualenvpython -m venv env # Crear entorno virtual.\env\Scripts\activate
### En macOS/Linux:
source env/bin/activate
### Para desactivar el entorno virtual:
deactivateCon el entorno virtual activado, instala Django:
pip install Django
Si necesitas una versión específica de Django:
pip install Django==4.2.4
Para verificar que Django está correctamente instalado:
python -m django --version
Instala el paquete necesario para conectar Django con MySQL:
pip install mysqlclient
Django REST Framework es la librería que te permitirá manejar las solicitudes HTTP en tu API.
pip install djangorestframework
Crea el proyecto base de Django:
django-admin startproject project_core .
Nota: El . al final crea el proyecto en el directorio actual.
Inicia el servidor de desarrollo de Django:
python manage.py runserver 8500
Accede a la URL http://127.0.0.1:8500 en tu navegador.
Crea una nueva aplicación en tu proyecto Django:
python manage.py startapp api_personas
Agrega la aplicación y Django REST Framework en el archivo settings.py:
INSTALLED_APPS = [
...
'rest_framework',
'api_personas',
]Configura la conexión a la base de datos en settings.py:
`DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'api_django_rest_framework',
'USER': 'root',
'PASSWORD': '',
'HOST': '127.0.0.1',
'PORT': '3306',
}
}Crea la base de datos api_django_rest_framework en tu gestor de bases de datos MySQL.
Define el modelo Persona en models.py:
generos = (
("M", "Masculino"),
("F", "Femenino"),
("Otro", "Otro"),
)
class Persona(models.Model):
nombre = models.CharField(max_length=100)
edad = models.IntegerField()
sexo = models.CharField(max_length=5, choices=generos)
nacionalidad = models.CharField(max_length=100)
profesion = models.CharField(max_length=100)
hobby = models.CharField(max_length=100)
created_at = models.DateTimeField(auto_now_add=True, null=True, blank=True)
updated = models.DateTimeField(auto_now=True)
def __str__(self):
return f"{self.id} - {self.nombre} - {self.edad} - {self.sexo} - {self.nacionalidad} - {self.profesion} - {self.hobby}"
class Meta:
db_table = "tbl_personas"
ordering = ['-created_at']Genera y ejecuta las migraciones para crear las tablas en la base de datos:
python manage.py makemigrations python manage.py migrate
Ejecuta nuevamente el servidor:
python manage.py runserver 8500
Para administrar los datos desde el panel de Django, crea un superusuario:
python manage.py createsuperuser
Accede al panel de administración de Django en http://127.0.0.1:8500/admin.
Registra el modelo Persona en el panel de administración:
from django.contrib import admin
from .models import Persona
admin.site.register(Persona)Crea un archivo serializers.py en tu aplicación y define el serializador para convertir los objetos de Persona a JSON:
from rest_framework import serializers
from .models import Persona
class PersonaSerializer(serializers.ModelSerializer):
class Meta:
model = Persona
fields = '__all__'
Define las vistas que manejarán las operaciones CRUD en views.py:
from rest_framework import generics
from .models import Persona
from .serializers import PersonaSerializer
class PersonaListCreate(generics.ListCreateAPIView):
queryset = Persona.objects.all()
serializer_class = PersonaSerializerDefine las rutas en urls.py de la aplicación api_personas:
from django.urls import path
from . import views
urlpatterns = [
path('', views.PersonaListCreate.as_view(), name='persona-list-create'),
]Agrega las rutas de la aplicación al archivo urls.py del proyecto:
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/personas/', include('api_personas.urls')),
]Si tienes un archivo requirements.txt, instala todas las dependencias:
pip install -r requirements.txt
Una vez completados los pasos, tu API estará lista para realizar las operaciones CRUD sobre los datos de Persona. Puedes interactuar con la API desde las siguientes rutas:
http://127.0.0.1:8500/api/personas/- Para listar o agregar personas (GET, POST).http://127.0.0.1:8500/api/personas/1/- Para obtener, actualizar o eliminar una persona específica (GET, PUT, DELETE).
- Comenta sobre este proyecto 📢
- Invita una cerveza 🍺 o un café ☕ Paypal
- Da las gracias públicamente 🤓.
- Routers: Permiten definir las URLs de tu API de manera sencilla y ordenada, encaminando las solicitudes a los métodos correspondientes según el verbo HTTP (GET, POST, PUT, PATCH).
- Vistas en Django: En lugar de renderizar HTML, las vistas de Django devuelven JSON, XML u otros formatos de datos para tu API.
- ViewSets: Son un tipo especial de vista que facilita la definición de múltiples operaciones CRUD de forma más compacta.
- Serializadores: Permiten definir cómo deben ser estructurados los datos en las respuestas de tu API y cómo se procesan los datos en las solicitudes.
- Generics:
ListCreateAPIViewes una vista genérica que soporta las operaciones de listar y crear de manera automática.