Creating the back-end of a Laravel 9 blog using MySQL database
The goal of this tutorial is to teach, step-by-step, how to create a simple Laravel 9 blog application. The main focus here is in the architecture and back-end, although some front-end features will also be added in a future tutorial.
For this tutorial, I’m using the following versions (extracted from
Like in any MVC framework, the first step is to define which entities the system will need and how they relate each other. This is my idea for this system:
With this model in mind, it is clear that we will need 4 entities:
Tag. Each of these entities will became a Model in our application and consequently a table in a relational DBMS; but we will need another table for holding the
m:n relationship between Post and Tag.
Before we start coding you must ensure that you have installed PHP 8.1 or greater on your computer; also you must have installed / enabled some PHP extensions — I recommend mysql, intl, mbstring, curl and xml, although I’m not sure if all of them will be needed for this Laravel app. You also need to have installed NodeJS (version 14 or greater), NPM, Composer (one of the most commons PHP dependency manager) and MySQL Server. If you don’t have it, please check on the internet how to install them 😉
First, open the terminal, change directory to you workspace directory (
cd …), and type the following commands:
composer create-project laravel/laravel simple-blog --prefer-dist
Install starter kit
After downloading all dependencies, you should open your preferred editor on the new
simple-blog directory — I recommend Visual Code with Intelephense extension.
Now, let’s go into the directory and install the Laravel Starter Kit Breeze:
composer require laravel/breeze --dev
php artisan breeze:install
Setting up the database
Next we need to prepare our database for storing the application data. In this step you need to access the DBMS Server (that must be running), create a new database and optionally a new user. You can do that through phpMyAdmin, Mysql Workbench or any other interface you prefer. Here I will show how to do to it directly from the terminal:
mysql -u root -pmysql> create database simple_blog;
mysql> create user 'laravel_user' identified by 'laravel_pw';
mysql> grant all privileges on simple_blog.* to 'laravel_user';
command+con Mac) to exit the MySQL CLI and let’s go to set up these fresh new created database and user on our environment file. To do this, open the
.env file and locate the line started by
DB_DATABASE; this will hold the name of the database (
DB_PASSWORD will keep username and password that application will use to access the DBMS:
In order to check if everything is ok, type
php artisan db; if it access the MySQL CLI then you should follow. If you experience some error, check if the DBMS server is running and you enabled / installed the PHP mysql extension (these are the more common mistakes in this step).
Migrating tables and testing
Now lets create database tables and run the application server in order to test it:
php artisan migrate
php artisan serve
Open your browser on
localhost:8000 and you should see the welcome page for the application:
Log in links should have been fully working, so you can test it.
Creating other entities and migrations
If you open the
app/Models directory you’ll see that Laravel came out with the User model and migration. Now we must create the other models with the migrations:
php artisan make:model Post -mfsr
php artisan make:model Comment -mfsr
php artisan make:model Tag -mfsr
php artisan make:migration create_post_tag_table
Note that I’m using the
-mfsr options here in order to create the Model alongside with its migration (for create database table), factory and seeder (for generating fake data for the sake of tests) and a resource Controller. All this will be covered later in this tutorial.
Now let’s add some columns to our models:
Migrating new tables
With the columns filled, run the following command to run the migrations:
php artisan migrate
Remember that once you run a migration or push a new migration in a Continuous Integration workflow you should not change that migration anymore. If you need to change anything in the database modelling, create another migration to do that.
Filling the models classes
Now we can add the columns into the
$fillable attribute of the related model classes (inside
Now it’s time to add some relationships. As we are using Eloquent ORM on Laravel, relationships are usually not exported to database, so this must be done in application level. Laravel and Eloquent provides us a powerful tool for creating relationships inside models:
Testing models and relationships
Laravel provides us a great CLI command based on the Psy Shell project, accessible through the command
php artisan tinker . The shell is rooted on our project directory and has some shortcuts to our Model classes:
Using this you can play with all classes and relationships, creating new records and accessing them.
Now, let’s improve our testing data by creating factories and seeders for our system, so we can start a fresh new database with fake generated data. This will greatly help us when developing our front-end.
First, we will implement our factories, that will be used to generate model instances with random fake generated data. Laravel bring us the
UserFactory class (
database/factories) already filled; if you want, you can change the hashed password to something more accessible:
Similarly, we will create now the other classes factories:
Checking seeders, models and relationships
With this, you can try the following commands on the
User::factory()->make() // creates an instance
User::factory()->make()->save() // creates an instance and store it
User::factory()->create() // same above, but shorter
User::factory(5)->create() // creates and saves 5 users
Now that we are able to random generate records for our database, we can create the seeders for auto seed database with fake data, so we can start our application with some data in order to test it.
To achieve this, we’ll implement Seeders classes inside
We will also create a
PostTagSeeder so we can some random relationships between posts and tags. Although you can create it directly into the directory, it is best to create through the artisan:
php artisan make:seeder PostTagSeeder
You must have in mind that by default only the
DatabaseSeeder class is called when running the artisan command, so we need to make it call the other seeders:
After this, you can run the following command on your terminal:
php artisan migrate:fresh --seed
This will recreate your database and seed it according with the
DatabaseSeeder class (you can check it with
This concludes this tutorial, that is fully focused on the back-end of a Laravel application. The next step is to create the front-end, using Blade templates, Vue, React or other supported front-end framework, but this is for another tutorial.