Laravel

Aprende Laravel: Proyecto Práctico - Blog Simple

Autorangel cruz
Actualizado
Publicado
Lectura7 min de lectura
Aprende Laravel: Proyecto Práctico - Blog Simple

En este proyecto armas un blog completo con Laravel 13, paso a paso: login con Breeze, el model Post con su migración, un resource controller para el CRUD, vistas Blade, una Policy para que solo el autor edite su post y, al final, el deploy a producción.

Has llegado al proyecto práctico de la serie. En los 5 posts anteriores aprendiste instalación, rutas, vistas, controllers y models. Ahora vas a juntar todo eso para construir un blog completo desde cero.

¿Qué vamos a construir?

Un blog funcional con estas features:

  • Autenticación de usuarios (login/registro)
  • CRUD completo de posts (crear, leer, actualizar, eliminar)
  • Sistema de comentarios
  • Autorización (solo el autor puede editar su post)
  • Búsqueda de posts
  • Paginación
  • Estados: Published/Draft

Stack tecnológico

  • Laravel 13: Framework principal
  • Blade: Motor de plantillas
  • Breeze: Kit de autenticación
  • SQLite: Base de datos (fácil para desarrollo)
  • Tailwind CSS: Styling (incluido con Breeze)

Paso 1: Crear el proyecto

Abre tu terminal y ejecuta:

laravel new blog-simple
cd blog-simple

El instalador de Laravel 13 te pregunta si quieres un starter kit: responde que no y elige Blade como stack. Instalamos Breeze manualmente en el Paso 3.

O usando Composer (también válido):

composer create-project laravel/laravel blog-simple
cd blog-simple

Paso 2: Configurar la base de datos

Para este tutorial usaremos SQLite (no requiere instalación). Laravel 13 ya viene configurado así: la instalación crea database/database.sqlite y el .env trae estas líneas:

DB_CONNECTION=sqlite
# DB_HOST=127.0.0.1
# DB_PORT=3306
# DB_DATABASE=laravel

Ejecuta las migrations iniciales:

php artisan migrate

SQLite es perfecto para desarrollo y prototipos. Para producción, considera MySQL o PostgreSQL.

Paso 3: Instalar Laravel Breeze

Un aviso antes de instalar: Breeze ya no está entre los starter kits oficiales de Laravel 13 y su README dice que está pensado para Laravel 11 o anteriores. Aquí lo usamos porque es la forma más simple de tener login con Blade puro; para un proyecto nuevo de verdad, mira el starter kit de Livewire.

Laravel Breeze provee autenticación lista para usar (login, registro, recuperación de contraseña). Guarda las contraseñas hasheadas por ti, y si te interesa qué hace por debajo lo desgloso en hashing de contraseñas con PHP:

composer require laravel/breeze --dev
php artisan breeze:install

Te preguntará el stack, si quieres dark mode y qué framework de testing prefieres. Elige Blade y responde lo demás según prefieras:

Which Breeze stack would you like to install?
> Blade with Alpine
 
Would you like dark mode support? (yes/no) [No]
> No
 
Which testing framework do you prefer? [Pest]
> Pest

Instala las dependencias de npm y compila assets:

npm install
npm run dev

Breeze no trae migraciones propias: las tablas de usuarios y de restablecimiento de contraseñas ya vienen con Laravel y las creaste en el Paso 2.

Levanta el servidor:

php artisan serve

Visita http://127.0.0.1:8000 y verás links de Login y Register en el header.

Paso 4: Crear el modelo Post con su migración

php artisan make:model Post -m

Edita la migration (database/migrations/xxxx_create_posts_table.php):

public function up(): void
{
    Schema::create('posts', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->onDelete('cascade');
        $table->string('title');
        $table->text('content');
        $table->boolean('published')->default(false);
        $table->timestamp('published_at')->nullable();
        $table->timestamps();
    });
}

En SQLite, que es lo que usamos aquí, una columna TEXT no tiene ese tope práctico. Si en producción pasas a MySQL, text('content') sí se queda en 65.535 bytes; si tu contenido puede pasarse, compara antes los tamaños máximos de TEXT, MEDIUMTEXT y LONGTEXT.

Ejecuta la migration:

php artisan migrate

Paso 5: Configurar el modelo Post

Edita app/Models/Post.php:

<?php
 
namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
 
class Post extends Model
{
    protected $fillable = [
        'title',
        'content',
        'published',
        'published_at',
    ];
 
