How to Perform CRUD (Create, Read, Update, Delete) Operations in Laravel

Struggling with data management in your web application? Are you looking for an efficient way to perform CRUD operations in Laravel? You’re not alone. Many developers face challenges in effectively implementing these fundamental operations.

CRUD operations form the backbone of most web applications, allowing us to interact with our data meaningfully. However, without the right approach, this can become a complex and daunting task, leading to inefficient code and potential data issues.

This is where this article comes in handy. I’ll show you how to perform CRUD operations in Laravel in easy steps. So, whether you’re a beginner or an experienced developer, this article has something for you. Let’s get started!

What Are CRUD Operations?

CRUD operations, standing for Create, Read, Update, and Delete, are basic tasks for manipulating data in web applications. They allow data to be added, retrieved, modified, and removed from a database, forming the core of data-driven applications.

These operations are universal and not tied to a specific programming language or database system. They’re essential for any system needing data persistence, whether it’s a relational database like MySQL or a database like MariaDB.

How Does CRUD Work?

CRUD operations interact with a database via a database management system (DBMS), which provides an interface for these tasks. When a user action occurs in the application, it’s converted into a DBMS-compatible command.

In relational databases, these commands are usually SQL statements. ‘Create’ becomes an ‘INSERT’ statement, ‘Read’ a ‘SELECT’, ‘Update’ an ‘UPDATE’, and ‘Delete’ a ‘DELETE’. The DBMS executes these and returns the results to the application, displaying the data to the user.

Why Use Crud Operations?

CRUD operations are essential for managing data in applications, providing a structured approach that keeps data organized and consistent. Without them, data management would be disorderly and prone to errors.

These operations also simplify application development and maintenance. They standardize how applications handle data, producing more maintainable code. They define what an application can do with its data, making its functionality clearer.

CRUD Operations in Laravel

Laravel offers strong support for CRUD operations through its Eloquent ORM. Eloquent makes database work easier with an object-oriented syntax for CRUD operations, letting you interact with your database like you’re working with PHP objects.

For instance, to add a new record to a database, you create a new model instance (a PHP class representing a database table), set its properties, and use the save method. Reading data involves methods like find or where. Updating and deleting records are also simple.

System Requirements for CRUD

To perform CRUD operations in Laravel, you need the following system requirements:

• PHP: Version 8.0 or higher.
• Laravel: Version 10.x.
• Database: Supported by Laravel, with connection details in .env file.
• Web Server: Like Apache or Nginx.

Ready to try your first CRUD operation in Laravel?

From PHP 8.0 or higher, Laravel installation, and database support to web servers like Apache or Nginx, Cloudways has got you covered.

Try Now!

Create a Laravel Project

In this article, I’ll use Cloudways to create a Laravel project for CRUD operations. This allows me to focus on development while Cloudways handles server management.

Step 1: Create the App

Click on View all Servers after logging in to your Cloudways account and choose your target server.

Step 2: Set up the Database

Laravel makes it easy to configure the database connection.

Open the .env file and provide the necessary information for your chosen database system, such as host, database name, username, and password.

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_database_username
DB_PASSWORD=your_database_password

Save the file after making these changes.

Step 3: Create the Migration

In Laravel, migrations are used to define the structure of your database tables. To create a migration for your CRUD operation, run the following command:

php artisan make:migration create_table_name

💡 Note: Replace table_name with a meaningful name for your database table.

Edit the generated migration file in the database/migrations directory to define the columns for your table. For example:

public function up()
{
    Schema::create('items', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->text('description');
        $table->timestamps();
    });
}

Run the migration to create the table in your database:

php artisan migrate

Step 4: Create the Model

Create a model for the table you just created by running the following command:

php artisan make:model Item

This command generates a model file in the app directory. You can use this model to interact with the database table.

Step 5: Create the Route

Laravel uses routes to map URLs to specific controller actions. Define your routes in the routes/web.php file. For a CRUD operation, you typically need routes for creating, reading, updating, and deleting records.

Route::resource('items', 'ItemController');

This single line of code will generate all the necessary routes for CRUD operations.

Step 6: Create the Controller

Create a controller for your CRUD operations by running the following command:

php artisan make:controller ItemController

In your ItemController.php file, you can define the methods for handling CRUD operations:

public function index()
{
    // Read - Display a list of items
}
public function create()
{
    // Create - Show the form to create a new item
}
public function store(Request $request)
{
    // Create - Save a new item to the database
}
public function show($id)
{
    // Read - Display a single item
}
public function edit($id)
{
    // Update - Show the form to edit an item
}
public function update(Request $request, $id)
{
    // Update - Save the edited item to the database
}
public function destroy($id)
{
    // Delete - Remove an item from the database
}

Step 7: Create the View

You’ll need views to interact with the user.

Laravel makes it easy to create views using Blade Templates. You can create views for listing, creating, editing, and displaying items.

Step 8: Implement the CRUD Operations

In your controller methods, implement the CRUD operations using the Eloquent ORM and views. Here’s a high-level overview of what each method should do:

• Index: Retrieve a list of items and display them.
• Create: Show a form to create a new item.
• Store: Save a new item to the database.
• Show: Display a single item.
• Edit: Show a form to edit an existing item.
• Update: Update the item in the database.
• Destroy: Delete the item from the database.

