CÓMO CREAR UNA APP DE REDES SOCIALES CON DJANGO

November 23, 2025

Introducción a la Creación de una Aplicación de Redes Sociales con Django

Django es un framework de desarrollo web robusto y escalable basado en Python, ideal para construir aplicaciones complejas como una red social. Este tutorial te guiará paso a paso para crear una aplicación de redes sociales que permita a los usuarios registrarse, iniciar sesión, crear publicaciones, seguir a otros usuarios y gestionar perfiles. Aprovecharemos las características integradas de Django, como el sistema de autenticación y el ORM, para agilizar el desarrollo. Además, incorporaremos Django REST Framework para una API que facilite la interacción con la aplicación. Este tutorial está diseñado para desarrolladores con conocimientos básicos de Python y Django, y se enfoca en un sitio web de programación y noticias tecnológicas.

Antes de comenzar, asegúrate de tener instalado Python 3.10 o superior, pip, y un entorno virtual para gestionar las dependencias. También necesitarás un editor de código como Visual Studio Code y conocimientos básicos de HTML y CSS para las plantillas.

Configuración del Entorno de Desarrollo

Para iniciar, crea un directorio para el proyecto y configura un entorno virtual. Esto aísla las dependencias y evita conflictos entre proyectos.

mkdir social_media_app
cd social_media_app
python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

Instala Django y Django REST Framework usando pip.

pip install django djangorestframework

Crea un archivo requirements.txt para documentar las dependencias.

django>=5.0
djangorestframework>=3.15

Creación del Proyecto Django

Inicia un nuevo proyecto Django con el comando django-admin. Esto genera la estructura básica del proyecto.

django-admin startproject social_media .

La estructura del proyecto será similar a:

social_media/
├── manage.py
├── social_media/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── asgi.py
│   └── wsgi.py
└── venv/

Actualiza el archivo settings.py para incluir la zona horaria y el idioma. Por ejemplo, para español y la zona horaria de México:

# social_media/settings.py
LANGUAGE_CODE = 'es-mx'
TIME_ZONE = 'America/Mexico_City'
USE_I18N = True
USE_TZ = True

Creación de la Aplicación de Usuarios

Crea una aplicación para gestionar la autenticación y los perfiles de usuarios. Usa el comando startapp.

python manage.py startapp users

Registra la aplicación en settings.py.

# social_media/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'users',
]

Define un modelo personalizado para los usuarios en users/models.py. Este modelo extenderá el modelo base de Django para incluir campos adicionales como biografía y foto de perfil.

# users/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    bio = models.TextField(max_length=500, blank=True)
    profile_picture = models.ImageField(upload_to='profile_pics/', blank=True, null=True)
    following = models.ManyToManyField('self', symmetrical=False, related_name='followers', blank=True)

    def __str__(self):
        return self.username

Actualiza settings.py para usar el modelo personalizado.

# social_media/settings.py
AUTH_USER_MODEL = 'users.CustomUser'

Crea y aplica las migraciones para generar las tablas en la base de datos.

python manage.py makemigrations
python manage.py migrate

Configuración de la Autenticación

Django proporciona un sistema de autenticación integrado que podemos personalizar. Configura las vistas para el registro, inicio y cierre de sesión. Crea un archivo users/urls.py para definir las rutas.

# users/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('register/', views.register, name='register'),
    path('login/', views.login_view, name='login'),
    path('logout/', views.logout_view, name='logout'),
]

Define las vistas en users/views.py.

# users/views.py
from django.shortcuts import render, redirect
from django.contrib.auth import login, authenticate, logout
from django.contrib.auth.forms import UserCreationForm
from django.contrib import messages

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            messages.success(request, 'Registro exitoso.')
            return redirect('home')
        else:
            messages.error(request, 'Error en el registro.')
    else:
        form = UserCreationForm()
    return render(request, 'users/register.html', {'form': form})

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('home')
        else:
            messages.error(request, 'Credenciales inválidas.')
    return render(request, 'users/login.html')

def logout_view(request):
    logout(request)
    return redirect('login')

Crea las plantillas en users/templates/users/.

<!-- users/templates/users/register.html -->
<!DOCTYPE html>
<html lang="es">
    <head>
        <meta charset="UTF-8" />
        <title>Registro</title>
    </head>
    <body>
        <h2>Registro de Usuario</h2>
        <form method="post">
            {% csrf_token %} {{ form.as_p }}
            <button type="submit">Registrarse</button>
        </form>
        {% for message in messages %}
        <p>{{ message }}</p>
        {% endfor %}
    </body>
</html>

La plantilla de inicio de sesión (login.html) sigue una estructura similar. Configura las URLs principales en social_media/urls.py.

# social_media/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('accounts/', include('users.urls')),
    path('', include('posts.urls')),  # Definiremos esta app más adelante
]