    protected function casts(): array
    {
        return [
            'published' => 'boolean',
            'published_at' => 'datetime',
        ];
    }
 
    // Relación: Un post pertenece a un usuario
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

Y actualiza app/Models/User.php:

use Illuminate\Database\Eloquent\Relations\HasMany;
 
public function posts(): HasMany
{
    return $this->hasMany(Post::class);
}

Paso 6: Crear el PostController

php artisan make:controller PostController --resource

Edita app/Http/Controllers/PostController.php:

<?php
 
namespace App\Http\Controllers;
 
use App\Models\Post;
use Illuminate\Http\Request;
use Illuminate\Routing\Controllers\HasMiddleware;
use Illuminate\Routing\Controllers\Middleware;
use Illuminate\Support\Facades\Auth;
 
class PostController extends Controller implements HasMiddleware
{
    public static function middleware(): array
    {
        // Requiere autenticación excepto para index y show
        return [
            new Middleware('auth', except: ['index', 'show']),
        ];
    }
 
    public function index()
    {
        $posts = Post::with('user')
            ->where('published', true)
            ->latest()
            ->paginate(10);
 
        return view('posts.index', compact('posts'));
    }
 
    public function create()
    {
        return view('posts.create');
    }
 
    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
            'published' => 'boolean',
        ]);
 
        $post = Auth::user()->posts()->create([
            'title' => $validated['title'],
            'content' => $validated['content'],
            'published' => $request->has('published'),
            'published_at' => $request->has('published') ? now() : null,
        ]);
 
        return redirect()
            ->route('posts.show', $post)
            ->with('success', 'Post creado exitosamente!');
    }
 
    public function show(Post $post)
    {
        // Solo mostrar posts publicados o del autor
        if (!$post->published && $post->user_id !== Auth::id()) {
            abort(404);
        }
 
        return view('posts.show', compact('post'));
    }
 
    public function edit(Post $post)
    {
        // Autorización: solo el autor puede editar
        if ($post->user_id !== Auth::id()) {
            abort(403);
        }
 
        return view('posts.edit', compact('post'));
    }
 
    public function update(Request $request, Post $post)
    {
        if ($post->user_id !== Auth::id()) {
            abort(403);
        }
 
        $validated = $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
            'published' => 'boolean',
        ]);
 
        $post->update([
            'title' => $validated['title'],
            'content' => $validated['content'],
            'published' => $request->has('published'),
            'published_at' => $request->has('published') ? ($post->published_at ?? now()) : null,
        ]);
 
        return redirect()
            ->route('posts.show', $post)
            ->with('success', 'Post actualizado!');
    }
 
    public function destroy(Post $post)
    {
        if ($post->user_id !== Auth::id()) {
            abort(403);
        }
 
        $post->delete();
 
        return redirect()
            ->route('posts.index')
            ->with('success', 'Post eliminado!');
    }
}

Route Model Binding en acción: Laravel automáticamente busca el Post por ID en la URL. Si no existe, retorna 404.

Paso 7: Definir las rutas

Edita routes/web.php. Breeze ya dejó ahí las rutas de dashboard y de perfil, y su navegación y su login dependen de ellas, así que no las borres: solo cambia la ruta / y agrega el resource de posts.

<?php
 
use App\Http\Controllers\PostController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;
 
Route::get('/', function () {
    return redirect()->route('posts.index');
});
 
Route::get('/dashboard', function () {
    return view('dashboard');
})->middleware(['auth', 'verified'])->name('dashboard');
 
Route::middleware('auth')->group(function () {
    Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
    Route::patch('/profile', [ProfileController::class, 'update'])->name('profile.update');
    Route::delete('/profile', [ProfileController::class, 'destroy'])->name('profile.destroy');
});
 
Route::resource('posts', PostController::class);
 
require __DIR__.'/auth.php';

Paso 8: Crear las vistas

Layout principal (resources/views/layouts/app.blade.php) ya viene con Breeze. Como el index y el show son públicos, envuelve su @include('layouts.navigation') en @auth ... @endauth: la navegación de Breeze imprime Auth::user()->name y fallaría con un visitante sin sesión.

Vista Index - Crea resources/views/posts/index.blade.php:

<x-app-layout>
    <x-slot name="header">
        <div class="flex justify-between items-center">
            <h2 class="font-semibold text-xl text-gray-800 leading-tight">
                Blog Posts
            </h2>
            @auth
                <a href="{{ route('posts.create') }}" class="bg-blue-500 text-white px-4 py-2 rounded">
                    Nuevo Post
                </a>
            @endauth
        </div>
    </x-slot>
 
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            @if (session('success'))
                <div class="bg-green-100 border border-green-400 text-green-700 px-4 py-3 rounded mb-4">
                    {{ session('success') }}
                </div>
            @endif
 
            <div class="bg-white overflow-hidden shadow-sm sm:rounded-lg">
                <div class="p-6 text-gray-900">
                    @forelse($posts as $post)
                        <article class="mb-8 pb-8 border-b last:border-0">
                            <h2 class="text-2xl font-bold mb-2">
                                <a href="{{ route('posts.show', $post) }}" class="hover:text-blue-600">
                                    {{ $post->title }}
                                </a>
                            </h2>
                            <p class="text-gray-600 text-sm mb-4">
                                Por {{ $post->user->name }} • {{ $post->published_at->diffForHumans() }}
                            </p>
                            <p class="text-gray-700 mb-4">
                                {{ Str::limit($post->content, 200) }}
                            </p>
                            <a href="{{ route('posts.show', $post) }}" class="text-blue-600 hover:underline">
                                Leer más →
                            </a>
                        </article>
                    @empty
                        <p class="text-gray-500">No hay posts publicados aún.</p>
                    @endforelse
 
                    <div class="mt-6">
                        {{ $posts->links() }}
                    </div>
                </div>
            </div>
        </div>
    </div>
</x-app-layout>

Vista Create - Crea resources/views/posts/create.blade.php:

<x-app-layout>
    <x-slot name="header">
        <h2 class="font-semibold text-xl text-gray-800 leading-tight">
            Crear Nuevo Post
        </h2>
    </x-slot>
 
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            <div class="bg-white overflow-hidden shadow-sm sm:rounded-lg">
                <div class="p-6 text-gray-900">
                    <form action="{{ route('posts.store') }}" method="POST">
                        @csrf
 
                        <div class="mb-4">
                            <label for="title" class="block text-gray-700 font-bold mb-2">Título</label>
                            <input
                                type="text"
                                name="title"
                                id="title"
                                value="{{ old('title') }}"
                                class="w-full border-gray-300 rounded-md shadow-sm"
                                required
                            >
                            @error('title')
                                <p class="text-red-500 text-sm mt-1">{{ $message }}</p>
                            @enderror
                        </div>
 
                        <div class="mb-4">
                            <label for="content" class="block text-gray-700 font-bold mb-2">Contenido</label>
                            <textarea
                                name="content"
                                id="content"
                                rows="10"
                                class="w-full border-gray-300 rounded-md shadow-sm"
                                required
                            >{{ old('content') }}</textarea>
                            @error('content')
                                <p class="text-red-500 text-sm mt-1">{{ $message }}</p>
                            @enderror
                        </div>
 
                        <div class="mb-4">
                            <label class="flex items-center">
                                <input type="checkbox" name="published" value="1" class="mr-2">
                                <span class="text-gray-700">Publicar inmediatamente</span>
                            </label>
                        </div>
 
                        <div class="flex gap-4">
                            <button type="submit" class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">
                                Crear Post
                            </button>
                            <a href="{{ route('posts.index') }}" class="bg-gray-300 text-gray-700 px-4 py-2 rounded hover:bg-gray-400">
                                Cancelar
                            </a>
                        </div>
                    </form>
                </div>
            </div>
        </div>
    </div>
</x-app-layout>

Vista Show - Crea resources/views/posts/show.blade.php:

<x-app-layout>
    <x-slot name="header">
        <div class="flex justify-between items-center">
            <h2 class="font-semibold text-xl text-gray-800 leading-tight">
                {{ $post->title }}
            </h2>
            @can('update', $post)
                <div class="flex gap-2">
                    <a href="{{ route('posts.edit', $post) }}" class="bg-yellow-500 text-white px-4 py-2 rounded">
                        Editar
                    </a>
                    <form action="{{ route('posts.destroy', $post) }}" method="POST" onsubmit="return confirm('¿Estás seguro?')">
                        @csrf
                        @method('DELETE')
                        <button type="submit" class="bg-red-500 text-white px-4 py-2 rounded">
                            Eliminar
                        </button>
                    </form>
                </div>
            @endcan
        </div>
    </x-slot>
 
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            @if (session('success'))
                <div class="bg-green-100 border border-green-400 text-green-700 px-4 py-3 rounded mb-4">
                    {{ session('success') }}
                </div>
            @endif
 
            <div class="bg-white overflow-hidden shadow-sm sm:rounded-lg">
                <div class="p-6 text-gray-900">
                    <p class="text-gray-600 text-sm mb-6">
                        Por {{ $post->user->name }} • {{ $post->published_at?->format('d/m/Y') ?? 'Borrador' }}
                    </p>
 
                    <div class="prose max-w-none">
                        {!! nl2br(e($post->content)) !!}
                    </div>
 
                    <div class="mt-8 pt-8 border-t">
                        <a href="{{ route('posts.index') }}" class="text-blue-600 hover:underline">
                            ← Volver a todos los posts
                        </a>
                    </div>
                </div>
            </div>
        </div>
    </div>