Test Your CRUD Operations

Before deploying your application, thoroughly test your CRUD operations to ensure they work as expected. Make sure to handle any validation, error handling, and edge cases.

Prepare your application for deployment as follows.

1. Make the deployment smooth and straightforward by declaring the public folder. Add a .htaccess file to the root of the application folder with the following code:

<IfModule mod_rewrite.c >
  RewriteEngine On
  RewriteRule ^(.*)$ public/$1 [L]
</IfModule >

2. Force your app to use HTTPS by adding the following code above your routes inside the routes/web.php file:

use Illuminate\Support\Facades\URL;
URL::forceScheme('https');

3. Push your code to a GitHub repository.

Deploy Code Using GitHub

Step 1: Go to Application Management

Log in to the Cloudways Platform, click on Applications in the top menu bar, and select your target application from the list.

Step 2: Generate and Download SSH Keys

We’ll use these keys to allow access from the Cloudways server to the Git repository.

• Click on the Deployment via Git from the Application Management section.
• Then click on the Generate SSH Keys button to generate the keys.

Step 3: Upload the SSH Public Key to Your Git Repository

We’ll use a GitHub account to exemplify the next two steps. If you are using another Git service, you must find the equivalent way of completing them.

For GitHub

1. Log in to GitHub and select your desired repository. Once done, go to Settings.
2. Here, you will find the Deploy Keys option.
3. Click on the Add Deploy Key button to add the SSH Key we downloaded in step 3. Simply open the file we downloaded (git_ssh_key.txt), copy the content, and paste it into the Key field on GitHub. You can give a name to this key too in the title field (e.g. Demo).
4. Click on the Add Key button to save the SSH Key (for details, please visit GitHub Docs).

Step 4: Copy the Repository SSH Address

Copy the repository address as shown in the image below. Ensure to copy the SSH address, as other formats (like HTTPS) are not supported.

Step 5: Deploy Code from Your Repository

1. Back on the Cloudways Platform, paste the SSH address you got in Step 4 into the Git Remote Address field and click on Authenticate. This will ensure that there are no blockers in the communication between Cloudways and Git service (which is Github in our example).
2. Then choose the branch of your repository (master will be selected as default) you want to deploy from.
3. Next, type the deployment path (i.e. the folder in your server where the code will be deployed). Make sure to end it with a /. If you leave this field empty, the code will be deployed to public_html/.
4. Finally, click on the Start Deployment button to deploy your code to the selected path.

Step 7: Configure Database

Open the .env file in your project root directory and configure your MariaDB database connection by updating the following lines with your database information:

DB_CONNECTION=mysql
DB_HOST=External hostname
DB_PORT=External port
DB_DATABASE=Database name
DB_USERNAME=Username
DB_PASSWORD=Password

Step 7: Test Your CRUD Operations

Now create the database tables, connect the database to your local app by updating your .env file with the same credentials you entered in your app and run the following command:

php artisan migrate

This command executes all migration files, setting up the defined tables in your application. You can now test your application using the URL provided after the initial deployment.

CRUD Optimization Tips

Optimizing the performance of a Laravel CRUD application is crucial for ensuring that your web application runs smoothly and efficiently.

Here are some tips to help you improve the performance of your Laravel CRUD application:

1. Caching: Use Laravel’s built-in caching system to store frequently accessed data. You can use tools like Redis or Memcached for caching. Cache query results, views, and configurations to reduce database and file system access.
2. Eager Loading: When retrieving data with relationships (e.g., eager loading), use the method to load related data upfront, reducing the number of database queries.

   $posts = Post::with('comments')->get();

3. Database Indexing: Properly index your database tables to speed up data retrieval. Use the Schema facade to add indexes to your migration files.

   Schema::table('posts', function ($table) {
       $table->index('column_name');
   });

4. Database Transactions: Wrap database operations in transactions to ensure data consistency and improve performance by minimizing database write operations.

   DB::transaction(function () {
       // Your CRUD operations here
   });

5. Database Optimization: Optimize your database queries by using the Query Builder efficiently. Avoid using the select * statement and use pagination for large datasets.
6. Use Queues: Offload time-consuming tasks to background queues, such as sending emails or processing uploaded files. Laravel’s built-in queue system can help you with this.

Empower Your Laravel Apps with Cloudways: Where Speed Meets Simplicity

Experience the power, speed, and flexibility of Cloudways for your Laravel applications. Elevate your web development with optimized Laravel hosting solutions designed for efficiency and scalability.

TRY NOW

Summary

Laravel CRUD operations is an essential skill for any developer looking to build robust and scalable web applications. This step-by-step guide has provided you with a comprehensive overview of:

• How to create, read, update, and delete data in your Laravel application.
• Validation and security considerations to ensure the integrity of your application’s data and protect against potential threats
• How to efficiently work with Laravel CRUD operations.

CRUD operations are a significant step toward becoming a proficient Laravel developer. As you continue to explore and expand your knowledge, you’ll find that Laravel offers a vast ecosystem of features and tools that can help you build powerful and dynamic web applications.