Creación de la Aplicación de Publicaciones

Crea una aplicación para gestionar las publicaciones de los usuarios. Usa el comando startapp.

python manage.py startapp posts

Registra la aplicación en settings.py.

# social_media/settings.py
INSTALLED_APPS = [
    ...
    'posts',
]

Define el modelo de publicaciones en posts/models.py.

# posts/models.py
from django.db import models
from users.models import CustomUser

class Post(models.Model):
    user = models.ForeignKey(CustomUser, on_delete=models.CASCADE)
    content = models.TextField(max_length=1000)
    created_at = models.DateTimeField(auto_now_add=True)
    likes = models.ManyToManyField(CustomUser, related_name='liked_posts', blank=True)

    def __str__(self):
        return f'{self.user.username} - {self.content[:50]}'

Crea y aplica las migraciones.

python manage.py makemigrations
python manage.py migrate

Define las vistas para crear y listar publicaciones en posts/views.py.

# posts/views.py
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from .models import Post
from .forms import PostForm

@login_required
def create_post(request):
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            post = form.save(commit=False)
            post.user = request.user
            post.save()
            return redirect('home')
    else:
        form = PostForm()
    return render(request, 'posts/create_post.html', {'form': form})

@login_required
def home(request):
    posts = Post.objects.all().order_by('-created_at')
    return render(request, 'posts/home.html', {'posts': posts})

Crea el formulario en posts/forms.py.

# posts/forms.py
from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['content']

Define las URLs en posts/urls.py.

# posts/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home, name='home'),
    path('post/create/', views.create_post, name='create_post'),
]

Crea las plantillas en posts/templates/posts/.

<!-- posts/templates/posts/home.html -->
<!DOCTYPE html>
<html lang="es">
    <head>
        <meta charset="UTF-8" />
        <title>Inicio</title>
    </head>
    <body>
        <h2>Bienvenido, {{ user.username }}</h2>
        <a href="{% url 'create_post' %}">Crear Publicación</a>
        <a href="{% url 'logout' %}">Cerrar Sesión</a>
        <h3>Publicaciones</h3>
        {% for post in posts %}
        <div>
            <p><strong>{{ post.user.username }}</strong>: {{ post.content }}</p>
            <p>{{ post.created_at }}</p>
        </div>
        {% endfor %}
    </body>
</html>

La plantilla create_post.html incluye un formulario para ingresar el contenido de la publicación.

Gestión de Perfiles de Usuario

Permite a los usuarios ver y editar sus perfiles. Agrega una vista en users/views.py.

# users/views.py
from django.shortcuts import render, redirect
from .forms import ProfileForm

@login_required
def profile(request):
    if request.method == 'POST':
        form = ProfileForm(request.POST, request.FILES, instance=request.user)
        if form.is_valid():
            form.save()
            return redirect('profile')
    else:
        form = ProfileForm(instance=request.user)
    return render(request, 'users/profile.html', {'form': form})

Crea el formulario en users/forms.py.

# users/forms.py
from django import forms
from .models import CustomUser

class ProfileForm(forms.ModelForm):
    class Meta:
        model = CustomUser
        fields = ['bio', 'profile_picture']

Agrega la URL en users/urls.py.

# users/urls.py
urlpatterns = [
    ...
    path('profile/', views.profile, name='profile'),
]

Crea la plantilla profile.html.

<!-- users/templates/users/profile.html -->
<!DOCTYPE html>
<html lang="es">
    <head>
        <meta charset="UTF-8" />
        <title>Perfil</title>
    </head>
    <body>
        <h2>Tu Perfil</h2>
        <form method="post" enctype="multipart/form-data">
            {% csrf_token %} {{ form.as_p }}
            <button type="submit">Guardar</button>
        </form>
    </body>
</html>

Para manejar archivos como la foto de perfil, configura el almacenamiento de medios en settings.py.

# social_media/settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

Actualiza urls.py para servir archivos de medios durante el desarrollo.

# social_media/urls.py
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    ...
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Implementación de la Funcionalidad de Seguir Usuarios

Permite a los usuarios seguirse mutuamente. Agrega una vista en users/views.py.

# users/views.py
@login_required
def follow_user(request, user_id):
    user_to_follow = CustomUser.objects.get(id=user_id)
    request.user.following.add(user_to_follow)
    return redirect('profile')

Agrega la URL en users/urls.py.

# users/urls.py
urlpatterns = [
    ...
    path('follow/<int:user_id>/', views.follow_user, name='follow_user'),
]

Modifica la plantilla home.html para mostrar un enlace para seguir usuarios.

<!-- posts/templates/posts/home.html -->
{% for post in posts %}
<div>
    <p><strong>{{ post.user.username }}</strong>: {{ post.content }}</p>
    <p>{{ post.created_at }}</p>
    {% if user != post.user %}
    <a href="{% url 'follow_user' post.user.id %}">Seguir</a>
    {% endif %}