</x-app-layout>

Vista Edit - Crea resources/views/posts/edit.blade.php:

<x-app-layout>
    <x-slot name="header">
        <h2 class="font-semibold text-xl text-gray-800 leading-tight">
            Editar Post
        </h2>
    </x-slot>
 
    <div class="py-12">
        <div class="max-w-7xl mx-auto sm:px-6 lg:px-8">
            <div class="bg-white overflow-hidden shadow-sm sm:rounded-lg">
                <div class="p-6 text-gray-900">
                    <form action="{{ route('posts.update', $post) }}" method="POST">
                        @csrf
                        @method('PUT')
 
                        <div class="mb-4">
                            <label for="title" class="block text-gray-700 font-bold mb-2">Título</label>
                            <input
                                type="text"
                                name="title"
                                id="title"
                                value="{{ old('title', $post->title) }}"
                                class="w-full border-gray-300 rounded-md shadow-sm"
                                required
                            >
                            @error('title')
                                <p class="text-red-500 text-sm mt-1">{{ $message }}</p>
                            @enderror
                        </div>
 
                        <div class="mb-4">
                            <label for="content" class="block text-gray-700 font-bold mb-2">Contenido</label>
                            <textarea
                                name="content"
                                id="content"
                                rows="10"
                                class="w-full border-gray-300 rounded-md shadow-sm"
                                required
                            >{{ old('content', $post->content) }}</textarea>
                            @error('content')
                                <p class="text-red-500 text-sm mt-1">{{ $message }}</p>
                            @enderror
                        </div>
 
                        <div class="mb-4">
                            <label class="flex items-center">
                                <input
                                    type="checkbox"
                                    name="published"
                                    value="1"
                                    {{ old('published', $post->published) ? 'checked' : '' }}
                                    class="mr-2"
                                >
                                <span class="text-gray-700">Publicado</span>
                            </label>
                        </div>
 
                        <div class="flex gap-4">
                            <button type="submit" class="bg-blue-500 text-white px-4 py-2 rounded hover:bg-blue-600">
                                Actualizar Post
                            </button>
                            <a href="{{ route('posts.show', $post) }}" class="bg-gray-300 text-gray-700 px-4 py-2 rounded hover:bg-gray-400">
                                Cancelar
                            </a>
                        </div>
                    </form>
                </div>
            </div>
        </div>
    </div>
</x-app-layout>

Paso 9: Crear una Policy para la autorización

php artisan make:policy PostPolicy --model=Post

Edita app/Policies/PostPolicy.php:

<?php
 
namespace App\Policies;
 
use App\Models\Post;
use App\Models\User;
 
class PostPolicy
{
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
 
    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
}

Las Policies centralizan la lógica de autorización. Usa @can en Blade y Gate::authorize() en controllers para aplicarlas.

Paso 10: Probar la aplicación

  1. Registra un usuario: Ve a /register
  2. Crea un post: Click en "Nuevo Post"
  3. Publica el post: Marca el checkbox "Publicar"
  4. Edita tu post: Solo tú verás el botón "Editar"
  5. Cierra sesión y verás que el post sigue visible pero no puedes editarlo

Características adicionales (opcionales)

1. Búsqueda de Posts

Amplía el método index del controller:

public function index(Request $request)
{
    $query = Post::with('user')->where('published', true);
 
    if ($search = $request->input('search')) {
        $query->where(function($q) use ($search) {
            $q->where('title', 'like', "%{$search}%")
              ->orWhere('content', 'like', "%{$search}%");
        });
    }
 
    $posts = $query->latest()->paginate(10);
 
    return view('posts.index', compact('posts'));
}

Y agrega un formulario de búsqueda en index.blade.php.

2. Comentarios

Crea un model Comment con relación a Post y User.

3. Categorías

Crea un model Category con relación Many-to-Many con Post.

