You can install Laravel on Ubuntu<\/a>, CentOS, and other popular Linux distributions. Before doing so, however, you must configure several software components, including PHP runtime, Composer, and Apache. If you want a simpler installation process, purchase a Hostinger Laravel VPS hosting plan<\/a>. Then, complete the onboarding process, and have Laravel set up automatically in 15 minutes or so.<\/p> Additionally, you must set up an integrated development environment on your local computer to write your application’s code. To deploy a Laravel app<\/a> to your VPS, you need Git <\/strong>or automation software like Jenkins<\/strong>.<\/p> \n\n\n Important!<\/strong> Depending on your Laravel version, several concepts might might be different. For this tutorial, we will focus on Laravel 11.X<\/strong>.<\/p><\/div>\n\n\n\n<\/p> One of the most important concepts in Laravel is its MVC architecture. Simply put, this model enables developers to divide an application into three components for easier code management, prioritization, and concern isolation.<\/p> Model components<\/strong><\/p> The model component represents your application’s business logic and storage. It is responsible for database operations, including writing and fetching specific information from the back end based on the user’s request.<\/p> Laravel relies on Eloquent ORM to handle model-related operations, which uses the object-oriented approach. This makes manipulating data much faster and more flexible than using SQL.<\/p> View components<\/strong><\/p> The view layer defines the area of your application that users can see on their device’s screen and interact with. It covers elements like drop-down menus, text boxes, and form fields.<\/p> To simplify the view component development process, Laravel provides a Blade engine that lets you incorporate PHP into HTML templates. This feature enables you to create reusable code and display data from the back-end more easily.<\/p> Controller components<\/strong><\/p> The controller connects the previous two components in your Laravel application. It fetches the data request from the model layer and presents the processed information on the front end to the view component.<\/p> You can use various methods to tell the controller to interact with the data differently. For example, index<\/strong> retrieves records from the database while store<\/strong> inserts new resources.<\/p> When a user accesses your application, they send a request which a controller will handle. Route directs the incoming request through a specific URL to reach the appropriate controller and return data to the view layer.<\/p> You can create multiple Laravel routes based on the request’s HTTP methods, like GET, POST, PUT, DELETE, and PATCH. By default, they are located in web.php<\/strong> inside the routes<\/strong> folder of your Laravel project directory.<\/p> To create a route, call the Route <\/strong>helper function or facade<\/a> by adding the following line at the top of your web.php<\/strong> file:<\/p> Then, specify your route. For example, the following will handle users who send the GET<\/strong> HTTP request to the domain.tld\/welcome<\/strong> URL:<\/p> If you want to set up a route for a specific controller, you can also call its facade and add the route like the following:<\/p> In the example, we route requests with the GE<\/strong>T method from domain.tld\/home<\/strong> to the HomeController<\/strong> controller, which will handle it using the INDEX <\/strong>method. The ::class<\/strong> syntax allows you to use the controller without specifying its full facade path.<\/p> Laravel can process requests through middleware before passing them to controllers for additional processing, like logging or authentication. Consider this example:<\/p> Remember, you must create the middleware through PHP Artisan. We will explain how to do so in the later section about advanced Laravel techniques.<\/p> Controllers group requests with the same logic into a class. It makes the processing more efficient since you can do so in bulk using a single handler.<\/p> For example, you create a HomeController to process all requests coming from the \/home URL. By default, controllers are located in app\/Http\/Controllers<\/strong>. To set one up, run the following PHP artisan command:<\/p> Then, define the methods of handling requests inside the new controller file. For example, the following handle GET<\/strong> requests sent through the product\/id <\/strong>route:<\/p> To handle common create, read, update, and delete (CRUD) operations, you can set up a resource controller with a set of predetermined methods. Here’s the command:<\/p> The Blade templating engine<\/a> enables seamless PHP integration into HTML using a simpler syntax. It helps you create view components for your application more easily.<\/p> To build a view using Blade, create a file with the .blade.php<\/strong> extension inside your Laravel project’s resources\/views<\/strong> directory.<\/p> The code structure is the same as that of HTML but with additional syntaxes for PHP. For example, you can insert a variable like so:<\/p> In the above example, Laravel passes the value of <\/strong>the $title<\/strong> PHP variable to the view component, displaying it to users.<\/p> You can also add directives that manipulate your HTML elements using PHP functions. For instance, @if<\/strong> lets you display specific content if a condition is met, like the following:<\/p> To improve code reusability, Blade offers a template inheritance feature that lets you create a master layout and add smaller components called child views<\/strong> separately. You can do so using the @extends<\/strong>, @section<\/strong>, and @yield<\/strong> directives.<\/p> For example, we have a master template with the following code:<\/p> The @yield <\/strong>directive is a placeholder for content from a child view marked with @section<\/strong>. For instance, the following will insert Your Awesome Website <\/strong>into the title tag:<\/p> Lastly, add the @extends<\/strong> directive to the child view to tell the master template which file it should use to extend its content.<\/p> Eloquent ORM<\/a> enables your application to interact with the database tables more efficiently using shorter code than traditional SQL. Instead of directly manipulating data directly using tables, Laravel assigns a model to simplify CRUD operations.<\/p> You can create a new Eloquent model anywhere within your Laravel project’s app<\/strong> folder since the Composer.json<\/strong> file will automatically locate it. If you don’t specify a directory, the web application framework will use the default app\/Models<\/strong> directory. To create a new model, run the PHP Artisan command like this. Replace Name<\/strong> with your desired model name:<\/p> By default, Laravel assumes the corresponding table is the plural form of your model name. For instance, the following command will assign the Post<\/strong> model to the posts <\/strong>database column.<\/p> Now, let’s write Eloquent code inside your controller for CRUD operation. For instance, the following will retrieve accounts from the User<\/strong> model with the Active<\/strong> status:<\/p> Normally, we need the following for the same operation using SQL:<\/p> Laravel also lets you establish relationships between records in different Eloquent models for more efficient data organization. Here are the supported connections:<\/p> Laravel also has a migration feature that helps maintain consistency between databases in different environments or versions. It also lets you create columns in a new model with a single execution.<\/p> To create a migration file for a table, run the following command:<\/p> You can also create a migration file while setting up a model by adding the -m or –migration option like so:<\/p> Laravel will create a migration file within the database\/migrations directory. Inside it, specify two commands – up()<\/strong> and down()<\/strong>.The up() <\/strong>function defines the changes to make when you run the PHP Artisan migrate<\/strong> command, while down()<\/strong> specifies the method to revert the modifications. Here’s an example of the full code:<\/p> If you execute the following command, the functions within up() <\/strong>will run, creating the id<\/strong>, string<\/strong>, text<\/strong>, and timestamp<\/strong>s columns inside the posts <\/strong>table.<\/p> To revert the changes, run the following command. It will execute the down()<\/strong> function, removing the newly created posts table:<\/p> Commonly, developers and system administrators migrate the database if they need to modify the schemas, whether it is during testing, deployment, or setting up a new environment.<\/p> Implementing a proper authentication and authorization mechanism is crucial for your web application’s integrity and safety. Since building this system manually is complicated, Laravel provides a toolkit that lets you develop it more easily.<\/p> Laravel authentication<\/strong><\/p> Laravel uses guards <\/strong>to define the user authentication method and providers to retrieve the account information from a persistent storage, like a database. The authentication logic is located inside the config\/auth.php<\/strong> file. Here’s what it might look like:<\/p> In the example above, we use a guard to authenticate requests to our web application using a cookie-based session method. It utilizes a provider called users<\/strong>, which uses the Eloquent ORM mechanism to retrieve the account’s records from the user<\/strong> model.<\/p> Laravel also offers Jetstream<\/strong> and Breeze <\/strong>starter kits<\/a>, which provide a ready-to-use authentication system. We recommend installing them to get a basic understanding of the code implementation, which can help you set up custom logic later on.<\/p> Laravel authorization<\/strong><\/p> Laravel authorization uses two components – gates<\/strong> and policies<\/strong>. Gates check if a user has permission to take a specific action. Meanwhile, policies define an authorization logic for collective actions within the same model.<\/p> Gates are suitable for one-off actions, while policies are useful for authorizing more complicated processes. Depending on your Laravel applications, you might use one or both.<\/p> Register a gate using the boot <\/strong>method inside App\/Providers\/AppServiceProvider<\/strong>. For example, the following compares the user ID of an account who wants to edit a post and its author:<\/p> Then, you can call the gate to your controllers or Blade templates and specify the response based on the authorization result. For example, you can set your application to return a message when encountering validation errors.Meanwhile, create a policy using the PHP Artisan command. For example, the following will create the PostPolicy<\/strong> policy:<\/p> Then, register it using the boot<\/strong> method inside AuthServiceProvider.php<\/strong>. In this example, we assign the policy to the Post<\/strong> model:<\/p> Now you can write the authorization logic inside your new policy’s file, which in our case is PostPolicy.php<\/strong>. To apply it, call the function to your controller and specify the response.<\/p> Laravel’s ability to efficiently communicate and authorize databases enables you to create forms easily.<\/p> For example, let’s create a form that collects usernames and email addresses. To start, create a view component using Blade. Here’s what the code might look like:<\/p> Then, add the routes into web.php<\/strong>, specifying which controller will handle the form submissions. In our case, we need two for the GET<\/strong> and POST<\/strong> methods:<\/p> Now, let’s create the controller using the following command:<\/p> Add the following code to the FormController.php<\/strong> file to set up your controller, which will validate the user input and compare the data against database entries:<\/p> As specified in the Blade file, if the input username and email exist in the database, your front-end view will return a success message. Otherwise, it will output an error.<\/p> If you want more thorough checks, you can enforce an authorization system using gates and policies.<\/p> Here are several advanced Laravel techniques that can improve your web application development efficiency.<\/p> PHP Artisan<\/a> is a command-line application that lets you interact with your application framework, automate complex tasks, and manage resources for a more efficient development process. It comes pre-configured with your Laravel installation.<\/p> To list the available PHP Artisan commands, run the following:<\/p> Meanwhile, use the help<\/strong> argument to check a command’s manual, including the acceptable options. For example, run the following to check the migrate <\/strong>utility:<\/p> One of the most commonly used PHP Artisan commands is make<\/strong>, which lets you create various items, including another command, controller, and middleware. Here’s the syntax:<\/p> Another important command is serve<\/strong>, which lets you deploy your Laravel application:<\/p> You can also manage caches with the PHP artisan command. For example, use the following to wipe your Laravel routing cache:<\/p> \n\n\n New to Laravel Artisan commands? Check our article on Laravel commands<\/a>.<\/p>\n <\/div>\n\n\n\n<\/p> Laravel middleware<\/a> is intermediary software between your application and the client. It intercepts user requests before they reach your server and is typically used for filtering traffic and logging. Laravel provides pre-built middleware that you can directly use in your application code base. By default, they are located in your project’s app\/Http\/Middleware<\/strong>. To create a new one, run the following PHP Artisan command:<\/p> Then, write your PHP script to define the handling logic. Once finished, you can apply middleware to a specific route or globally, intercepting all HTTP requests and methods.<\/p> To apply your middleware globally, add it to the $middleware <\/strong>property inside app\/Http\/Kernel.php<\/strong>. When working with multiple middleware services, you can group them to simplify routing. To do so, list them under the $middlewareGroups<\/strong> property inside the Kernel.php<\/strong> file. Consider this example:<\/p> In the snippet, the custom <\/strong>group contains two middleware components. You can call them simultaneously into a route using the group name like so:<\/p> Laravel ships with an error handling mechanism that helps you handle issues more flexibly. To set up a custom exception handler, add the logic inside the App\\Exceptions\\Handler<\/strong> class.<\/p> You can use different methods to customize how Laravel will display an exception. For example, the following code uses render()<\/strong> to display specific errors as HTTP responses:<\/p> Another method is report()<\/strong>, which modifies how Laravel logs errors in the storage\/logs <\/strong>directory. You can also create a custom exception class by extending the base Exception<\/strong> class, like in this code:<\/p> In addition to enabling you to catch exceptions more efficiently, Laravel provides tools for debugging errors. For example, the dd() <\/strong>and dump() <\/strong>lets you check values from a variable, allowing you to see if the output is correct:<\/p> Alternatively, use a third-party solution, like Laravel Debugbar<\/strong>, which provides a graphical user interface in your web browser that displays useful information about your application. For example, you can check its routes, queries, and requests.<\/p> You can install this tool via Composer<\/strong>. If you want to learn more about it, check the Laravel Debugbar GitHub repository<\/a>.<\/p>![\"\"](\"https:\/\/imagedelivery.net\/LqiWLm-3MGbYHtFuUbcBtA\/wp-content\/uploads\/sites\/2\/2023\/02\/VPS-hosting-banner.png\/public\")
<\/a><\/figure>Understanding the MVC architecture<\/h2>
Creating routes and URLs<\/h2>
use Illuminate\\Support\\Facades\\Route;<\/pre>
Route::get('\/welcome', function () {\n \/\/Write your controller logic here;\n});<\/pre>use App\\Http\\Controllers\\HomeController;\n\nRoute::get('\/home', [HomeController::class, 'index']);<\/pre>Route::get('\/welcome', function () {\n return view('welcome');\n})->middleware('log.request');<\/pre>Working with controllers<\/h2>
php artisan make:controller ControllerName<\/pre>
namespace App\\Http\\Controllers;\n\nuse App\\Models\\Product;\nuse Illuminate\\Http\\Request;\n\nclass ProductController extends Controller\n{\n \/\/ GET \/product\/{id}\n public function show($id)\n {\n $product = Product::find($id);\n \n if (!$product) {\n abort(404); \/\/ Return a 404 error if the product is not found\n }\n\n return view('products.show', compact('product')); \/\/ Return a view with the product data\n }\n}<\/pre>php artisan make:controller ControllerName --controller<\/pre>
Creating views with Blade templating engine<\/h2>
<h1>{{ $title }}<\/h1><\/pre>@if($user->'Username')\n <h1>Glad to see you, Username!<\/h1>\n@endif<\/pre>
<title>@yield('websitetitle')<\/title><\/pre>@section('websitetitle', 'Your Awesome Website') <\/pre>Managing database with Eloquent ORM<\/h2>
php artisan make:model Name<\/pre>
php artisan make:model Post<\/pre>
$activeUsers = User::where('status', 'active')->get();<\/pre>$activeUsers = DB::select('SELECT * FROM users WHERE status = ?', ['active']);<\/pre>\n
php artisan make:migration create_example_table<\/pre>
php artisan make:model Post --migration<\/pre>
<?php\n\nuse Illuminate\\Database\\Migrations\\Migration;\nuse Illuminate\\Database\\Schema\\Blueprint;\nuse Illuminate\\Support\\Facades\\Schema;\n\nclass CreatePostsTable extends Migration\n{\n \/**\n * Run the migrations.\n *\n * @return void\n *\/\n public function up()\n {\n Schema::create('posts', function (Blueprint $table) {\n $table->id(); \/\/ Auto-incrementing primary key\n $table->string('title'); \/\/ Column for post title\n $table->text('body'); \/\/ Column for post content\n $table->timestamps(); \/\/ Created and updated timestamps\n });\n }\n\n \/**\n * Reverse the migrations.\n *\n * @return void\n *\/\n public function down()\n {\n Schema::dropIfExists('posts');\n }\n}<\/pre>php artisan migrate<\/pre>
php artisan migrate:rollback<\/pre>
Implementing authentication and authorization<\/h2>
'guards' => [\n 'web' => [\n 'driver' => 'session',\n 'provider' => 'users',\n ],\n'providers' => [\n 'users' => [\n 'driver' => 'eloquent',\n 'model' => App\\Models\\User::class,\n ],\n],<\/pre>
use App\\Models\\Post;\nuse App\\Models\\User;\nuse Illuminate\\Support\\Facades\\Gate;\n\npublic function boot(): void\n{\n Gate::define('update-post', function (User $user, Post $post) {\n return $user->id === $post->user_id;\n });\n}<\/pre>php artisan make:policy PostPolicy<\/pre>
namespace App\\Providers;\n\nuse App\\Models\\Post;\nuse App\\Policies\\PostPolicy;\nuse Illuminate\\Foundation\\Support\\Providers\\AuthServiceProvider as ServiceProvider;\nuse Illuminate\\Support\\Facades\\Gate;\n\nclass AuthServiceProvider extends ServiceProvider\n{\n protected $policies = [\n Post::class => PostPolicy::class, \/\/ Registering the policy for the Post model\n ];\n\n public function boot(): void\n {\n \/\/ Specify gate here\n }\n}<\/pre>Handling forms and validation<\/h2>
<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n <meta charset=\"UTF-8\">\n <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n <title>Simple Form<\/title>\n<\/head>\n<body>\n <h1>Submit Your Info<\/h1>\n\n @if (session('success'))\n <div style=\"color: green;\">{{ session('success') }}<\/div>\n @endif\n\n @if ($errors->any())\n <div style=\"color: red;\">\n <ul>\n @foreach ($errors->all() as $error)\n <li>{{ $error }}<\/li>\n @endforeach\n <\/ul>\n <\/div>\n @endif\n\n <form action=\"{{ route('form.submit') }}\" method=\"POST\">\n @csrf\n <label for=\"name\">Name:<\/label>\n <input type=\"text\" id=\"name\" name=\"name\" required>\n\n <label for=\"email\">Email:<\/label>\n <input type=\"email\" id=\"email\" name=\"email\" required>\n <button type=\"submit\">Submit<\/button>\n <\/form>\n<\/body>\n<\/html><\/pre>use App\\Http\\Controllers\\FormController;\n\nRoute::get('\/form', [FormController::class, 'show'])->name('form.show');\nRoute::post('\/form-submit', [FormController::class, 'submit'])->name('form.submit');<\/pre>php artisan make:controller FormController<\/pre>
namespace App\\Http\\Controllers;\n\nuse Illuminate\\Http\\Request;\nuse App\\Models\\User; \/\/ Make sure to import your User model\n\nclass FormController extends Controller\n{\n public function show()\n {\n return view('simple-form');\n }\n\n public function submit(Request $request)\n {\n \/\/ Validate input\n $request->validate([\n 'name' => 'required|string|max:255',\n 'email' => 'required|email|max:255|exists:users,email', \/\/ Check if email exists\n ]);\n\n return redirect()->route('form.show')->with('success', 'Form submitted successfully!');\n }\n}<\/pre>Advanced Laravel techniques<\/h2>
Using Laravel PHP Artisan command line<\/h3>
php artisan list<\/pre>
php artisan help migrate<\/pre>
php artisan make:item [option]<\/pre>
php artisan serve<\/pre>
php artisan route:clear<\/pre>
Suggested Reading<\/h4>\n
Middleware<\/h3>
php artisan make:middleware-name<\/pre>
protected $middlewareGroups = [\n 'custom' => [\n \\App\\Http\\Middleware\\EncryptCookies::class,\n \\Illuminate\\Cookie\\Middleware\\AddQueuedCookiesToResponse::class,\n]<\/pre>
Route::get('\/example', function () {\n return 'This route uses the custom middleware group.';\n})->middleware('custom');<\/pre>Error handling and debugging<\/h3>
public function render($request, Throwable $exception)\n{\n if ($exception instanceof CustomException) {\n return response()->view('errors.custom', [], 500);\n }\n\n return parent::render($request, $exception);\n}<\/pre>namespace App\\Exceptions;\n\nuse Exception;\n\nclass CustomException extends Exception\n{\n \/\/ Custom logic or properties\n}<\/pre>dd($variable)<\/pre>
![\"Laravel](\"https:\/\/imagedelivery.net\/LqiWLm-3MGbYHtFuUbcBtA\/wp-content\/uploads\/sites\/2\/2024\/09\/laravel-debugbar-user-interface.png\/public\")
<\/figure><\/div>Building RESTful APIs with Laravel<\/h3>