</div>
{% endfor %}

Creación de una API con Django REST Framework

Para permitir interacciones programáticas, implementa una API con Django REST Framework. Configura los serializadores en posts/serializers.py.

# posts/serializers.py
from rest_framework import serializers
from .models import Post
from users.models import CustomUser

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = CustomUser
        fields = ['id', 'username', 'bio']

class PostSerializer(serializers.ModelSerializer):
    user = UserSerializer(read_only=True)

    class Meta:
        model = Post
        fields = ['id', 'user', 'content', 'created_at']

Define las vistas de la API en posts/views.py.

# posts/views.py
from rest_framework import generics
from .models import Post
from .serializers import PostSerializer

class PostListCreateAPIView(generics.ListCreateAPIView):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

    def perform_create(self, serializer):
        serializer.save(user=self.request.user)

Configura las URLs en posts/urls.py.

# posts/urls.py
from django.urls import path
from . import views

urlpatterns = [
    ...
    path('api/posts/', views.PostListCreateAPIView.as_view(), name='post_list_create_api'),
]

Habilita la autenticación en settings.py.

# social_media/settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.BasicAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
}

Prueba la API usando un cliente como Postman o cURL.

curl -H "Authorization: Basic username:password" http://127.0.0.1:8000/api/posts/

Configuración de Estilos con CSS

Para mejorar la apariencia, agrega estilos CSS. Crea un directorio static y un archivo styles.css.

static/
└── css/
    └── styles.css

Define estilos básicos.

/* static/css/styles.css */
body {
    font-family: Arial, sans-serif;
    margin: 0;
    padding: 20px;
}

.post {
    border: 1px solid #ccc;
    padding: 10px;
    margin-bottom: 10px;
}

form {
    margin-bottom: 20px;
}

Configura los archivos estáticos en settings.py.

# social_media/settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']

Carga los estilos en las plantillas.

<!-- posts/templates/posts/home.html -->
{% load static %}
<!DOCTYPE html>
<html lang="es">
    <head>
        <meta charset="UTF-8" />
        <title>Inicio</title>
        <link rel="stylesheet" href="{% static 'css/styles.css' %}" />
    </head>
    <body>
        ... {% for post in posts %}
        <div class="post">
            <p><strong>{{ post.user.username }}</strong>: {{ post.content }}</p>
            <p>{{ post.created_at }}</p>
            {% if user != post.user %}
            <a href="{% url 'follow_user' post.user.id %}">Seguir</a>
            {% endif %}
        </div>
        {% endfor %}
    </body>
</html>

Recolecta los archivos estáticos.

python manage.py collectstatic

Pruebas y Depuración

Django incluye un framework de pruebas basado en unittest. Crea pruebas para los modelos y vistas en posts/tests.py.

# posts/tests.py
from django.test import TestCase
from django.contrib.auth import get_user_model
from .models import Post

class PostModelTest(TestCase):
    def setUp(self):
        User = get_user_model()
        self.user = User.objects.create_user(username='testuser', password='testpass')
        self.post = Post.objects.create(user=self.user, content='Test post')

    def test_post_content(self):
        self.assertEqual(self.post.content, 'Test post')
        self.assertEqual(str(self.post), 'testuser - Test post')

Ejecuta las pruebas.

python manage.py test

Habilita el modo de depuración en settings.py para obtener información detallada durante el desarrollo.

# social_media/settings.py
DEBUG = True

Despliegue del Proyecto

Para desplegar la aplicación, usa un servicio como Heroku o Railway. Configura una base de datos PostgreSQL y ajusta settings.py.

# social_media/settings.py
import dj_database_url

DATABASES = {
    'default': dj_database_url.config(default='sqlite:///db.sqlite3')
}

Instala gunicorn y psycopg2-binary para el servidor y la base de datos.

pip install gunicorn psycopg2-binary

Crea un archivo Procfile para Heroku.

web: gunicorn social_media.wsgi

Despliega la aplicación siguiendo las instrucciones del proveedor. Asegúrate de configurar las variables de entorno para DEBUG=False y la clave secreta.

Conclusiones

Este tutorial ha cubierto los pasos esenciales para crear una aplicación de redes sociales con Django, desde la configuración del entorno hasta la implementación de una API y el despliegue. Has aprendido a gestionar autenticación, publicaciones, perfiles y relaciones de seguimiento, aprovechando las herramientas integradas de Django y Django REST Framework. La aplicación resultante es funcional y escalable, ideal para un sitio web de programación y noticias tecnológicas. Puedes extenderla agregando funciones como comentarios, notificaciones o integración con servicios externos. Continúa explorando la documentación oficial de Django para profundizar en temas avanzados como optimización y seguridad.