Deploy a producción

Opciones de hosting:

  1. Laravel Forge - Fácil, automatizado, desde $12/mes
  2. Laravel Cloud - Plataforma oficial de Laravel, optimizada para Laravel
  3. Railway - Deploy con Git; ofrece un periodo de prueba con crédito inicial y después planes de pago
  4. DigitalOcean - VPS desde $4/mes, según su página de precios

Pasos básicos para deploy:

# 1. Configurar .env de producción
APP_ENV=production
APP_DEBUG=false
APP_URL=https://tublog.com
 
# 2. Generar APP_KEY si no existe (antes de cachear la config)
php artisan key:generate
 
# 3. Optimizar
php artisan config:cache
php artisan route:cache
php artisan view:cache
 
# 4. Migrar database
php artisan migrate --force

NUNCA hagas commit de tu archivo .env! Cada entorno debe tener su propio .env con credenciales únicas.

Siguientes pasos: expande tu blog

Ahora que tienes un blog funcional, puedes agregar:

  • Rich Text Editor: Integra TinyMCE o Trix
  • Image Uploads: Usa Laravel Storage
  • Tags: Sistema de etiquetas con Many-to-Many
  • RSS Feed: Para suscriptores
  • API: Exponer posts vía JSON API
  • Testing: Escribe tests con Pest/PHPUnit
  • Emails: Notificaciones de nuevos comentarios
  • Admin Dashboard: Panel con estadísticas

Conclusión de la primera parte

Felicidades por completar la primera parte de la serie Aprende Laravel Fundamentals. Has aprendido:

  1. Instalación y Setup
  2. Rutas
  3. Vistas y Layouts
  4. Controllers
  5. Models y Database
  6. Proyecto Práctico (este post)

La serie sigue con validación y después autenticación, middleware, testing con Pest, componentes Blade, Artisan y deploy. Más adelante puedes explorar temas más avanzados como:

  • Testing con Pest/PHPUnit
  • APIs RESTful con Laravel Sanctum
  • Queues & Jobs para tareas asíncronas
  • Broadcasting con Laravel Echo
  • Packages - Crea tu propio paquete

Preguntas frecuentes

¿Necesito saber JavaScript para crear un blog con Laravel?

No. Este tutorial usa Breeze con Blade y casi no toca JavaScript, y con el Livewire Starter Kit de Laravel 13 también puedes crear un blog completamente funcional usando solo PHP y Blade. Livewire proporciona reactividad sin escribir JavaScript. Sin embargo, conocer JavaScript básico te ayudará a personalizar el comportamiento.

¿Cómo protejo el panel de administración?

Usa middleware de autenticación: Route::middleware('auth')->group(function() { ... }). Breeze, como el Livewire Starter Kit, incluye autenticación completa (login, registro, recuperar contraseña) lista para usar. También puedes usar Policies para controlar permisos granulares.

¿Cómo añado un editor WYSIWYG para los posts?

Integra un editor como TinyMCE o Trix. Para Livewire, usa wire:ignore en el contenedor del editor y despacha eventos para actualizar el modelo. Alternativamente, si armas el panel con FilamentPHP, sus campos MarkdownEditor y RichEditor ya traen un editor integrado.

¿Cómo implemento categorías y tags en los posts?

Crea una relación Many-to-Many entre Posts y Categories/Tags usando una tabla pivot. Define en el model Post: public function categories() { return $this->belongsToMany(Category::class); }. Usa attach() y sync() para gestionar las relaciones.

¿Cómo añado paginación a la lista de posts?

Cambia Post::all() por Post::paginate(15). En la vista Blade, añade {{ $posts->links() }} para mostrar los controles de paginación. Laravel usa Tailwind CSS para los estilos de paginación por defecto.

¿Cómo implemento búsqueda en el blog?

Usa Post::where('title', 'like', "%{$query}%")->orWhere('content', 'like', "%{$query}%")->get(). Para búsqueda avanzada, considera Laravel Scout con Algolia/Meilisearch, o el paquete spatie/laravel-searchable para búsqueda en base de datos.

Recursos adicionales

Fuentes

Muchas gracias por seguir esta serie. Si tienes preguntas, déjalas en los comentarios.

¿Tienes un proyecto en mente?

Trabajo con Laravel, WordPress, SEO técnico y servidores MCP. El primer paso es una llamada de descubrimiento, sin costo ni compromiso, donde me cuentas qué necesitas y te digo con honestidad si puedo ayudarte.

Hablemos