Install Laravel and set up authentication using Breeze or Jetstream. 2. Create models and migrations for core content like Post with fields for title, slug, body, and user relationship. 3. Build an admin controller with CRUD operations for managing posts. 4. Design Blade views for the admin panel to list, create, edit, and delete posts. 5. Implement authorization using Laravel policies to control access based on user roles. 6. Handle file uploads by storing media and creating symbolic links. 7. Set up public routes and controllers to display published content. 8. Extend functionality with categories, editors, caching, and search. A Laravel-based CMS is built step by step with full control over features and security, starting from basic content management and scaling with advanced modules, resulting in a fully functional and customizable system.

Implementing a content management system (CMS) with Laravel involves setting up a structured application that allows users to manage dynamic content—like pages, blog posts, media, and user roles—through a secure admin interface. Laravel’s robust features make it ideal for building a custom CMS. Here’s how to do it step by step.

1. Set Up Laravel and Basic Structure

Start by creating a new Laravel project and installing necessary dependencies:

composer create-project laravel/laravel my-cms
cd my-cms

Install Laravel Breeze or Jetstream for authentication (recommended):

composer require laravel/breeze --dev
php artisan breeze:install
npm install && npm run dev
php artisan migrate

This gives you login, registration, and password reset functionality out of the box.

2. Define Core Content Models and Migrations

Most CMS platforms need models like Page, Post, Category, Tag, and Media. Let’s create a basic Post model:

php artisan make:model Post -mf

Edit the migration to include essential fields:

// database/migrations/xxxx_create_posts_table.php
Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->string('slug')->unique();
    $table->text('excerpt')->nullable();
    $table->longText('body');
    $table->boolean('is_published')->default(false);
    $table->timestamp('published_at')->nullable();
    $table->foreignId('user_id')->constrained()->onDelete('cascade');
    $table->timestamps();
});

Run the migration:

php artisan migrate

Then define the relationship in the User model:

// app/Models/User.php
public function posts()
{
    return $this->hasMany(Post::class);
}

And in the Post model:

// app/Models/Post.php
use Illuminate\Support\Str;

protected static function boot()
{
    parent::boot();

    static::saving(function ($post) {
        $post->slug = Str::slug($post->title);
    });
}

3. Create Admin Panel and Controllers

Generate a controller for managing posts:

php artisan make:controller Admin/PostController --resource

Set up routes in routes/web.php:

use App\Http\Controllers\Admin\PostController;

Route::middleware(['auth'])->prefix('admin')->group(function () {
    Route::resource('posts', PostController::class);
});

Now implement basic CRUD methods in PostController:

// app/Http/Controllers/Admin/PostController.php

public function index()
{
    $posts = Post::with('user')->latest()->paginate(10);
    return view('admin.posts.index', compact('posts'));
}

public function create()
{
    return view('admin.posts.create');
}

public function store(Request $request)
{
    $request->validate([
        'title' => 'required|max:255',
        'body' => 'required',
        'is_published' => 'boolean'
    ]);

    $post = new Post($request->only('title', 'excerpt', 'body', 'is_published'));
    $post->user_id = auth()->id();
    if ($request->is_published) {
        $post->published_at = now();
    }
    $post->save();

    return redirect()->route('admin.posts.index')->with('success', 'Post created.');
}

Add similar logic for edit, update, and destroy.

4. Build Admin Views with Blade

Create Blade templates in resources/views/admin/posts/:

• index.blade.php – list all posts
• create.blade.php – form to create a new post
• edit.blade.php – edit existing post

Example form field in create/edit:

<form action="{{ route('admin.posts.store') }}" method="POST">
    @csrf
    <input type="text" name="title" placeholder="Title" required>
    <textarea name="body" rows="10" placeholder="Content" required></textarea>
    <label><input type="checkbox" name="is_published"> Publish Now</label>
    <button type="submit">Save</button>
</form>

Use Laravel’s @error directives for validation feedback.

5. Add Authorization and Roles (Optional)

For multi-user roles (admin, editor, author), use Laravel’s policies:

php artisan make:policy PostPolicy --model=Post

Register the policy in AuthServiceProvider:

protected $policies = [
    Post::class => PostPolicy::class,
];

Then define abilities in PostPolicy.php:

public function update(User $user, Post $post)
{
    return $user->id === $post->user_id || $user->is_admin;
}

Apply in controller:

public function edit(Post $post)
{
    $this->authorize('update', $post);
    return view('admin.posts.edit', compact('post'));
}

6. Handle Media and File Uploads

To upload images or files with posts:

// In PostController@store
if ($request->hasFile('image')) {
    $path = $request->file('image')->store('public/posts');
    $post->image = str_replace('public/', 'storage/', $path);
}

Make sure to run:

php artisan storage:link

And in .env, ensure APP_URL is correct for asset access.

7. Add SEO and Frontend Display

Create a public-facing route for viewing posts:

Route::get('/blog/{slug}', [PostController::class, 'show'])->name('blog.show');

In the controller:

public function show($slug)
{
    $post = Post::where('slug', $slug)->where('is_published', true)->firstOrFail();
    return view('blog.show', compact('post'));
}

Display content safely with !! or use a markdown parser like Parsedown.

8. Extend with Additional Features

You can expand your CMS by adding:

• Categories and tags (with many-to-many relationships)
• WYSIWYG editor (like TinyMCE or Trix)
• Caching for performance
• Search functionality using Scout
• Multi-language support via spatie/laravel-translatable
• Page builder using repeaters or JSON fields

Final Notes

Laravel doesn’t come with a built-in CMS, but its flexibility lets you build one tailored to your needs. For faster development, consider using packages like:

• October CMS – Laravel-based headless CMS
• Statamic – commercial Laravel CMS
• FusionCMS or AsgardCMS – modular Laravel CMS platforms

But if you want full control, building your own with Laravel is a solid approach.

Basically, start small with posts and users, secure access, and grow from there.

The above is the detailed content of How to implement a content management system (CMS) with Laravel?. For more information, please follow other related articles on the PHP Chinese website!