Forem: Ian Kumu

How to Build a Rest API with Laravel: A Beginners Guide

Ian Kumu — Sat, 19 Nov 2022 13:01:36 +0000

With the rise of mobile and javascript web frameworks such as React and Vue, Restful APIs have seen their popularity increase. This is because you can maintain one backend serving multiple front-end clients.

Laravel provides a good environment and ecosystem for building your Rest API.

First-party packages such as Laravel Passport and Laravel Sanctum provide API authentication implementation making authentication easy.

Laravel Breeze provides starter templates that can help with reset password features.

Socialite and Scout provide Social Login implementations and Full-text search functionalities.

The laravel ecosystem provides solutions to almost all problems you can encounter in your development journey thus providing maximum productivity to a developer.

This tutorial will explore how to create a Laravel Rest API with authentication using Laravel Sanctum.

What is a Restful API?

REST stands for REpresentational State Transfer and it is a pattern used for communication between applications through HTTP. The protocol is stateless meaning no session is stored between the applications. Each request is therefore processed as if it is a new request even though it is repeated.

A benefit of REST APIs is that they can easily be cached. It is easy to cache a response from the Rest API in a service such as Redis or Memcached and thus easy to scale.

For an API to be considered Restful, it has to have the following

Must be accessible over a URL or endpoint
Must use any of the REST Methods

The common REST Methods are:

GET -Fetch resources from an API

POST -Create a resource in the API

PUT/PATCH -Update a resource in the API

DELETE – Delete a resource from an API

Can have HTTP headers
Must return a valid response code in each response.

How to build a REST API with Laravel

Create a new Application

The first step is to create a new Laravel application.

laravel new rest

Set up a Model and Migration

The next step is to create a Model and its corresponding migration file. This acts as a blueprint for our database table. In this tutorial, I will use Products as my resource.

php artisan make:model Products -m

The -m flag will instruct Laravel to create the corresponding migration file of the Products Model.

//App/Models/Products
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Products extends Model
{

    use HasFactory;

}

The migration file generated will resemble the one below.

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('products');
    }
};

We can start by updating the migration file by adding more columns to our database. I will add the following columns: product name , product price and product description

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('products', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->double('price');
            $table->longText('description');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('products');
    }
};

We can then update the Products model by registering the mass-assignable variables. This helps prevent SQL injection by instructing laravel only to accept data containing the specified keys/variables.

//App/Models/Products
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Products extends Model
{
    use HasFactory;

    protected $fillable = [
        'name', 'price', 'description'
    ];
}

The last step is to set up the database credentials in the .env file and create the database

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel-rest
DB_USERNAME=root
DB_PASSWORD=password

The final step is to migrate the database.

php artisan migrate

Create a Database Seeder and Factory

When developing, I prefer to use fake data to ensure that I develop as fast as possible. Laravel provides a handy Factory facade that can allow us to use Faker to generate dummy data.

We can run this command to create a Factory

php artisan make:factory ProductsFactory

This will create a file in the databases/factories folder

We can update the file as follows

//database/factories/ProductsFactory
<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Products>
 */
class ProductsFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    public function definition()
    {
        return [
            'name' => $this->faker->word,
            'price' => $this->faker->numberBetween(1, 99),
            'description' => $this->faker->sentence()
        ];
    }
}

Now that our factory is ready, we can call it in the DatabaseSeeder file to seed our database.

//database/seeders/DatabaseSeeder
<?php

namespace Database\Seeders;

// use Illuminate\Database\Console\Seeds\WithoutModelEvents;
use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        \App\Models\Products::factory(10)->create();
    }
}

We can now seed the database

php artisan db:seed

Create a Controller

Let’s now create a Controller which will contain all the Business logic for the API.

php artisan make:controller ProductsController -r

The -r flag will generate a Controller that is resourceful. This means it will create a controller with all the required methods for a Restful API.

The main methods we will use are index , show , store , update and destroy. We can delete the create and edit methods as we will not need them. We can update the Products Controller as shown below

//App/Http/Controllers/ProductsController

<?php

namespace App\Http\Controllers;

use App\Http\Resources\ProductResource;
use App\Models\Products;
use Illuminate\Http\Request;

class ProductsController extends Controller
{
    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        //
    }

    /**
     * Display the specified resource.
     *
     * @param Products $product
     * @return \Illuminate\Http\Response
     */
    public function show(Products $product)
    {
        //
    }

    /**
     * Update the specified resource in storage.
     *
     * @param \Illuminate\Http\Request $request
     * @param Products $product
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, Products $product)
    {
        //
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param Products $product
     * @return \Illuminate\Http\Response
     */
    public function destroy(Products $product)
    {
        //
    }
}

These methods can be mapped to the default HTTP verbs (get, post, patch/put and delete).

Index(Get all Products)

We can use this method to return all products present in the database

use App\Models\Products;
public function index()
{
   return Products::all();
}

We can further customise it by paginating it or caching the response from the database.

Show(Get a Single Product)

We can use this method to return a single product present in the database

We can pass the product id as a parameter and we can then fetch it from the database

Note: I am using API Resources which I will discuss later in the article.

use App\Http\Resources\ProductResource;
use App\Models\Products;

public function show(Products $product)
{
   return new ProductResource($product);
}

Store(Create a Product)

We can create a new product record in the database using this method. A post method can be made to this method through an endpoint to create the record

use App\Http\Resources\ProductResource;
use App\Models\Products;

public function store(Request $request)
{
        $product_name = $request->input('name');
        $product_price = $request->input('price');
        $product_description = $request->input('description');

        $product = Products::create([
            'name' => $product_name,
            'price' => $product_price,
            'description' => $product_description,
        ]);
        return response()->json([
            'data' => new ProductResource($product)
        ], 201);
}

Update(Update Product Details)

To update the product details , we can update the logic of the update method

use App\Http\Resources\ProductResource;
use App\Models\Products;

public function update(Request $request, Products $product)
{
        $product_name = $request->input('name');
        $product_price = $request->input('price');
        $product_description = $request->input('description');

        $product->update([
            'name' => $product_name,
            'price' => $product_price,
            'description' => $product_description,
        ]);
        return response()->json([
            'data' => new ProductResource($product)
        ], 200);
}

Destroy(Delete a Product)

At times you might want to delete products from the database. We can add the following code to delete products from the database.

use App\Models\Products;

public function destroy(Products $product)
{
   $product->delete();
   return response()->json(null,204);
}

Routes and endpoints

Let’s now create the endpoints that will be accessible over HTTP. We can add the routes in the routes/api.php file

//routes/api.php
<?php

use App\Http\Controllers\ProductsController;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!
|
*/

Route::middleware('auth:sanctum')->get('/user', function (Request $request) {
    return $request->user();
});

Route::get('products', [ProductsController::class, 'index'])->name('products.index');
Route::get('products/{product}', [ProductsController::class, 'show'])->name('products.show');
Route::post('products', [ProductsController::class, 'store'])->name('products.store');
Route::put('products/{product}', [ProductsController::class, 'update'])->name('products.update');
Route::delete('products/{product}', [ProductsController::class, 'destroy'])->name('products.destroy');

These endpoints are mapped to the methods in the ProductsController we created earlier.

We can now test the index method through a GET request. This will return the following response

[
    {
        "id": 1,
        "name": "quo",
        "price": 15,
        "description": "Ut rerum aut deleniti eveniet ad et ullam perferendis.",
        "created_at": "2022-11-18T15:18:13.000000Z",
        "updated_at": "2022-11-18T15:18:13.000000Z"
    },
    {
        "id": 2,
        "name": "maxime",
        "price": 70,
        "description": "Natus officiis repellat vero ea voluptatem mollitia similique.",
        "created_at": "2022-11-18T15:18:13.000000Z",
        "updated_at": "2022-11-18T15:18:13.000000Z"
    }
]

Formatting the Response

The response above is returned in JSON format. It includes details from the database with the column names as the keys.

What if you want to format this response? One thing you might not want to expose is the created_at and updated_at data. You might also want to calculate and return a predefined discount back as a response.

Laravel allows us to customize our responses using API resources.

In this example, I will assume that all products have a 10% discount. I will therefore return the product price and the discounted price as part of the payload in the response.

php artisan make:resource ProductResource

This will transform a model into an array.

//App/Http/Resources/ProductResource
<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class ProductResource extends JsonResource
{
    /**
     * Transform the resource into an array.
     *
     * @param \Illuminate\Http\Request $request
     * @return array|\Illuminate\Contracts\Support\Arrayable|\JsonSerializable
     */
    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'product_name' => $this->name,
            'product_price' => "$" . $this->price,
            'discounted_price' => "$" . ($this->price * 0.9),
            'discount' => "$" . ($this->price * 0.1),
            'product_description' => $this->description,
        ];
    }
}

Let’s update our index method in Products Controller to use the Product resource

public function index()
{
   return ProductResource::collection(Products::all());
}

This will return the newly formatted response

{
    "data": [
        {
            "id": 1,
            "product_name": "quo",
            "product_price": "$15",
            "discounted_price": "$13.5",
            "discount": "$1.5",
            "product_description": "Ut rerum aut deleniti eveniet ad et ullam perferendis."
        },
{
            "id": 2,
            "product_name": "maxime",
            "product_price": "$70",
            "discounted_price": "$63",
            "discount": "$7",
            "product_description": "Natus officiis repellat vero ea voluptatem mollitia similique."
        }
    ]
}

Response Codes

It is important to always return a valid response code in each request. These response codes can be used by a consuming application or client to know what exactly happened on the server side.

Here is a list of the most common response codes

200 – Ok. This signifies it is a success code and it is the default response code
201- Created. This shows that a resource has been created. It is useful for POST requests.
204- No Content. This signifies that the action was successful but no content is returned. It is useful for DELETE requests since a deleted resource cannot return any body content
400- Bad Request. This signifies that the client passed an invalid request to the server
401- Unauthorized. This signifies that the client is not authorized to access the resource. It is typically used in authentication and authorization services.
403- Forbidden. This signifies that a user is authenticated but is not allowed to access the resource.
404- Not Found. This signifies that a resource is not found
500- Internal Server Error. This implies that there is an error at the server level

Laravel allows us to specify the correct response code using the response()->json() helper function. It is important to always return a response code so that the client/frontend can display the correct data and “fail gracefully” in the case of an error.

response()->json(data,status code)

Setting up Authentication with Laravel Sanctum

We have discussed the most basic way of creating a CRUD REST API in Laravel. We now want to add authentication to our API in order to secure it. There are two ways in which we can implement authentication; either through Laravel Passport or Laravel Sanctum.

Passport provides a way in which applications authenticate themselves over the internet. It basically adds Oauth implementation to your API which other systems can use to authenticate themselves when interacting with your API. It is useful for public APIs where you might want to track API usage and also limit requests for each API key.

Sanctum on the other hand provides a stateless integration of the normal authentication service by using email and passwords to provide authentication to a client. It is useful for private/internal APIs that don’t need all the features provided by an OAuth Server.

In this part, I will use Laravel Sanctum to create a simple authentication service for my API. I will use the default email and password to authenticate a user.

To learn more about the two authentication packages, you can read the Laravel Sanctum article or the Laravel Passport article.

Configuration and Setup

We will first create an authentication scaffold using Laravel Breeze

composer require laravel/breeze --dev

We can then install the package

php artisan breeze:install
php artisan migrate
npm install 
npm run dev

This will create a basic authentication scaffold and a forgot and reset password functionality out of the box.

Let’s now install Laravel sanctum and set it up

composer require laravel/sanctum

Next is to publish Sanctum’s configurations

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

Finally, we can migrate the database that will store the access tokens

php artisan migrate

The last step is to allow Sanctum to issue access tokens which will be used to authenticate users’ requests.

App/Models/User
<?php

namespace App\Models;

// use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens; //import the trait

class User extends Authenticatable
{
    use HasApiTokens; //add this trait
    use HasFactory, Notifiable;

    /**
     * The attributes that are mass assignable.
     *
     * @var array<int, string>
     */
    protected $fillable = [
        'name',
        'email',
        'password',
    ];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array<string, string>
     */
    protected $casts = [
        'email_verified_at' => 'datetime',
    ];
}

We can now create a new controller that will be responsible for the Authentication

php artisan make:controller UserAuthenticationController

Register

We can start by fleshing out the user registration logic. We will use the default user table that comes with laravel but feel free to add and remove some columns as you please

use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;

public function register(Request $request)
{
        $name = $request->input('name');
        $email = strtolower($request->input('email'));
        $password = $request->input('password');

        $user = User::create([
            'name' => $name,
            'email' => $email,
            'password' => Hash::make($password)
        ]);

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json([
            'message' => 'User Account Created Successfully',
            'access_token' => $token,
            'token_type' => 'Bearer',
        ], 201);
}

From the code, we can see that a user account is created in the database and an access token is issued to the user and is returned back to the user as a response.

Login

The next important feature is to allow users to log in. We can add the following logic

use Illuminate\Support\Facades\Auth;

public function login(Request $request)
    {
        $email = strtolower($request->input('email'));
        $password = $request->input('password');

        $credentials = [
            'email' => $email,
            'password' => $password
        ];
        if (!Auth::attempt($credentials)) {
            return response()->json([
                'message' => 'Invalid login credentials'
            ], 401);
        }

        $user = User::where('email', $request['email'])->firstOrFail();

        $token = $user->createToken('auth_token')->plainTextToken;

        return response()->json([
            'access_token' => $token,
            'token_type' => 'Bearer',
        ],200);
    }

Similar to the registration, we need to return the access token as soon as the user credentials have been validated.

If the credentials are wrong, we need to alert the user that their credentials are wrong. But how?🤔

Since a REST API is stateless, there is no way of flashing responses in real-time. We, therefore, need to return a valid response code and a descriptive message so that a user knows what happened at the server level.

We can use a simple if else statement but this might make our code less clean. A solution is to use the default Exception Handler provided by Laravel.

We can add some logic to apply to the whole API and catch any Authentication Exceptions and return back a valid API Response back to the client.

We can update the App/Exceptions/Handler. php to resemble the one below

App/Exceptions/Handler

<?php

namespace App\Exceptions;

use Illuminate\Auth\AuthenticationException;
use Illuminate\Foundation\Exceptions\Handler as ExceptionHandler;
use Illuminate\Http\Request;
use Throwable;

class Handler extends ExceptionHandler
{
    /**
     * A list of exception types with their corresponding custom log levels.
     *
     * @var array<class-string<\Throwable>, \Psr\Log\LogLevel::*>
     */
    protected $levels = [
        //
    ];

    /**
     * A list of the exception types that are not reported.
     *
     * @var array<int, class-string<\Throwable>>
     */
    protected $dontReport = [
        //
    ];

    /**
     * A list of the inputs that are never flashed to the session on validation exceptions.
     *
     * @var array<int, string>
     */
    protected $dontFlash = [
        'current_password',
        'password',
        'password_confirmation',
    ];

    /**
     * Register the exception handling callbacks for the application.
     *
     * @return void
     */
    public function register()
    {
        $this->renderable(function (AuthenticationException $exception, Request $request) {
            if ($request->is('api/*')) {
                if ($exception instanceof AuthenticationException) {
                    return $request->expectsJson() ?:
                        response()->json([
                            'message' => 'Unauthenticated.',
                            'status' => 401,
                            'Description' => 'Missing or Invalid Access Token'
                        ], 401);
                }
            }
        });
    }
}

This will come in handy when we discuss middleware.

Logout

Of course in each system, we need a logout functionality so we will also create its function

public function logout()
{
    auth()->user()->tokens()->delete();

    return response()->json([
        'message' => 'Succesfully Logged out'
    ], 200);
}

Note that we are using the delete function to invalidate an existing access token and delete it from the database. This makes the access token unusable and we can comfortably say the user is logged out.

The final piece left is to create the endpoints/routes in the routes/api.php file.

Route::post('login', [UserAuthenticationController::class, 'login']);
Route::post('register', [UserAuthenticationController::class, 'register']);
Route::post('logout', [UserAuthenticationController::class, 'logout'])->middleware('auth:sanctum');

Only the logout endpoint needs middleware because it requires a token to be passed to v erify which user is being logged out of the system.

Scopes and Middlewares

Scopes are commonly used in APIs to assign abilities to tokens. They help flesh out what a user can and cannot do in a system. Think of them as permissions you grant to users once you onboard them. Some users can access financial records in a system while others cannot.

Middlewares on the other hand are used to protect endpoints from unauthorized access. Think of them as a gate that filters out valid requests from unauthorized and malicious requests. They help safeguard your endpoints from being accessed by users who have no role in accessing them.

We can add the auth:sanctum middleware to the product’s endpoints to safeguard them. This means that for a request to be considered valid, it has to have the Authorization: Bearer token headers(where the token is the actual access token issued by the API).

HEADERS {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer <Token>'
    }

Each request has to include the bearer token in the headers or the server will respond with a 401(Unauthorized) response.

Grouping Endpoints

In most cases, you might have multiple endpoints that share some common things such as version (e.g v1,v2), prefixes (admin), or middleware.

It is important to always version your APIs especially if they are being used by the public. This helps in preventing breaking changes and also allows for backward compatibility in the event new APIs are available.

We can group these endpoints using the Route::group method

Route::group(['middleware' => ['auth:sanctum']], function () {

    //All Routes that share the auth:sanctum middleware
});

This way we can have our code organized and clean. In this example, I will group the routes to be of version 1 and use the auth:sanctum middleware.

We might also want to reduce the size of the api.php file by making each resource use apiresource. This simple function reduces the file size by almost 60% and makes reading and maintaining the code an easy task.

Route::apiResource('products', ProductsController::class);

The apiresource method under the hood works by mapping the main functions(index, show, store, update and delete) in our controller to their various endpoints.

For example products.show is mapped to the endpoint api/products/{product}.

These are some cool techniques you can use to optimize your development experience and become more productive when developing your APIs.

The final routes/api.php file should resemble the one below

//routes/api.php
<?php

use App\Http\Controllers\ProductsController;
use App\Http\Controllers\UserAuthenticationController;
use Illuminate\Support\Facades\Route;

/*
|--------------------------------------------------------------------------
| API Routes
|--------------------------------------------------------------------------
|
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!
|
*/

//These routes are NOT protected using middleware

Route::prefix('v1')->group(function () {
    Route::post('login', [UserAuthenticationController::class, 'login']);
    Route::post('register', [UserAuthenticationController::class, 'register']);
});

//These routes are protected using middleware
Route::prefix('v1')->middleware('auth:sanctum')->group(function () {
    Route::post('logout', [UserAuthenticationController::class, 'logout']);
    Route::apiResource('products', ProductsController::class);
});

Testing using Postman

The last step in this tutorial is to test our API through an HTTP Client. There are numerous HTTP Clients such as Postman and Thunderclient just to name a few.

I personally use Thunderclient because it integrates seamlessly with Vscode which is my goto editor. It can be added as a Vscode extension thereby making your Vscode editor a powerful editor and REST API client at the same time.

It improves my productivity and development experience immensely. You are free to use any other HTTP Client of your choice.

I will use postman in this article as most people are familiar with it.

We will break down the test from authentication to the basic CRUD

Authentication

We can further break down authentication into registration, login and logout.

Registration

We can make a POST request to the endpoint api/v1/register with the body on postman

Successful Registration

Login

To test login functionality, we can make a POST request to the api/v1/login

Failed Login

A failed login attempt returns a 401(Unauthorized) Status Code and also returns a descriptive message to the client

Successful Login

A successful login attempt returns a 200(OK) Status Code and also returns an access token that can be stored for future use.

Logout

Logout can be tested by making a POST request to the api/v1/logout endpoint. We also need to attach the bearer token assigned to us during registration/login to the Headers.

Logout

Upon success, a descriptive message and a 200(OK) Status Code are returned back to a User.

We can now test the Product resource. Similar to log out, we also need to attach the bearer token assigned to us during registration/login to the Headers. This is because all the product’s endpoints are protected by the auth:sanctum middleware.

If we try to access any product’s endpoint without the access token , the server will respond with a 401(Unauthorized) Status Code.

Unauthorized Access

This is because we registered an Exception Handler to catch any access to the API that is not authorized and return a 401 Status Code with a descriptive response. This protects our API endpoints from unauthorized access.

Get All Products

All products can be returned by making a GET request to the api/v1/products endpoint.

Get All Products

Get A Single Product

We can fetch a single product from the API by making a GET request to the api/v1/products/{id} endpoint

Get a Single Product

Add A Product

We can add a product by making a POST request to the api/v1/products endpoint

Add a Product

Update A Product

To update a product’s details, we can make a PUT/PATCH request to the api/v1/products/{id} endpoint.

Update a Product

Delete A Product

We can make a DELETE request to the api/v1/products/{id} endpoint to delete a product from the database

Delete a Product

In Closing

In this article, we have covered what Rest APIs are and how to create one in Laravel. We have also covered API authentication and Using Middleware to control access to your API. I hope this article was insightful and helped you create a powerful REST API in laravel.

Thank you for reading.

The post How to Build a Rest API with Laravel: A Beginners Guide appeared first on Ian Kumu's Blog.

How to Upload Files/Images to Google Cloud Storage in Laravel

Ian Kumu — Mon, 31 Oct 2022 13:14:15 +0000

Laravel provides a powerful filesystem integration that makes working with Files an easy task. Laravel integrates with Amazon S3 out of the box and you can also use the default disk space on your computer/server to store files.

The market, however, has seen the rise of other Object Storage services such as Google Cloud Storage and Azure Blob Storage just to name a few.

In this article, I will show you how to upload files/images to Google Cloud Storage.

Why use Object Storage

When it comes to files, it is way easier to just store them on the disk, say for your server, because it is free and it is one way of utilizing your server space assigned to you by your host.

However, it does come at risk since the server can always get corrupted and worse get deleted making all your files and images to be lost in the event of such a scenario.

It is also not scalable because you would have to dedicate one instance to primarily store files which can lead to more revenue spent on your infrastructure.

It is also not secure because you would need to actively implement security features to safeguard your file server.

Object Storage help solve these problems as they provide Security , Scalability and Availability at the fraction of the price.

Take Google Cloud for instance, for just 0.02$, at the time of writing, you get 1GB of storage. This provides all the features I mentioned above and removes the burden of maintaining your own File Server. Just connect to their API and you are good to go.

How to Upload Files to Google Cloud Storage in Laravel

To Upload Files to Google Cloud Storage, you can follow the following steps.

Create a Service Account

A Service Account allows a system to authenticate itself when accessing Data from Google APIs. Access to Google is granted based on the IAM and is specified in the service account. This makes it easy for us to specify which services our Application will have access to.

In your Google Cloud Console, head over to the Service Accounts Section
Select your project and Create a Service Account.
Once the Service account is created, you will be assigned a random email address for your service account
The next step is to create a Key which you will use in our Laravel Application.
In the keys tab in your newly created service account, click on the add key button and choose the JSON option

This will create a new key with its corresponding service account JSON file which you can download to your local pc.

Create a Storage Bucket

Once you are done with setting up the Service Account, it is now time to create a Storage Bucket. A bucket is a basic container which holds all your data. You can have folders and files in a single Bucket.

Head over to the Cloud Storage Tab and create a new Bucket
Name your bucket and choose the location where your bucket will be created. In this part, I will just choose a single region as it is the cheapest
For the default storage class , just choose the Standard class, or any other class depending on your needs
When it comes to how your data will be accessed , there are two options; Uniform and Fine-grained. Google Recommends Uniform Access Control but I was not able to wrap my head around how it works and thus I just use Fine-grained access control which allows me to authenticate through the service account I created earlier.
The last step is to choose the protection tools. You can leave it as None since Google Cloud Storage Buckets are Secure by default. Once done click Create and your bucket is now ready.
One final thing you need to do is to grant your service account access to your bucket and specify its roles. Click on your new bucket and head to the permissions tab.
Click on grant access and Add your Service Account as a Principal(search for it and it should pop up in the search).
You then need to assign cloud storage roles to your principal. The Roles you should assign are Storage Admin , Storage Object Admin , Storage Object Creator , and Storage Object Viewer. Click save and your bucket is now ready to be used in Laravel.

Create a Laravel Project

If you have no Laravel project created yet, you can create one using the laravel new command.



laravel new gcs storage

Install package

To interact with Google Cloud Storage APIs, we will use this package to do so.



composer require superbalist/laravel-google-cloud-storage

Update Filesystem file

Laravel handles storage disks through the config/filesystems.php file. The file contains three different disk services, local , public and s3. We need to add gcs to register it as another disk available to our laravel application



//config/filesystems.php

'gcs' => [
            'driver' => 'gcs',
            'project_id' => env('GOOGLE_CLOUD_PROJECT_ID', 'your-project-id'),
            'key_file' => env('GOOGLE_CLOUD_KEY_FILE', base_path('service-account.json')), // optional: /path/to/service-account.json
            'bucket' => env('GOOGLE_CLOUD_STORAGE_BUCKET', 'your-bucket'),
            'path_prefix' => env('GOOGLE_CLOUD_STORAGE_PATH_PREFIX', null), // optional: /default/path/to/apply/in/bucket
            'storage_api_uri' => env('GOOGLE_CLOUD_STORAGE_API_URI', null), // see: Public URLs below
        ],

The updated filesystems.php file should resemble this one.

filesystems config file

Copy Service Account JSON file to the base path

The next step is to copy the Service Account JSON file we downloaded earlier to your Laravel Application base path. If you have not downloaded it yet, refer to this section to do so.

Service Account JSON File

Update Environment Variables

You need to specify the bucket name and the project id. You can find your project id in the console dashboard.

Google Cloud Storage Environment Variables

You also need to update the Filesystem Driver to gcs in the .env file

Filesystem variable

Upload Files

You can now interact with google cloud storage through Laravel. To Upload files, I will create a new Files Controller



php artisan make:controller FilesController

I will create an Upload File Function that will take care of Uploading Files to Google Cloud Storage.



use Illuminate\Support\Str;
use Illuminate\Http\UploadedFile;

public function uploadFile(UploadedFile $file, $folder = null, $filename = null)
    {
        $name = !is_null($filename) ? $filename : Str::random(25);

        return $file->storeAs(
            $folder,
            $name . "." . $file->getClientOriginalExtension(),
            'gcs'
        );
    }

You can then request files through HTTP and Upload them to Google Cloud.



public function store(Request $request)
    {
        $link = $request->hasFile('file') ? $this->uploadFile($request->file('file'), 'Categories') : null;
        $category = new Categories();
        $category->name = $request->input('name');
        $category->file= $link;
        $category->save();

        return redirect()->back();
    }

Google Cloud Storage

Retrieve Files/Images.

You can retrieve files using the Storage Facade. If you are storing the file path in the database, you can append the path to the URL method.



use Illuminate\Support\Facades\Storage;

Storage::disk('gcs')->url(path/to/file)

This will return the file URL in this pattern.



http://storage.googleapis.com/bucket-name/folder/your_file.png

If you prefer to use your own custom domain name , you can add a CNAME to your DNS records.

You can read this guide for further instructions on how to use your custom domain name.

Delete Files.

I will also add another function that will be responsible for deleting files from Google Cloud Storage if they are not needed anymore.



use Illuminate\Support\Facades\Storage;

public function deleteFile($path = null)
    {
        Storage::disk('gcs')->delete($path);
    }

You can now delete files by calling the function and passing the File Path as a parameter.

Conclusion

In this guide, we have learnt how to set up and upload files to Google Cloud Storage and how to Manage those files by Retrieving and Deleting them. I hope this article was insightful and helpful. You can read some of the best practices for uploading Files in Laravel.

Thank you for reading.

The post How to Upload Files/Images to Google Cloud Storage in Laravel appeared first on Ian Kumu's Blog.

How to Build a Live Search using Laravel, Livewire, and Meilisearch

Ian Kumu — Fri, 14 Oct 2022 18:35:47 +0000

One of the most powerful features of Laravel is its ability to integrate with many different services. By default, Laravel integrates with the Meilisearch service. This allows you to easily query your data using the Laravel Eloquent ORM. But what if you want to build a custom search page? Well, it’s easy to do with a couple of tweaks. This article will show you how to create a custom search page using Laravel, Livewire, and Meilisearch.

What is Meilisearch?

Meilisearch is an open-source search engine that is built using Rust and can be integrated into any application to provide Full-Text Search. It comes with a lot of features that we can use to our advantage as developers. Because it is built using Rust, it is blazing fast making it a useful utility for any application. Laravel, through Laravel Scout , comes with an already implemented solution for meilisearch making it easy to use.

But What is Laravel Scout?

Laravel Scout is a first-party Package developed by Taylor Otwell that can be used to add Full-Text Search to your Eloquent Models. It makes it easy to search through your Eloquent Models and return the search results in a clean fashion.

Let’s get started.

How to integrate Full-Text Search into Laravel

Before we start, we need a couple of things;

A Laravel Application
Meilisearch Installed.

Once you have created a new Laravel Application and downloaded and installed Meilisearch, you can now follow these steps.

Install Laravel Breeze

If you have created a new Laravel Application, you can install a starter kit. I will install Laravel breeze in this tutorial.

composer require laravel/breeze

Prepare Model and Migration

We now need a Model to work with. I am going to use an Article Model which will contain an article name, author name and article content

php artisan make:model Articles -m

This command will create an Article Model and its corresponding migration file.

//App/Models/Articles.php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Articles extends Model
{
    use HasFactory;

    protected $fillable = [
        'name', 'author', 'content'
    ];
}

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('articles', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->longText('content');
            $table->string('author');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('articles');
    }
};

Seed the Database

When testing, I usually use Factories and Seeders to speed up my development process. To do so, we can create an Article Factory

php artisan make:factory ArticleFactory

We can use faker to seed the database and then register the factory in the Database seeder

//database/factories/ArticlesFactory.php
<?php

namespace Database\Factories;

use Illuminate\Database\Eloquent\Factories\Factory;

/**
 * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\Articles>
 */
class ArticlesFactory extends Factory
{
    /**
     * Define the model's default state.
     *
     * @return array<string, mixed>
     */
    public function definition()
    {
        return [
            'name' => $this->faker->words(2, true),
            'content' => $this->faker->sentence(),
            'author' => $this->faker->name()
        ];
    }
}


//database/seeders/DatabaseSeeder.php
<?php

namespace Database\Seeders;

// use Illuminate\Database\Console\Seeds\WithoutModelEvents;

use App\Models\Articles;
use Illuminate\Database\Seeder;

class DatabaseSeeder extends Seeder
{
    /**
     * Seed the application's database.
     *
     * @return void
     */
    public function run()
    {
        Articles::factory(20)->create();
    }
}

To seed the database, db:seed command will be of help

php artisan db:seed

Install and Configure Livewire

The next step is to install the livewire package. Livewire will be a major help in adding reactivity to our application.

composer require livewire/livewire

We then need to include the livewire Javascripts in the app.blade.php file in the resources/views/components folder.

...
    @livewireStyles
</head>
<body>
    ...

    @livewireScripts
</body>
</html>

Create Article Component

Livewire helps us scaffold components fast using the make:livewire command.

php artisan make:livewire Articles

This creates a Component which we can reuse in multiple places.

This command creates two files, one in the App/Http/Livewire Folder and another one in the resources/views/livewire folder. These two will be essential in creating our full-text search

Through laravel breeze, Laravel scaffolded authentication and a dashboard which we can now use to display the Articles.

We can fetch records from the database and display them using the Articles Component.

{{-- resources/views/dashboard.blade.php --}}
<x-app-layout>
    <x-slot name="header">
        <h2 class="font-semibold text-xl text-gray-800 leading-tight">
            {{ __('Dashboard') }}
        </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 bg-white border-b border-gray-200">
                   @livewire('articles'){{-- Including the Article Compontent--}}
                </div>
            </div>
        </div>
    </div>
</x-app-layout>

Install and Set up Laravel Scout

The next step is to install the Laravel scout package using composer

composer require laravel/scout

We can then publish the configurations

php artisan vendor:publish --provider="Laravel\Scout\ScoutServiceProvider"

Laravel Scout allows us to use any search driver such as database , algolia or meilisearch etc Meilisearch is a popular search engine because it is open source and can be self-hosted. It makes search easy because it handles all the technical bits such as typos.

Laravel Scout helps with all the other factors in search including indexing , updating the index and returning the results in a Laravel Friendly way. Under the hood, Scout uses Model Observers to update the records and re-index the search results in Meilisearch.

To set up Scout in our Models, we will need to include the Searchable trai t in our Model

//App/Models/Articles.php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable; //import the trait

class Articles extends Model
{
    use HasFactory;
    use Searchable; //add this trait

    protected $fillable = [
        'name', 'author', 'content'
    ];
}

We also need to install a few packages to be able to interact with meilisearch

composer require meilisearch/meilisearch-php http-interop/http-factory-guzzle

We can then set the environment variables to now use Meilisearch

SCOUT_DRIVER=meilisearch
MEILISEARCH_HOST=http://127.0.0.1:7700
MEILISEARCH_KEY=masterKey

Add Search Logic

Before performing a Search, we need to index our records in meilisearch using the scout:import command

php artisan scout:import "App\Models\Articles"

Now, we can use Eloquent to perform a search on our records

We can update our Livewire Component to include the Search Logic

//App/Livewire/Articles.php
<?php

namespace App\Http\Livewire;

use App\Models\Articles as ModelsArticles;
use Livewire\Component;

class Articles extends Component
{

    public $search = '';
    public $articles;

    public function render()
    {
        if (empty($this->search)) {

            $this->articles = ModelsArticles::get();
        } else {
            $this->articles = ModelsArticles::search($this->search)->get();
        }

        return view('livewire.articles');
    }
}

Add Search Input Field

On the Articles Table, we can add a search input field that will receive the query and send it to the backend.

Livewire provides a cool way to perform data binding which we can use to our advantage. Using the wire:model property, we can pass the query onto the server and get the results back synchronously.

We can use one of the tailwind components templates to scaffold a view.

<!-- resources/view/livewire/articles.blade.php -->
<div>
     <!-- component -->
     <link rel="stylesheet" href="https://demos.creative-tim.com/notus-js/assets/styles/tailwind.css">
     <link rel="stylesheet" href="https://demos.creative-tim.com/notus-js/assets/vendor/@fortawesome/fontawesome-free/css/all.min.css">

       <section class="py-1 bg-blueGray-50">
           <div class="w-full xl:w-8/12 mb-12 xl:mb-0 px-4 mx-auto mt-24">
           <div class="relative flex flex-col min-w-0 break-words bg-white w-full mb-6 shadow-lg rounded ">
               <div class="rounded-t mb-0 px-4 py-3 border-0">
               <div class="flex flex-wrap items-center">
                   <div class="relative w-full px-4 max-w-full flex-grow flex-1">
                   <h3 class="font-semibold text-base text-blueGray-700">Articles</h3>
                   </div>
                   <div class="relative w-full px-4 max-w-full flex-grow flex-1 text-right">
                <input type="text" placeholder="Search..." wire:model="search">
                </div>
               </div>
               </div>

               <div class="block w-full overflow-x-auto">
               <table class="items-center bg-transparent w-full border-collapse ">
                   <thead>
                   <tr>
                       <th class="px-6 bg-blueGray-50 text-blueGray-500 align-middle border border-solid border-blueGray-100 py-3 text-xs uppercase border-l-0 border-r-0 whitespace-nowrap font-semibold text-left">
                                   Article name
                        </th>
                   <th class="px-6 bg-blueGray-50 text-blueGray-500 align-middle border border-solid border-blueGray-100 py-3 text-xs uppercase border-l-0 border-r-0 whitespace-nowrap font-semibold text-left">
                                   Content
                    </th>
                   <th class="px-6 bg-blueGray-50 text-blueGray-500 align-middle border border-solid border-blueGray-100 py-3 text-xs uppercase border-l-0 border-r-0 whitespace-nowrap font-semibold text-left">
                                   Author
                    </th>
                   </thead>

                   <tbody>
                        @if (!$articles->isEmpty())
                            @foreach ($articles as $article)

                                <tr>
                                    <th class="border-t-0 px-6 align-middle border-l-0 border-r-0 text-xs whitespace-nowrap p-4 text-left text-blueGray-700 ">
                                    {{$article->name}}
                                    </th>
                                    <td class="border-t-0 px-6 align-middle border-l-0 border-r-0 text-xs whitespace-nowrap p-4 ">
                                        {{$article->content}}
                                    </td>
                                    <td class="border-t-0 px-6 align-center border-l-0 border-r-0 text-xs whitespace-nowrap p-4">
                                        {{$article->author}}
                                    </td>
                                </tr>
                            @endforeach
                        @else
                            <td class="border-t-0 px-6 align-center border-l-0 border-r-0 text-xs whitespace-nowrap p-4">
                            No Results Found
                            </td>
                        @endif
                   </tbody>

               </table>
               </div>
           </div>
           </div>

       </section>
</div>

Livewire handles getting the query from the input field, makes an ajax request to the backend and returns the results back to the frontend.

This makes it easy to create a live search with minimal effort.

Live Search

Display Results

Once Scout returns the results, Livewire takes care of displaying them on the table.

Searched Results

Conclusion

In this article, we have covered how to create a live search using Laravel Livewire and Meilisearch. We covered how to set up your application and include all the features needed for Full-Text Search. I hope this article was insightful.

If you enjoyed this article, you'd love the Free Laravel Guide I prepared for you. Be sure to get your guide today.
Thank you for reading.

The post How to Build a Live Search using Laravel, Livewire, and Meilisearch appeared first on Ian Kumu's Blog.

Laravel Mail: How to Send Emails Easily in Laravel

Ian Kumu — Fri, 09 Sep 2022 20:21:20 +0000

Sending an email is one of the most important additions to any system; be it Transactional emails or sending newsletter emails. In recent surveys, 64% of small businesses use emails to reach customers. This makes it necessary to send emails to customers in order to engage your customers and also build a loyal customer base.

Laravel provides a clean and easy way to send emails without any hassle and difficulties using the Mailable Class.

In this article, I am going to show you how to easily send emails in Laravel and how to create email templates using markdown

What you need to know about Laravel Mail

If you want to send emails from your Laravel application, you need to know about the Laravel Mail API. This simple API is built on top of the popular Swiftmailer library. You can configure it to use SMTP , Mailgun , Postmark , Amazon SES , or Sendmail. You can also use the simple API to send emails directly from your PHP code. Laravel provides multiple mail drivers for sending emails making it easy to send emails using any integration of your liking.

The Laravel Mail API makes it easy to send beautiful email templates. You can create a Mailable class and a public function build() that returns your email template.

It’s easy to get started with Laravel Mail. Just configure your SMTP settings and you’re ready to go!

How do you send Emails in Laravel?

To send an email message in Laravel, you can follow the following steps

Step 1: Install Laravel

You can create a new Laravel project using the laravel new command

laravel new test

Step 2: Create a Mailable Class

You can use the make:mail artisan command in Laravel. This will scaffold a Mailable class which has a build() function where your mail logic will be added.

You can specify the email subject , and the content of the email such as images , attachments, and reply to address among others.

php artisan make:mail OrderMail

This command will create a Mailable Class in the app/Mail Folder

<?php

namespace App\Mail;

use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;

class OrderMail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Create a new message instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Build the message.
     *
     * @return $this
     */
    public function build()
    {
        return $this->markdown('emails.orders');
    }
}

Mail Example using Markdown Template

One of the key benefits of laravel is that it has markdown support. You can create an email template using markdown. This allows you to have a boilerplate view of the email which you can customise to your liking or use as is.

You can modify the make:mail command and add a flag to specify which markdown will be used by your Mailable Class. The markdown template is a blade file that is placed in the “emails” directory.

php artisan make:mail OrderMail --markdown=emails.orders

This creates a default markdown blade file in the resources/views/emails folder

@component('mail::message')
# Introduction

The body of your message.

@component('mail::button', ['url' => ''])
Button Text
@endcomponent

Thanks,<br>
{{ config('app.name') }}
@endcomponent

Using a simple scenario of an order mail, you can pass some default data to the markdown through the with() command in the Mailable Class. You could use the constructor to receive data from other classes.

You can update the logic of the Mailable class

<?php

namespace App\Mail;

use App\Models\Orders;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Mail\Mailable;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Facades\URL;

class OrderMail extends Mailable
{
    use Queueable, SerializesModels;

    /**
     * Create a new message instance.
     *
     * @return void
     */
    public $order, $user;
    public function __construct(Orders $order, User $user)
    {
        $this->user = $user;
        $this->order = $order;
    }

    /**
     * Build the message.
     *
     * @return $this
     */
    public function build()
    {
        return $this->markdown('emails.orders')
            ->subject('Your Order is being Processed')
            ->with([
                'order' => $this->order,
                'customer' => $this->user,
                'order_url' => URL::route('orders.show', $this->order->id)
            ]);
    }
}

The next step is to add content to the markdown blade template

@component('mail::message')
Hello {{$customer->name}},

Your Order No.{{$order->id}} has been placed successfully and is now being processed

You can view your order details using the link below.

@component('mail::button', ['url' => $order_url])
View Order
@endcomponent

Regards,<br>
{{ config('app.name') }}
@endcomponent

If you want to customize the Laravel Mail Components, you can publish the assets and change them to your liking using this command

php artisan vendor:publish --tag=laravel-mail

Step 3: Sending email in Laravel

Once you have the email template set, it is now time to send an email. You can use the Mail Facade to send an email. It comes with a lot of methods but the most important is the to() method. This method defines where the email will be sent. You can pass a user’s email as a parameter and Laravel will send the email to the email specified.

The next important method is the send() method. This method allows us to specify a Mailable message Instance. This is where you specify the Mailable class you had created earlier.

use Illuminate\Support\Facades\Mail;
Mail::to(request()->user())->send(new MailableClass);

You can update the Facade to include your Mailable Class

use Illuminate\Support\Facades\Mail;

$user = User::find($id)?? auth()->user();
$order = Orders::find($id);
Mail::to($user->email)->send(new OrderMail($order, $user));

Emails can be queued and sent in the background making your application even faster.

Before sending an email,you first need to update the mail configurations.

You can set the default details in the env file.

MAIL_MAILER=smtp
MAIL_HOST=mailhog
MAIL_PORT=1025
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="hello@example.com"
MAIL_FROM_NAME="${APP_NAME}"

Once you have set the mail configurations, you can now start sending emails from your Laravel Application.

Step 4: Testing emails in Laravel

Laravel makes it easy to test emails using either the laravel log file ,mailhog or Mailtrap as third-party integration. These services provide a fake SMTP server from where you can test and verify that your emails are correctly formatted.

All you need to do is change the mail configurations in the env file and use the credentials of any fake SMTP server.

Using Mailtrap for instance, you can visually see how the email is formatted

Sample Email Using Markdown

Which third-party email sending providers are supported in Laravel?

Laravel supports several third-party email sending providers, including Mailgun, Postmark, Amazon SES, and SendGrid. Each provider has its own strengths and weaknesses, so it’s important to choose the one that best suits your needs.

If you prefer using your own SMTP server , ensure that your server’s SMTP port is not blocked. Most VPS services such as Digital Ocean block port 25(SMTP) making it hard to send and receive emails on your server.

Other services such as Contabo and Kamatera, however, do not block port 25 making it easy to host your own mail server.

If you prefer hosting your own mail server as opposed to using third-party email service providers, then you can read this article.

It is good to note that hosting your own mail server comes with its fair share of cons such as emails may be delivered to the spam folder. This is because your mail server IP is still new among other email SMTP servers and it will require you to warm up your IP so that it gains a good reputation among other servers.

This is why most people prefer using third-party email service providers so that you concentrate more on what matters.

Why Use Laravel to Send Emails?

One of the great features of Laravel is its inbuilt mail system. This makes it easy to send emails from your application without having to set up a separate mail server. Through its robust Mail API, you can connect to any Email service provider and have your emails sent with ease.

Send Emails in Laravel using Gmail’s SMTP Server

Most people prefer using their default Gmail account as an SMTP server for their Laravel Application because it is free. In this part, I will show you how to use Gmail as an SMTP server for sending your Laravel Emails.

Configure Google Account

You first need to configure some security settings in your Gmail account. To do so, log in to your Gmail account and select “Manage your Google Account” from your profile.

You then need to activate 2 step verification

Before 2-step Verification is turned on

Once you have activated 2 step verification , you will have access to the App password section

After 2-step Verification is turned on

Click on the App passwords section and create a new password for your Laravel Mail Application

Choose the Mail App and the device Custom

Generate a New App Password

Update Mail Configurations

Once you have generated your app password, you can update your mail configurations in the env file to use Gmail’s SMTP configurations

MAIL_MAILER=smtp
MAIL_HOST=smtp.gmail.com
MAIL_PORT=465
MAIL_USERNAME=youremail@gmail.com
MAIL_PASSWORD=generated password
MAIL_ENCRYPTION=ssl
MAIL_FROM_ADDRESS=youremail@gmail.com
MAIL_FROM_NAME="${APP_NAME}"

Once you have set the configurations you are set to send emails using Gmail for free. Do bear in mind that Gmail allows only 500 emails per day so if your application will be sending a lot of emails, you might consider other services.

Conclusion

Sending Emails in Laravel is easy and is essential in any production-ready application. Through emails, you can engage customers and also automate some of the tasks that are necessary for a fully functioning application. In this article, we have covered how to set up a Simple Mail Implementation in Laravel and how to configure Gmail’s SMTP server so that we can use it with our Laravel application.

There are multiple ways you can further send emails in Laravel. One way is scheduling them using Laravel Scheduler. I hope this article was informative and I hope you enjoyed reading it.

If you enjoyed this article, you'd love the Free Laravel Guide I prepared for you. Be sure to get your guide today.
Thank you for reading.

The post Laravel Mail: How to Send Emails Easily in Laravel appeared first on Ian Kumu's Blog.

Laravel File Upload: A Complete Tutorial and Guide

Ian Kumu — Mon, 05 Sep 2022 14:40:28 +0000

Working with files in any application is a crucial part of any system. Laravel provides a filesystem from where we can interact with files; file upload, storing or retrieving them.

If you have your application deployed to production using one of the hosting providers, It is important to know how to manage your resources wisely. One important thing we could do is compress the files/images so that they do not occupy a lot of space in your server or any storage service such as Amazon S3, Google Cloud Storage or any other external disk services.

In this article, I am going to show you how to upload and compress files in Laravel before storing them.

How do you Upload Files in Laravel?

To upload files in Laravel we can follow the following steps:

Step 1: Create a Laravel Project

We can use the Laravel new command or composer

laravel new test

composer create-project laravel/laravel test

Step 2: Add Auth Scaffolding

In this step, we can use Laravel breeze to scaffold authentication and all other necessary requirements such as password reset and email confirmation logic.

composer require laravel/breeze

Step 3: Add Model and Migration

The next step is to create a migration file that will contain the file name and folder. We can use artisan to create a model and migration file.

php artisan make:model Files -m

The -m flag creates a migration file for the Files Model. We can add the following logic to the Model

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Files extends Model
{
    use HasFactory;

    protected $fillable = ['path'];
}

We can then specify the columns in the files table

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('files', function (Blueprint $table) {
            $table->id();
            $table->string('path');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('files');
    }
};

Step 4: Create a generic File Upload Trait

Traits help us reuse code across multiple classes. This trait will contain the logic for Uploading the file , Renaming the File , Storing the Files in User Specified Folders and Delete Files from storage

For example, in an e-commerce system, we may want to separate Images into Folders; Main Images, Secondary Images, Banners etc.

To do so we will use Illuminate\Http\UploadedFile class to work with the files.

We can also make the trait to be usable with any external disk such as Amazon S3.

Laravel supports local file storage and Amazon S3 out of the box. If you want to use Google Cloud Storage as your storage then you can consider using this package.

Either way, whichever storage service you decide to use, the trait should be able to handle it without adding any extra implementations.

We can create an App\Traits folder in the App directory which will contain all our traits.

<?php

namespace App\Traits;

use Illuminate\Support\Str;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Storage;

trait Upload
{
    public function UploadFile(UploadedFile $file, $folder = null, $disk = 'public', $filename = null)
    {
        $FileName = !is_null($filename) ? $filename : Str::random(10);
        return $file->storeAs(
            $folder,
            $FileName . "." . $file->getClientOriginalExtension(),
            $disk
        );
    }

    public function deleteFile($path, $disk = 'public')
    {
        Storage::disk($disk)->delete($path);
    }
}

To compress the images upon upload, we can use one of Spatie’s Packages

composer require spatie/laravel-image-optimizer

We can have the images compressed automatically when they are uploaded thereby reducing their file size before uploading them to storage. To set it up, we will first need to register it as route middleware in the app/Http/Kernel.php file.

// app/Http/Kernel.php   
protected $routeMiddleware = [   
     'optimizeImages' => \Spatie\LaravelImageOptimizer\Middlewares\OptimizeImages::class,   
   ];

We will then assign the middleware later to the file upload route.

Step 5: Handle File uploads using a Controller

The next step is to Receive Files through a POST request. We will use the store method in the file upload controller to do so.

We can also check the validations to ensure that the files uploaded are of the correct type and are the allowed files.

The file path is also stored in the file table. The file path is returned from our trait after it has renamed the file to be uploaded. The format of the file path will be Folder/filename and extension i.e Products/HIDvPbozwW.png

<?php

namespace App\Http\Controllers;

use App\Models\Files;
use App\Traits\Upload;
use Illuminate\Http\Request;

class FilesController extends Controller
{
    use Upload;

    public function store(Request $request)
    {
        if ($request->hasFile('file')) {
            $path = $this->UploadFile($request->file('file'), 'Products');
            Files::create([
                'path' => $path
            ]);
            return redirect()->route('files.index')->with('success', 'File Uploaded Successfully');
        }
    }
}

File paths in the database

Step 6: Add the Route

We can add the route to the routes/web.php file. We can use the middleware we created earlier in our route

Route::post('upload-files', [FileController::class,'store'])->middleware('optimizeImages');

Step 7: Add File Upload UI

We can create a view file and add a file upload form

File Upload Form

Step 8: Add Storage Link(Optional)

Files uploaded using the public disk option are always stored in the storage/app/public folder. We can use the storage:link command to create a symlink to the public folder.

php artisan storage:link

Step 9: View Uploaded Files

Once the files are uploaded to your preferred storage, you can view the file. If you are using the public folder, you can use the asset helper or public_path helper to return the file path. If you are using a third-party storage system such as s3 or Google Cloud storage, you can use the Storage facade

Using public folder

asset('storage/'.$file->path)

Using S3 or GCS

use Illuminate\Support\Facades\Storage;
Storage::disk('s3')->url($file->path)

You can then append the path as your image source and display them on your application.

<img src="{{asset('storage/'.$file->path)}}" alt="file name">
//or
<img src="{{$file->path}}" alt="file name">

Display Files

How can I update Files in Laravel?

By default, there is no intrinsic way to update files/images using the default PUT or PATCH request based onthis issue. Therefore, we need to look for another way to do so. We could use a POST request but then delete a previous file if it exists and then upload a new file and update the file path in the database.

 public function update_file(Request $request) //POST
    {
        //get the file id and retrieve the file record from the database
        $file_id = $request->input('file_id');
        $file = Files::where('id', $file_id)->first();
        //check if the request has a file
        if ($request->hasFile('file')) {
            //check if the existing file is present and delete it from the storage
            if (!is_null($file->path)) {
                $this->deleteFile($file->path);
            }
            //upload the new file
            $path = $this->UploadFile($request->file('file'), 'Products');
        }
        //upadate the file path in the database
        $file->update(['path' => $path]);

        //redirect with the success message
        return redirect()->back()->with('success', 'File Updated Successfully');
    }

We can then define the route to update the file.

Route::post('update-file', [FilesController::class, 'update_file'])->middleware('optimizeImages');

How do I upload multiple Files and Images in Laravel?

It is pretty easy. We can reuse our trait and use a foreach loop to upload and store the path in the database.

We will first update the File Controller to allow for multiple files.

<?php

namespace App\Http\Controllers;

use App\Models\Files;
use App\Traits\Upload;
use Illuminate\Http\Request;

class FilesController extends Controller
{
    use Upload;

    public function store(Request $request)
    {

        $file_details = [];

        //check if request has files
        if ($request->hasFile('files')) {
          // loop through each file and upload
 it

            foreach ($request->file('files') as $key => $file) {
                //Upload to Storage
                $path = $this->UploadFile($file, 'Products');

                //reformat the file details
                array_push($file_details, [
                    'path' => $path,
                ]);
            }

            //add each file details to database
            foreach ($file_details as $key => $value) {
                Files::create($value);
            }
        }
    }
}

The store method now allows for multiple files to be uploaded.

How do I resize files in Laravel?

You can resize files before storing them using the Intervention Image package. This package can help you resize images before storing them.

use Intervention\Image\Facades\Image;
Image::make($file->path)->resize(200, 200);

Conclusion

Working with files and images can be a daunting task in any application but Laravel makes it easy to work with multiple Storage services using their inbuilt APIs and other third-party packages.

If you enjoyed this article, you'd love the Free Laravel Guide I prepared for you. Be sure to get your guide today.
Thank you for reading

The post Laravel File Upload: A Complete Tutorial and Guide appeared first on Ian Kumu's Blog.

NGINX vs Apache: Choosing The Best Web Server in 2022

Ian Kumu — Sat, 27 Aug 2022 16:06:13 +0000

Nginx and Apache are two of the most popular web servers in the world. They are both powerful and versatile and can be used for a variety of purposes. Nginx is known for its high performance and stability, while Apache is known for its flexibility and ease of use. Both web servers are open source and can be used on a variety of operating systems.

Most Web hosting providers provide any of the two and it is up to us to determine which web server better suits our needs.

What is a Web Server?

A web server is a computer program that runs on a computer and is used to serve content to the World Wide Web. It can also be used to run other programs or provide services.

How does a Web Server actually work?

A Web Server processes requests from the client computers and sends back the requested data. It is typically located on an IP address, which is a number that identifies an internet protocol address. The IP address can be used to locate the server on the internet and send its requests.

A web server uses one of two methods to process requests: TCP/IP or HTTP. When using HTTP , the server responds with HTML pages, images, videos, and other web content that match the request. When using TCP/IP , on the other hand, the server is typically running a single application that receives inbound requests from clients and processes them.

How Does Nginx Work?

Nginx is a popular web server that has been used in various places for years. It is open-source and can be found on many different operating systems.

It was created by Igor Sysoev in 2004 and is mostly used as a reverse proxy or load balancer. Nginx also uses TCP and HTTP protocols to handle requests from clients.

Nginx architecture consists of two parts, the worker process and the master process. The worker processes are responsible for handling client requests while the master process handles all tasks such as startup, configuration changes, logging, health monitoring, etc. It uses event-based architecture to handle requests. This helps in concurrent connections being handled simultaneously.

Nginx Pros

Free and Open source
Nginx is lightweight and has fewer resource requirements than Apache
It offers a number of features that are not available in Apache
Is able to handle more traffic than other web servers like Apache
Nginx provides excellent performance and scalability.
Easy to configure and deploy

Nginx Cons

Is not as secure as other web servers like Apache

How Does Apache Work?

Apache is an open-source web server software under the apache software foundation. It was created in the early 1990s by a group of developers at the University of California, Berkeley.

The Apache server is structured in different modules used for different purposes but all share similar functionality. The Apache configuration includes both installation directories as well as files that are necessary for its operation. It uses a process-based architecture to handle requests. This results in a single process handling a single request.

Apache Pros

Apache is a free and open source HTTP server
It uses a modular design, which means that you can mix and match modules from different vendors to create your own custom configuration
Apache offers a lot of security options to protect your website from hackers and other malicious entities
It has strong performance due to its use of caching algorithms
There are many add-ons available for the server that allow you to customize its functionality even further
It is compatible with other web servers such as Nginx and Lighttpd.

Apache Cons

Can be slow
Consumes a lot of memory (Resource Intensive)

What’s the Difference Between Apache and NGINX?

NGINX and Apache are the two most popular web servers in the world. They are both open source and have been around for a long time. So what is the difference between them?

Architecture

Well, the biggest difference is that Apache uses a process-based model , while NGINX uses an event-based model.

To better understand the two architectures, we will use an analogy of a restaurant and a drive-thru.

At a restaurant, each customer has one waiter serving them. This is how the process-based model works. We have one request(customer) being handled by one process(waiter)

At a drive-thru, a customer is served by more than one person. One person could be taking the order, another person preparing the order and later another person will pack the order. In this scenario, we have a chain of delegation happening allowing for faster take-out service. This is how the event-based model works under the hood.

Apache Architecture

Apache uses a process-based architecture which is a software architecture that was first introduced in the Apache HTTP Server in 2000. It is a set of architectural principles and best practices for building, deploying, and operating high-performance web servers.

Apache process-based architecture consists of three layers: The application layer is where the user interface is rendered and managed. The presentation layer provides a view of the data to the user. The data layer handles all data processing.

Processes are created to handle particular requests or tasks, with each process having its own responsibility for handling that request/task. These processes communicate with each other through queues or shared memory to coordinate their work and pass information back up to higher levels of the system as necessary.

Nginx Architecture

Nginx event-based architecture is built on the idea that the best way to serve a request is to process it in the order it arrives.

The Nginx event-based architecture has been designed with scalability in mind and it is also a good fit for microservices. This architecture makes use of global variables and events that are used to trigger actions when certain conditions are met.

This means that NGINX can handle a lot more traffic than Apache can. It also uses less memory, which is important if you have a lot of traffic.

Load Balancing Capabilities

Another difference is that NGINX can act as a load balancer, while Apache cannot. This means that NGINX can distribute traffic across multiple servers , which helps to keep your site up even if one of your servers goes down. Using Nginx as a load balancer can help us take advantage of canary deployments to our application servers.

Reverse Proxy Capabilities

Nginx can also act as a reverse proxy while Apache cannot. A reverse proxy is able to hide the identity of the application servers.This way all the client applications will only know the identity of the reverse proxy but not the identity of the application servers.

Reverse Proxy Architecture

Simplicity

Configuring can be simple depending on your choice of data manipulation. Apache uses XML in its configuration while Nginx uses JSON in its configuration files. Depending on which format you are comfortable with, you can use either.

I personally prefer Nginx because I am more familiar with JSON and as a result find it easier to configure Nginx as a load balancer, reverse proxy or a general web server. Fine-tuning Nginx performance such as adding Http 2 , and enabling Gzip compression is way easier.

Performance

When it comes to performance, it is dependent on the type of content being served. There are two types of content that are served by a web server; Static Content and Dynamic Content

Static Content

Static Content can be described as content that does not change every now and then. These include blog posts, landing pages etc.

When it comes to Static Content , the Nginx server seems to be the better option as it is able to serve static content in milliseconds compared to Apache. It serves Static Content 2.5 times faster than Apache.

Dynamic Content

Dynamic Content on the other hand is the content that keeps on changing based on the reactivity of the application. For example, if you have a video editing application, the content keeps on changing based on the inputs.

Apache is able to serve dynamic content better than Nginx. Nginx uses external processes such as PHP-FPM to serve dynamic content because it does not support dynamic content natively.

Platform

Nginx runs on modern Unix Systems such as Linux but does not support Windows Based Systems. Apache on the other hand runs on All Unix systems and Windows Based Systems

When should you use Apache?

You should use Apache if you want more flexibility and customisation. This is because Apache allows you to configure your own modules.

You should also use Apache if your application is dealing with a lot of Dynamic Content. It is way easier to use the built-in functionalities of Apache to serve dynamic content as opposed to relying on external processes in Nginx to serve the same Dynamic Content.

When should you use Nginx?

You should use Nginx if you want a lightweight web server. If your server resources are minimal , then Nginx is the best option because it consumes fewer resources as compared to Apache.

Nginx should be a no brainer if you are dealing with Static Content as it ticks all the boxes when it comes to serving static content.

If a load balancer or a reverse proxy is required in your stack,Nginx is your best bet in this scenario.

Nginx is also a good choice for a web server that can handle a lot of traffic in an efficient way.

Frequently Asked Questions

Can Nginx and Apache be Used Together?

They can both be used together to improve website performance. Nginx can act as a proxy server, which means it can allow Nginx to handle static content while Apache handles dynamic content. This can speed up website loading times.

Is the Apache HTTP server still used?

Apache HTTP Server is still used today. With a 31.5% market share, it is still one of the most used web servers in the world. Nginx, its closest rival, holds a 33.5% market share.

What language is Nginx written in?

Nginx Source Code is written in C programming language

Why is Apache so Popular?

Apache is popular because it is open source and is also flexible. The flexibility allows for easy customization and configuration.

Why is Nginx faster than Apache?

Nginx is faster than Apache because it uses event-based architecture which allows it to process multiple requests using one process.

In Closing

Deciding on a web server for your use case is an important step in setting up your website. Both Web servers serve content to the best of their ability and it is only right to choose a web server that will suit your needs.

I personally use Nginx as my web server and it is because I find it easier to configure and optimize to suit my needs. I have covered how to deploy a web application using Nginx and Apache and having used both I can say I preferred Nginx to Apache.

What Web Server is your preferred choice?

If you're interested in getting updated each time I publish a new article, feel free to sign up for my newsletter.

The post NGINX vs Apache: Choosing The Best Web Server in 2022 appeared first on Ian Kumu's Blog.

The Ultimate Guide to Ubuntu Commands for Beginners

Ian Kumu — Wed, 24 Aug 2022 08:44:43 +0000

What is Ubuntu?

Ubuntu is a free and open-source operating system. It is based on the Linux kernel and distributed with a GNU userland. Ubuntu has a wide range of support and can be installed on many different devices or used to power your own server. It is one of the best Linux distros used by developers. It has gained popularity because of how stable it is and how mature its package manager is.

Why Should You Learn These Commands?

Ubuntu commands are very important to learn because they can help you with almost anything you need to do on your computer.

They can help you fix any errors , install programs , and manage files. Learning these commands not only helps you navigate the command line interface but also helps you understand why some Linux commands are essential in operating a Linux operating system.

It shows how powerful a terminal can be since you can execute anything on the computer through the terminal. These tasks include changing file permissions, renaming files, check disk space just to name a few.

What are the Basic Ubuntu Commands?

Linux commands are a set of instructions that allow you to interact with the Linux operating system from the command line interface.

The Ubuntu commands helps you get around your system faster and more efficiently.

In this section, I am going to split the commands into their use cases.

Commands used for System Information

lsblk – List block devices on the system.

lsblk command

lspci – List all PCI devices in the system.

lspci command

lshw – Show detailed hardware information about the machine.

lshw command

dmesg – Shows kernel messages since last boot.

dmesg command

uname – Displays the Linux kernel release and architecture.

uname command

Commands used for File Handling

The following commands are used for file handling.

ls : – Lists all the files and directories in the current directory.

ls command

touch : – Creates an empty file with a given name or alters a file’s timestamp to match that of a given date and time.

touch new.txt

cp :- Copies a file from one place to another.

cp .env.example .env

mv :- Moves and renames a file or directory.

mv directory/ /var/www/html

rm :- Removes an existing file or directory.

rm new.txt

find :- Finds files in a directory and displays the names of those files.

find new.txt

mkdir : – Creates a new directory

mkdir directory

rmdir : – Remove an empty directory.

rmdir directory

rd : – Removes a directory and all of its contents recursively.

rd directory/

make :- Creates a new file in a specified location, which must exist and be empty.

make new.txt

You can read more on file permission commands here.

Ubuntu Commands For Package Installation

This is a list of commands which are the most useful for installing packages in Ubuntu. These commands will work in any Linux distribution, but the package names may be different.

apt-get install package name – Installs a package from the APT repository

apt-get update – Downloads the package lists from the repositories and “updates” them to get information on the newest versions of packages and their dependencies. Ideally, it updates the “links” of the packages from where the packages will be fetched when we perform an upgrade

apt-get upgrade – fetches new versions of packages existing on the operating system. This command now “upgrades” the packages by”following the links” that were updated using the apt-get update command

apt-get dist-upgrade – installs new packages or removes existing ones on its own during an upgrade

dpkg -i package-name – This command helps in installing Debian-based packages.

Download/Extract Files Via The Command Line On Ubuntu

wget

The wget command is an internet utility that can be used to download files from the web. It is a command line tool, which means it will only work in a terminal window. The wget command is very versatile and can be used to download files from different types of servers, as well as individual files from websites.

tar

The tar command is a computer program for packaging a set of files into a single file or multiple files. Tar can be used to create, extract, list and verify the contents of archives.

unzip

The unzip command is used to extract files from a ZIP archive. It can be used to extract the contents of an archive into the current directory, or into a new directory.

zip

Zip is a compression and archive format that was initially developed in the mid-1970s. It was created to replace the “archive” command which had been used on Unix systems.

The zip file format offers some advantages over tar and other formats: it can store many files , even if they are not part of a hierarchical directory tree, it provides better compression , especially for large files and it is supported on nearly all computing platforms.

Removing Packages/Uninstalling Software In Ubuntu

The following commands can be used to remove packages from your system:

apt-get remove package_name – removes installation files while keeping the configuration data for a package.

apt-get autoremove – removes packages that were automatically installed because some other package required them.

dpkg -P package_name – To uninstall a specific configuration file of a program

apt-get purge package_name – removes everything related to a package including the configuration files

apt-get autoclean – remove files that can no longer be downloaded and are deemed useless

Ubuntu/Linux Networking Commands

Below are some of the most common Linux networking commands you should know.

ifconfig – Configures interface information on a Linux system

ip addr show – Shows an IP address or a list of IP addresses associated with an interface

ifup – Configures network interfaces on a Linux system

Managing Processes, Closing Programs, And System Resources Commands

Managing processes, closing programs, and system resources are some of the basic tasks that Linux users need to perform on a regular basis. There are various commands that can be used to accomplish these tasks.

killall – kill all running process

pkill – kill process by name

ps – show the running processes

ps -ef – show all running processes and their command line arguments

kill – terminate the specified process ID (PID)

pgrep – find all instances of a particular process name, including those without a terminal or any open files. This is useful for finding runaway background processes

Ubuntu Authentication/User Account Commands

There are a few commands you can use to manage user accounts and authentication in Ubuntu.

passwd – you can use to change a user’s password

passwd username

adduser – you can use to create a new user account

adduser username

deluser – you can use to delete an existing user account

deluser username

Frequently Asked Questions

What’s a working directory in Linux?

A working directory is a directory that contains the files that are currently in use by a process.

In Linux, it is the default location for storing temporary files and directories.

The working directory can be accessed using cd command or through the GUI of your Linux distribution.

How do you find the filename in Linux?

To find out the filename in Linux, you can use the following command:

ls -l

How do I search for a word in the Ubuntu terminal?

There are many ways to search for a word within the Ubuntu terminal, but two of the most common are grep and locate.

Locate searches for files and directories in your computer’s file system , while grep searches for files in your computer’s data directory.

Are Ubuntu Commands Case-sensitive?

Ubuntu commands are case-sensitive. The command “ls” is different from the command “Ls” and the command “ls -l” is different from the command “Ls -l”.

In Closing

Ubuntu is one of the most popular Linux operating systems and is used by many hosting providers and companies in production. It is also used on desktops and as a result, understanding the basic commands can help you immensely.

The post The Ultimate Guide to Ubuntu Commands for Beginners appeared first on Ian Kumu's Blog.

A Complete Beginner’s Guide on Linux Permissions

Ian Kumu — Thu, 11 Aug 2022 10:55:39 +0000

Linux is a Unix-like computer operating system assembled under the model of free and open-source software development and distribution. It is popular among developers and has seen some distros being preferred for programming across the board.

One of the key concepts in mastering Linux is understanding Linux Permissions.

What are Permissions in Linux?

Permissions are a set of rules that determine what a user is allowed to do with the files in Linux. These rules are set for each file and folder separately.

The three types of permissions are:

Read : allows users to view the contents of the file

Write : allows users to modify or delete the contents of the file

Execute : allows users to execute it as a program

The permission model is a mechanism to control access to files/directories in a process known as permission checking. When the permissions of an object need to be changed, they are changed according to the rules in the system.

Permissions are used when manipulating file contents , such as moving or deleting them, copying or renaming them, and viewing their content. Another use is when granting or denying apps permission to access data on the device, such as contacts, photos, and location.

The File Manager app requests permission before accessing the user’s entire device.

Why Should I Care about the Linux Permission Structure?

Permissions in Linux are a crucial part of it, they allow users to control who can access files on their computer.

They are based on three different types of users: the owner of the file , the group that owns the file , and other users.

To set permissions on a file, one must know which type of user they want to set them for. The owner of a file is able to read , write , and execute the file.

The group that owns the file is able to read and write the file. Other users have no control over the file other than being able to view it.

A user can be a member of more than one group. In this case, they must choose which group they want to set their file permissions for.

The owner of a file and the group that owns the file can change permissions on it later and all other users will have no effect on those changes.

Basic Commands for Linux File Permissions

This section provides a basic overview of the three commands that affect file permissions.

ls -List contents of a directory

The ls command can be used to list the contents of a directory and can take a directory name as an argument, or display what’s in the current working directory when there are no arguments specified.

ls

This command lists the contents in the current working directory.

ls command

ls -a

This command lists all the contents in the current working directory including hidden files.

ls -a command

ls -l

This command shows information about a directory including file permissions , the number of links , owner name , owner group , file size , time of last modification , and the file or directory name

ls -l command

chmod – Alter file permissions

To modify existing permissions on a file, use the chmod command with a plus or minus symbol before each letter to indicate whether you want to increase or decrease the permissions.

For example, chmod u+rwx filename changes file permissions so that others can read, write and execute while users in the group can only read. This sets the owner of the file to be the user where u is an arbitrary number and then sets all other permissions to 0 (no permissions). U = user who owns the file.

chmod +rwx filename

This command adds read, write and execute permissions to a file

chmod -rwx filename

This command removes read, write and execute permissions from a file

Note that “r” is for read, “w” is for write, and “x” is for execute.

chown – Change file ownership

chown is a command-line utility in Unix, Linux and other Os which changes the owner of a file.

It requires root privileges to assign ownership of any file other than the current user’s home directory.

The command-line syntax is chown [-R [-h] ] owner:newowner filename where filename is the name of the file that is to be changed in ownership.

The -R flag recursively changes all subdirectories and their files.The -h flag changes only the specified file’s owner without changing the group.

chown -R owner:newowner /path/to/directory

This command gives someone the ownership of the directory , and all files and subdirectories.

Advanced Commands for Linux File Permissions

In this part, I’ll discuss some of the less-known commands for working with file attributes.

chattr – Change Attributes of a File or Directory

By default, files in Linux are immutable. This means that once the file has been created, it cannot be changed. In order to change the attribute of a file or directory, you have to use the chattr command followed by a string or a set of strings.

Let’s take an example of the file / etc/passwd. if we run the command ls -l we can get the following output

-rw-r--r-- 1 root root 4096 Aug 8 11:36 /etc/passwd

To add attributes to a file we can use the chattr command

chattr +i /etc/passwd

we can verify the immutability using the lsattr command

lsattr
----i----------- ./etc/passwd

You can find more information on chattr in this article.

find – Search for Files in Linux

Finding files is easier than you think. Below are some quick tips to help you find and locate the files you need in the file system.

To locate files in the current folder with a specific extension:

find . -name "*.txt"

To list files with a specific name and their parent directory :

find . -name "my_file.txt" -print

If you want to search for a file that is in your current working directory :

find . -name "my file.txt"

You can learn more about find here.

lsattr – List Attribute of Files or Directories

lsattr is a command-line utility that lists the attributes of files/directories. The information listed below should be used as an example when using lsattr.

lsattr myfile.txt

touch – Update Timestamp on a File

touch is a command line utility for updating the access and modification times on one or more files or directories. This will update the access and modification times on all files in the current directory.

touch -a filename

This updates the access time of a file

touch -am -r directory

This will update the access and modification times on all files in the current directory recursively.

unlink – Delete a Directory or File

The unlink command is used to delete a directory or file from a file system. The original name of the directory/file will be deleted, along with any hard links that might have been created.

unlink /path/to/some-directory

How to Change Linux File & Folder Permissions on a Root or Standard User Account?

Permissions are set by using three different classifications: owner, group, and others.

The owner of a file is the person who created it. The group of a file is the people who have access to that file if it’s been shared with them. And others are everyone else who doesn’t fall into those two categories.

What is a group in Linux?

A group is a set of users who share permissions to files in a given directory. A user who belongs to the group can access these files, but cannot change their permissions or ownership.

How to reset permissions Linux

It is important to reset permissions on your Linux server so that it is secure. To do this, you need to log in as root and use the following command: chmod -R 777 /home/testuser The chmod command sets permissions on the given directory, making all files, subdirectories and directories read-only for the user and group testuser.

How to reset ownership in Linux

The root user is the default owner of all files and directories in a Linux system. When a user creates a file within a directory, they automatically become the owner of that file/directory. The root user can change the ownership of any file/directory by using the chown command. If you are logged in as root and you wish to reset ownership for all files and directories, you can use this command:

chown -R root: root *

This command will change the owner for all files and directories to root with a recursive option set.

What is a sticky bit permission in Linux?

A sticky bit permission is a permission that is set on a directory (or any file system object) that causes all new files created in the directory (or other objects) to inherit the permission.

The sticky bit permission is set by using the chmod command with a plus character (+) followed by an r, which sets the read and write permissions.

SUID permission in Linux

The Linux operating system assigns a unique identifier to every user. This identifier is called the user ID or UID. The Linux system also assigns a group ID (GID) to each account that is associated with it. SUID stands for Set User ID and it is an attribute of files in Unix-like OS that determines what operations the file’s owner can perform on the file versus what operations other users can perform on the file. A SUID program runs with the permissions of its owner rather than with those of its original (non-owner) user and group.

What Does chmod 775 Mean?

chmod 775 means that all users in the group can read, write, and execute a file.

What Does chmod 777 Mean?

chmod 777 means that read, write and execute access is granted to all users.

Conclusion

Linux permissions are the first thing to consider when looking at any Linux system. It is important to know what the permissions mean and what to do when they are not correct. Linux permissions can be a little tricky to wrap your head around, but once you know the basics, you’ll be able to use them to your advantage. I hope this guide was able to shed some light on some of the most important Linux permissions. If you enjoyed reading, you can read about the best Linux distros for programming. Thank you for reading.

The post A Complete Beginner’s Guide on Linux Permissions appeared first on Ian Kumu's Blog.

How To Configure Nginx as a Load Balancer

Ian Kumu — Sat, 06 Aug 2022 15:38:09 +0000

What is load balancing?

Load balancing involves effectively distributing incoming network traffic across a group of backend servers. A load balancer is tasked with distributing the load among the multiple backend servers that have been set up. There are multiple types of load balancers

Application Load balancer
Network Load Balancer
Gateway load balancer
Classic Load balancer

There are multiple load balancer examples and all have different use cases

Linux Virtual Server(LVS)

In this article, I am going to cover Nginx as a load balancer.

What Is Nginx Load Balancing?

Nginx is a high-performance web server which can also be used as a load balancer. Nginx load balancing refers to the process of distributing web traffic across multiple servers using Nginx.

This ensures that no single server is overloaded and that all requests are handled in a timely manner. Nginx uses a variety of algorithms to determine how to best distribute traffic, and it can also be configured to provide failover in case one of the servers goes down.

You can use either Nginx open source or Nginx Plus to load balance HTTP traffic to a group of servers.

Personally, I use Nginx open source to set up my load balancers and that is what I am going to show you in this article.

Advantages of load balancing

Load balancing helps in scaling an application by handling traffic spikes without increasing cloud costs. It also helps remove the problem of a single point of failure. Because the load is distributed, if one server crashes, the service would still be online.

Configuring Nginx as a load balancer

We can follow the steps to configure the Nginx load balancer.

Installing Nginx

The first step is to install Nginx. Nginx can be installed in Debian, Ubuntu or CentOS. I am going to use Ubuntu which I have configured on my Contabo VPS.

sudo apt-get update
sudo apt-get install nginx

Configure Nginx as a load balancer

The next step is to configure Nginx. We can create a new configuration file for the load balancer.

cd /etc/nginx/sites-available/
sudo nano default

http {
   upstream app{
      server 10.2.0.100; 
      server 10.2.0.101;
      server 10.2.0.102;
   }

   # This server accepts all traffic to port 80 and passes it to the upstream. 
   # Notice that the upstream name and the proxy_pass need to match.

   server {
      listen 80; 

      server_name mydomain.com;

      location / {
          include proxy_params;

          proxy_pass http://app;


          proxy_redirect off;
          proxy_http_version 1.1;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection "upgrade";
      }
   }
}

We will need to define the upstream directive and server directive in the file. Upstream defines where Nginx will pass the requests upon receiving them. It contains upstream server group (backend) IP addresses to which requests can be sent to based on the load balancing method chosen. By default, Nginx uses a round-robin load balancing method to distribute the load across the servers.

The server segment defines the port 80 through which Nginx will receive requests. It also contains a proxy_pass variable

The proxy_pass variable is used to tell NGINX where to send traffic that it receives. In this case, the proxy_pass variable is set to point to 3 servers. This tells NGINX to forward traffic that it receives to any of the upstream servers’ IPs provided. Nginx acts as both a reverse proxy and a load balancer.

A reverse proxy is a server that sits in between backend servers and intercepts requests from clients.

Selecting a load-balancing method

The next step is to determine the load balancing method to use. There are multiple load balancing methods we can use. They include:

Round Robin

Round Robin is a load balancing method where each server in a cluster is given an equal opportunity to process requests. This method is often used in web servers, where each server request is distributed evenly among the servers.

The load is distributed in rotation meaning that each server will have its time to execute a request. For example, if you have three upstream servers, A, B and C, then the load balancer will first distribute the load to A then to B and finally to C before redistributing the load to A. It is fairly simple and does have its fair share of imitations.

One of the limitations is that you will have some servers idle simply because they will be waiting for their turn. In this example, if A is given a task and executes it in a second, it would then mean it would be idle until it is next assigned a task. By default, Nginx uses round robin to distribute load among servers.

Weighted Round Robin

To solve the issue of server idleness , we can use server weights to instruct Nginx on which servers should be given the most priority. It is one of the most popular load balancing methods used today.

This method involves assigning a weight to each server and then distributing traffic among the servers based on these weights. This ensures that servers with more capacity receive more traffic, and helps to prevent overloading of any one server.

This method is often used in conjunction with other methods, such as session Persistence , to provide an even distribution of load across all servers. The application server with the highest weight parameter will be given priority(more traffic) as compared to the server with the least number(weight).

We can update the Nginx configuration to include the server weights

http {
   upstream app{
      server 10.2.0.100 weight=5; 
      server 10.2.0.101 weight=3;
      server 10.2.0.102 weight=1;
   }

  server {
      listen 80; 

      location / {
          proxy_pass http://app;
      }
   }
}

Least Connection

The least connection load balancing method is a popular technique used to distribute workloads evenly across a number of servers. The method works by routing each new connection request to the server with the fewest active connections. This ensures that all servers are used equally and that no single server is overloaded.

http {
   upstream app{
      least_conn;
      server 10.2.0.100; 
      server 10.2.0.101;
      server 10.2.0.102;
   }
   server {
      listen 80; 

      location / {
          proxy_pass http://app;
      }
   }
}

Weighted Least Connection

The Weighted Least Connection load balancing method is a technique used to distribute workloads across multiple computing resources, such as servers, in order to optimize performance and minimize response times. This technique takes into account the number of active connections each server has and assigns weights accordingly. The goal is to distribute the workload in a way that balances the load and minimizes response times.

http {
   upstream app{
      least_conn;
      server 10.2.0.100 weight=5; 
      server 10.2.0.101 weight=4;
      server 10.2.0.102 weight=1;
   }
   server {
      listen 80; 

      location / {
          proxy_pass http://app;
      }
   }
}

IP Hash

The IP Hash load balancing method uses a hashing algorithm to determine which server should receive each incoming packet. This is useful when multiple servers are behind a single IP address and you want to ensure that each packet from a given client IP address is routed to the same server. It takes the source IP address and destination IP address and creates a unique hash key. It is then used to allocate a client to a particular server.

This is very important in the case of canary deployments. It allows us as developers to roll out changes to a subsection of users so that they can test and provide feedback before shipping it out as a feature to all the users.

The advantage of this approach is that it can provide better performance than other methods, such as round-robin.

http {
   upstream app{
      ip_hash;
      server 10.2.0.100; 
      server 10.2.0.101;
      server 10.2.0.102;
   }
   server {
      listen 80; 

      location / {
          proxy_pass http://app;
      }
   }
}

URL Hash

URL Hash load balancing also uses a hashing algorithm to determine which server will receive each request based on the URL.

It is also similar to the Ip Hash load balancing method but the difference here is that we hash specific URLs as opposed to hashing IPs.This ensures that all requests are evenly distributed across the servers, providing improved performance and reliability.

Restart Nginx

Once you have configured the load balancer with the correct load balancing method, you can restart Nginx for the changes to take effect.

sudo systemctl restart nginx

Proxying HTTP traffic to a group of servers

A proxy server is a server that acts as an intermediary between a client and another server. A proxy server can be used to allow clients to access a group of servers, such as a group of web servers, by forwarding requests from the client to the appropriate server.

The proxy server can also provide caching, which can improve performance by reducing the need to send requests to the server for each page view. Nginx acts can act as a Forward proxy or a reverse proxy. The difference between a forward proxy and a reverse proxy is that a forward proxy sits in front of multiple clients and a reverse proxy sits in front of multiple backends.

A forward proxy protects the identity of the clients while a reverse proxy protects the identity of the backend servers.

Forward Proxy

Reverse Proxy

Load balancing with HTTPS enabled

Load balancing with HTTPS enabled is a great way to improve the performance of your website. By using a load balancer, you can distribute the load of your website across multiple servers, which can help to reduce the strain on any one server.

Additionally, by enabling HTTPS, you can ensure that all communications between the servers and visitors to your site are encrypted, which can help to keep your site safe and secure.

It does come with its fair share of problems. On problem is that for each request a TLS Handshake and a DNS lookup have to occur which might lead to delayed responses.

I personally have my backend application servers communicate with the load balancer using HTTP (SSL Termination) and the load balancer communicates with the clients through HTTPS. This way, there are no TLS Handshakes and DNS Lookups to be considered when routing requests to application servers.

Health checks

Load balancers are often used to distribute incoming traffic across a group of servers, in order to avoid overloading any single server. Health checks are a vital part of ensuring that the load balancer is able to correctly route traffic, as they can help to identify when a server is down or not functioning properly.

Nginx can monitor the health of our HTTP servers in an upstream group. Nginx can perform Passive Health checks and Active health checks.

Passive health checks

NGINX analyzes transactions as they take place and tries to restore failed connections for passive health checks. NGINX identify the server as unavailable and temporarily halt transmitting requests to it until it is deemed active again if the transaction still cannot be resumed.

For an upstream server to be marked as unavailable, we need to define two parameters in the upstream directive; failed_timeout and max_fails.

failed_timeout sets the time during which a number of failed attempts must happen for the server to be marked unavailable.

max_fails sets the number of failed attempts.

upstream app{
      server 10.2.0.100 max_fails=3 fail_timeout=60s; 
      server 10.2.0.101;
      server 10.2.0.102;
   }

Active Health Checks

NGINX can periodically check the health of upstream servers by sending special health‑check requests to each server and verifying the correct response.

server {
    location / {
        proxy_pass http://app;
        health_check;
    }
}

I have not used Active health checks as they seem to be applicable for Nginx Plus. You can read more on Active health checks here.

Self-managed load balancer vs. managed service

There are two main types of load balancers: self-managed and managed. Self-managed load balancers are usually less expensive, but require more technical expertise to set up and maintain. Managed load balancers are more expensive but often come with more features and support.

If you want to sleep well at night 😂 then managed load balancers are way better as they remove the headache of constantly debugging.

Limiting the number of connections

One way to improve the performance of a load balancer is to limit the number of connections that it tries to establish to each server. This can prevent the load balancer from overloading any one server and can help to ensure that each server has a fair share of the traffic.

Are Reverse Proxy and Load Balancer Similar?

Yes, reverse proxy and load balancer are similar in many ways. Both can be used to improve the performance and availability of a website or application. Both can also be used to distribute traffic among multiple servers.

Conclusion

Load balancing is a good way to distribute requests across application instances. It provides high availability and ensures server health is always high. Using the Nginx load balancer to distribute load is beneficial as it serves as both a reverse proxy and a load balancer. It is also open source and thus you can get more from Nginx. I hope this article was able to help you set up an Nginx load balancer. If you have any questions feel free to ask them in the comment section. Thank you for reading.

If you're interested in getting updated each time I publish a new article, feel free to sign up for my newsletter.

The post How To Configure Nginx as a Load Balancer appeared first on Ian Kumu's Blog.

12 Best Linux Distros For Programming in 2022

Ian Kumu — Sun, 24 Jul 2022 11:12:24 +0000

Linux is a Unix-like operating system that was originally created by Linus Torvalds. Linux is typically packaged in a Linux distribution. It is free and open source.

A Linux distribution (distro) is an operating system made from a software collection, which is based upon the Linux kernel and, often, a package management system. Distributions are used to bundle together all of the necessary software to run an operating system, including the kernel, libraries, utilities and applications.

There are many different distributions (“distros”) available, each with its own benefits and drawbacks. Some are better suited for certain tasks than others. In this article, we will take a look at 12 of the best Linux distros for developers.

Gnome is a popular desktop environment for Linux that is known for being user-friendly and easy to use. It is a good choice for beginners or those who are not familiar with the Linux kernel.

Distros that are based on Debian or Ubuntu (such as Mint, Elementary, and Zorin) are also good choices for developers as they are easy to set up and use. These distros come with a large number of pre-installed applications and drivers, making them ideal for those who want to get started with programming right away.

For more experienced developers and Linux enthusiasts, there are also a number of “minimal” distros that do not come with any pre-installed applications. These distros require the user to install and set up everything from scratch, which can be a good learning experience. However, it is important to note that these distros are not suitable for beginners.

What makes a good Linux distro for programming?

There are a few key things to look for in a good Linux distro for development and programming. Firstly, it should come with a good selection of pre-installed programming tools, development tools and languages. Secondly, it should have a relatively short release cycle , so that you can always be up-to-date with the latest versions of tools and languages. Lastly, it should be easy to install new software packages and updates.

How to choose the best Linux distro for you if you are a programmer?

Choosing the best Linux distro for your needs can be tricky. There are hundreds of Linux distributions available, and each has its own release cycle, programming language support, and desktop environment.

Fedora is a good choice for developers who want to stay on the bleeding edge of technology. Its release cycle is shorter than most other distros, so you’ll always have the latest and greatest software available. Ubuntu is a good choice for those who want a more stable release cycle. It’s also a good choice if you want to use a specific programming language, as there are many Ubuntu derivatives that cater to specific languages.

Ultimately, the best Linux distro for you is the one that meets your specific needs. If you’re not sure what those needs are, try out a few different distros and see which one feels right for you.

Why Is Choosing a Distro Important?

There are hundreds of distros available, so why is it important to choose the right one? For developers, choosing the right distro is important because it can make a big difference in terms of stability, security, and performance. A distro that is well-suited for development will come with the right tools pre-installed and will be easy to install new software on. Bleeding edge distros are great for developers who want to always have the latest and greatest software, but they can be more unstable. If you’re looking for a more stable development environment, you may want to choose a distro that lags behind the latest releases by a few months. Another factor to consider when choosing a popular distro is the package manager. Some package managers are better at handling dependencies than others. If you’re not sure which package manager to use, ask around or look for reviews online.

Why Is Linux Better for Developers and Programmers?

Linux is a great choice for programmers and developers for a number of reasons. First, it is an open-source operating system, which means that anyone can contribute to its development. Second, there are many different programming languages available for Linux, so you can choose the one that best suits your needs. Third, Linux distributions are available for a variety of different desktop environments, so you can find one that fits your workflow. Finally, Ubuntu is a popular Linux distribution that is easy to use and has a lot of support from the community.

Which Is The Best Linux Distributions For Programming 2022?

This is a list of the best Linux distributions for programming for various users.

1. Ubuntu (best for beginners)

Ubuntu is a great choice for beginner programmers and Linux newbies. It is a distro based on Debian and is easy to install and has a lot of online resources to help you get started. Plus, it is free! For programmers, the Ubuntu Long Term Support (LTS) release provides a stable development environment that they don’t need to upgrade every six months. If you are a beginner Linux user or new to the Linux ecosystem, then this is the best option for you. With Ubuntu, you will be up to speed in getting started with Linux commands and package managers. Many programming languages are supported and as a result, it is easy to adopt and a good choice for programming.

(Image Credit: Ubuntu)

2. Manjaro Linux (best for intermediate programmers)

Manjaro is a great choice for intermediate programmers. It is based on Arch Linux and has a lot of the same features, but is much easier to install and use. It is one of the best distros for intermediate developers or programmers. Combining all the power of Arch Linux, it suits beginners looking for an Arch alternate. Moreover, Manjaro comes in three editions GNOME, KDE, and XFCE. It also has its own repositories, so you don’t have to worry about using Arch User Repository(AUR).

(Image Credit: Distrowatch)

3. Arch Linux (best for advanced programmers)

Arch Linux is a great choice for advanced programmers. It is a very lightweight distribution that can be easily customized to your needs. The Arch User Repository (AUR) is a great resource for finding and installing software. The Arch community is very friendly and helpful, and there is a lot of documentation available. If you identify yourself as an advanced programmer or you want some challenge then go for arch Linux

(Image Credit: Linux Config)

4. Kali Linux (best for security researchers)

Kali Linux is a Debian-derived Linux distribution designed for digital forensics and penetration testing. It is maintained and funded by Offensive Security Ltd. The development team comprises more than 600 people, with a large community of contributors.

It’s the most popular choice for security programmers due to its vast collection of security-related tools. These tools can be used to test the security of systems and find vulnerabilities. Ethical hackers and security researchers frequently use Kali Linux to perform hack exploits on other systems. If you are looking for a Linux distro that will help you in penetration and security programming, then look no further. Developers, as well as security researchers, can gain a lot of benefits by using Kali Linux as their choice of Linux operating system

(Image Credit: Kali Linux)

5. Fedora (best for server programmers)

Fedora Workstation is a popular choice for server programmers due to its stability and wide range of software packages. It is also easy to customize and extend, making it a versatile platform for developing and deploying server applications.

(Image Credit: How to Geek)

6. openSUSE (best for system admins)

OpenSUSE is a great choice for system administrators and developers who want a stable and reliable operating system. It is one of the oldest Linux systems that was created in 1992. It is well-supported and comes with a wide range of tools and features that make it easy to administer a server.

(Image Credit: Wikipedia)

7. Raspberry Pi OS(best for education purposes)

Raspberry Pi OS(previously called Raspbian) is a Linux distro that is optimized for the Raspberry Pi hardware. Like Ubuntu or Linux Mint, it is also based on Debian. It is the official operating system for the Raspberry Pi and comes with a wide range of software that is suitable for education , programming , and general use. It provides a programming environment for Raspberry Pi software development.

(Image credit: Tom’s Hardware)

8. Drauger OS (best for game programmers)

Drauger OS is a great option for game programmers. It is based on Ubuntu, so it has all of the features and benefits that come with that operating system. It provides a good development platform for game programmers who are interested in Linux gaming. In addition, Drauger OS comes with a number of features specifically designed for game development, such as a custom kernel and support for Vulkan.

(Image Credit: Medium)

9. Zorin OS (best for windows based programmers)

Zorin OS is a great option for programmers coming from Windows or macOS. It’s based on Ubuntu, so it’s easy to use and familiar for anyone who’s used Windows before. Plus, it comes with all the tools you need to get started programming right away.

(Image Credit:Tecmint)

10. Gentoo/Sabayon Linux (best for customizations)

Gentooand Sabayon Linux are two of the most popular distros for customizations. They both offer a wide range of options and tools to customize your system. Gentoo is known for its flexibility and customizability, while Sabayon is known for its ease of use and user-friendly interface. Sabayon Linux is the best Linux distro for developers and system designers who want to customise the feel of their Linux operating system

Sabayon(Image Credit: Wikimedia)

11. Linux Mint (best for general purpose use)

Linux Mint is a great choice for general purpose use. It is based on Ubuntu, so it has all of the same features and benefits. It has some extra features that make it even more user-friendly. For example, it comes with pre-installed software that makes it easy to get started with using Linux.

(Image Credit: Wikimedia)

12. Android-x86 (best for Android programmers)

Android-x86 is an open-source project that aims to bring the Android operating system to x86-based PCs and laptops. It is a great choice for Android programmers who want to develop and test their apps on a desktop or laptop. The project provides a live and bootable ISO image that can be used to run Android on your PC.

(Image Credit: Wikipedia)

Is Ubuntu Best For Programming?

Yes, Ubuntu is best for programming because it is an open-source operating system that is popular among developers and supports most programming languages.

How can I become a Linux Pro?

There is no one-size-fits-all answer to this question, as the best way to become a Linux Pro may vary depending on your level of experience and expertise. However, some tips on how to become a Linux Pro include: studying and practising regularly , attending conferences and workshops, and networking with other Linux professionals. Additionally, it is important to stay up-to-date with the latest trends and developments in the Linux community to polish your Linux expertise.

Are there alternative Linux desktop options to consider?

Yes, there are alternative Linux desktop options to consider. For example, you could try the LXDE or Xfce desktop environments.

Why is Debian so Popular?

Debian is a very popular Linux distribution for several reasons. It is stable , well-supported , and has a large community of users and developers. Debian is also easy to install and use, and it comes with a wide range of software applications.

Which Linux distro does Linus Torvalds use?

Linus Torvalds uses Fedora as his main workstation

Is Fedora better than Debian?

There is no simple answer to this question as it depends on what you are looking for in an operating system. Fedora is a popular choice for those who want a stable and reliable system , while Debian is often preferred by those who want a more customizable experience. Ultimately, the best operating system for you is the one that meets your needs and preferences.

Do you prefer stability or bleeding-edge software?

I prefer stability. I like my software to work well and not have any glitches. I don’t mind if it’s not the newest version, as long as it’s stable.

Conclusion

There are many different Linux distributions available, and choosing the best one for programming can be a difficult task. However, I believe that the best Linux distro for programming is Ubuntu. Ubuntu is a popular distribution that is easy to use and comes with a wide range of features. It also has a large community of users and developers who can help you if you run into any problems. It is also widely used in servers and as a result, learning it can be a case of killing two birds with one stone. What Linux distro do you think is the best for programming?

The post 12 Best Linux Distros For Programming in 2022 appeared first on Ian Kumu's Blog.

Laravel Cache: How To Speed Up Your Load Time

Ian Kumu — Fri, 15 Jul 2022 09:05:58 +0000

Caching plays a vital role in optimizing the performance of a web application. According to this article, google engineers discovered that 400ms is long enough to cause users to leave a site. That’s how crucial load time affects bounce rates currently. Slow load speeds could affect conversion rates in e-commerce sites as Amazon stands to lose 1.6 billion in sales for every one second in load time.

Caching is an essential part of the software development process if you care about the scalability and performance of your application.

What is Laravel Caching?

Laravel provides a robust and easy-to-use implementation of caching and supports multiple caching backends. Through this support, you can switch between caching backends to suit your needs.

Cache Architecture

A cache hit occurs when data is available in cache memory and as a result, the application does not query the database. A cache miss, on the other hand, occurs when data is not present in the cache memory and as a result, the application has to query the database.

Laravel helps use model the same architecture using its inbuilt cache system.

Benefits of Caching

One of the benefits of caching is that it can reduce the workload on your application servers. For example, you can cache database queries, API responses and file contents thereby reducing server overheads.

Another benefit is that you can cache third-party API responses thereby reducing the chances of hitting a throttle limit or monthly request limit. For example, if your application is interacting with a third-party API say OpenWeatherMap API, instead of making a call to the OpenWeatherMap API each time, we can store the response in a cache and update it every 1 hour thereby reducing the number of requests made.

These are some of the benefits of caching.

Tradeoffs of Caching

Although caching has a lot of benefits, there are some drawbacks we need to be aware of. The first drawback is having outdated data in the cache. Let’s imagine we have some record stored in a cache with a time to live of 1 hour. In the event, that there is an update in the records, the cache may not be updated leading to outdated data being used as opposed to fresh data.

Another drawback is that it can be difficult to debug errors. It can be quite hard to detect points of failure in an application because records are stored in the cache. Let’s imagine we have a complex query to the database that does a lot of computations. Because we have a cache in place, we would not know about the complex query computation simply because the results might be cached and at surface level, the application might seem to be okay but deep down there are memory leaks that were shipped to production.

All in all, as much as there are drawbacks, the benefits outweigh the drawbacks and one would benefit massively from implementing caching in their application.

Configuration and Setup

Laravel comes already pre-configured to handle caching. It supports popular caching services such as Memcached, Redis, DynamoDBand the default relational database. Data can also be stored in a file.

Since Laravel supports multiple cache services, it uses driversto determine which cache service is in use. Some of the drivers are database , redis , memcached , database , dynamodb , file and array. Depending on your stack needs, you can use any of the drivers to suit your needs. For me, I use file driver in development and redis driver in production

Using Laravel Cache Commands

Laravel provides a Cache Facade that enables us to interact with our cache system. We can use the methods available in the Facade to add and remove data from the cache easily.

use Illuminate\Support\Facades\Cache;

Cache Methods

Cache::remember()

This method helps us retrieve data from the cache if it is present in the cache or store it if it is not present. It requires 3 parameters; the cache key , ttl(time to live) and a callback function. Cache Key is a unique string that will be used to retrieve data from the cache. TTL is the amount of time in seconds the data will be stored in the cache. The Callback function is a function that will be invoked in the case the cache is empty.

use Illuminate\Support\Facades\Cache;

Cache::remember('categories', now()->addHour(), function () {
    return Category::with('subcategories')->get();
});

In this case, we have a cache key of products, TTL of 1 hour(3600 seconds) and a callback function that queries the database in the case of a cache miss. A cache miss occurs when data is not present in the cache memory.

Cache::get()

This method retrieves items from the cache memory. In the event of a Cache miss, it returns null as the value.

use Illuminate\Support\Facades\Cache;

$categories= Cache::get('categories');

$categories= Cache::get('categories', 'default');

Cache::forget()

This method helps remove items from the cache. This is extremely useful when we want to update the cache records with new data.

use Illuminate\Support\Facades\Cache;

Cache::forget('categories');

Cache::has()

This method determines if an item exists in the cache. It returns true if it exists and false otherwise.

use Illuminate\Support\Facades\Cache;

if(Cache::has('categories')){
  //execute some code
}

Cache::put()

This method is used to store data in the cache memory.

use Illuminate\Support\Facades\Cache;

Cache::put('key', 'value', $seconds = 15);

Cache::put('key', 'value');

These are some of the useful Cache methods you will use in your day-to-day development. There are other methods present which you can find them here.

Using Laravel Cache Commands in Production

Now that we know the basic commands, we can use them in our production codebase. When an application is deployed to production, there are numerous things we need to factor in. The first one is speed. It is known that bad SQL query designs can cause memory leaks and lead to slow applications. One way we can avoid such issues is to introduce a cache system.

The Cache would sit in between our Laravel application and the database and would return data in the case of a cache hit or retrieve the data from the database and store it in memory in the case of a cache miss.

In Laravel, we can use the remember method to handle this for us. It will return cached data if it is present and store it in memory by retrieving the data from the database. This way, we are able to improve the speed of the application by reducing the number of queries made to the database.

The second thing we need to factor in is efficiency. If we are writing a REST API in Laravel, we would want to paginate our responses as we don’t want to return thousands of records in one response.

But how do we deal with paginated data in Cache?

It is actually pretty easy. We can paginate the results being fetched from the database. However, to store them in the cache, we would need to know which page’s results are stored so that when we retrieve the data we can return the results for the correct page.

To do so, we can append the cache key with the page number and thus have the results for the different pages stored differently in memory.

use Illuminate\Support\Facades\Cache;

public function index()
    {
        $currentPage = request()->get('page', 1);
        return Cache::remember('categories' . $currentPage, now()->addHour(), function () {
                return Categories::with('subcategories')->paginate(10);
            })
        );
    }

Update the Cache

One of the challenges in caching is updating the cache. It is challenging because it is hard to know when to update the cache, especially in production. Since we won’t be managing the cache manually, we would need a way to update the cache automatically.

Luckily, Laravel provides a way in which we can update the cache.

Now that we have data in the cache, we would want to update as soon as new data is available. This is where we would use the forget method. This would remove the data for a specific cache key from the memory. In development, this would not be an issue since we can just clear the cache once new data is available. This is not the case in production.

So how do we update the cache at scale?

This is where Model Observers come in handy. Observers listen to events on a given model and execute code based on the triggered events. For example, if a new record is added to the database, we would want the cache to be updated to have the new data.

We can drop the previous data that was in the cache memory and update it at the next get request.

To create an observer, we can use the make:observer Artisan command.

php artisan make:observer CategoriesObserver --model=Category

We then need to register the Observer in the AppServiceProvider boot method in the App\Providers\AppServiceProvider.php file.

use App\Models\Category;
use App\Observers\CategoriesObserver;

public function boot()
    {
        Category::observe(CategoriesObserver::class);
    }

We can now add the Cache::forget() logic in the observer.

<?php

namespace App\Observers;

use App\Models\Category;
use Illuminate\Support\Facades\Cache;

class CategoriesObserver
{
    /**
     * Handle the Category "created" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function created(Category $category)
    {
        Cache::forget('categories');
    }

    /**
     * Handle the Category "updated" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function updated(Category $category)
    {
        Cache::forget('categories');
    }

    /**
     * Handle the Category "deleted" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function deleted(Category $category)
    {
        Cache::forget('categories');
    }
}

This will remove the data based on certain events on a Model.

While this is a simple solution for a small application, it is definitely not a good one for a production-ready application. This is because, in production, you probably have paginated results. This is because the data stored in the cache contains the page number as part of the cache key.

So how do we update the cache with paginated results?

In this case, we would need to write a for loop that would remove all the data for all the cache keys for a model. I would first write a generic function in a trait through which I can use it anywhere in my codebase. Traits help us reuse our code in multiple classes. I will create a Traits folder in the app directory and create a ClearCache trait in the App\Traits folder

<?php

namespace App\Traits;

use Illuminate\Support\Facades\Cache;

trait ClearCache
{

    /**
     * This function is responsible for clearing the cache when a specific cache key is passed.
     * It is useful for paginated Resources that are cached
     * @param int $key The cache key index
     */
    public function clearCache($key)
    {
        for ($i = 1; $i <= 5000; $i++) {
            $newKey = $key . $i;
            if (Cache::has($newKey)) {
                Cache::forget($newKey);
            } else {
                break;
            }
        }
    }
}

With this, you are able to clear the cache and prepare the cache to be ready to store new data once it is available.

Now that we have the trait ready, we can update our Category Observer to use the trait.

<?php

namespace App\Observers;

use App\Models\Category;
use App\Traits\ClearCache;
use Illuminate\Support\Facades\Cache;

class CategoriesObserver
{
    use ClearCache;
    /**
     * Handle the Category "created" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function created(Category $category)
    {
        $this->clearCache('categories');
    }

    /**
     * Handle the Category "updated" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function updated(Category $category)
    {
        $this->clearCache('categories');
    }

    /**
     * Handle the Category "deleted" event.
     *
     * @param \App\Models\Category $category
     * @return void
     */
    public function deleted(Category $category)
    {
        $this->clearCache('categories');
    }
}

Observers listen to events that happen to one record only. For example, the updated method only executes if one record is updated. While this is good by design, there may exist some cases where you are executing updates on multiple records at the same time. In this case, the updated event would not fire and thus the cache would not be updated.

So how do we update the cache when multiple records are updated in the database?

In this case, we would need to just clear the cache manually. We can add the clearcache method from the trait in a controller after records have been updated. Though I would advise against it , this could be a workaround for that particular scenario.

Clear the Cache

To clear the cache, we can use the cache:cache Artisan command.

php artisan cache:clear

After implementing caching in my application, this was the major improvement I saw in my API requests.

Before Caching

After Caching

Conclusion

Caching helps improve the performance of an application. It does come with its fair share of challenges but the challenges are worth the effort as this can skyrocket your application to greater heights. I hope this article was able to shed some light on how to implement Laravel cache and some of the best practices. If you want to improve your application’s performance, you can read this article on Laravel Scheduling. Thank you for reading.

The post Laravel Cache: How To Speed Up Your Load Time appeared first on Ian Kumu's Blog.

Laravel Hide Id from URLs: A Simple Implementation

Ian Kumu — Sat, 18 Jun 2022 21:24:01 +0000

Introduction

Ever wondered how big services such as youtube tend to hide their ids in their URLs? I am sure you have seen how youtube masks the ids by showing a random string in the query string of a video URL. We also can mask and hide our database ids in Laravel thereby reducing any security risks that would arise in production.

Why hash ids?

There are multiple ways to hide/mask the ids in the URLs. The first way is by using UUIDs. UUIDs are Universally Unique Identifiers that can be used instead of the default incremental ids. Laravel comes with support for UUIDs. You can check this article on how to implement UUIDs in Laravel.

The second way is hashing the ids using a unique salt. This means that the salt can be set at the server level and have the ids hashed and returned to the frontend as unique strings.

In this article, I am going to hash ids using salt and return them as random encoded strings. To do so, I will use this package to accomplish that.

Installation

To start using it we can download the package using composer into our application

composer require vinkla/hashids

Configuration

The next step is to publish the configurations. We can use the vendor:publish command to do so.

php artisan vendor:publish --provider="Vinkla\Hashids\HashidsServiceProvider"

This will publish the config/hashids.php file which contains the package configurations. The file looks like this

There are a few things we need to change. As you can see the default connection has been set to main and as a result, we need to update the main connection for the package. The first thing we need to do is to uncomment the alphabet part. This is the set of strings the package will use to create a random hash for the database ids.

The next step is to define a salt. This is any additional data that will be used as input in hashing of the ids. By default it is empty so you can leave it as is or add anything. I am going to use my name as the salt.

The last thing is the length of the hash. This will determine the number of characters the random string will contain. I personally prefer using a hash of 4 characters.

'connections' => [

        'main' => [
            'salt' => 'Ian',
            'length' => 4,
            'alphabet' => 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
        ],

        'alternative' => [
            'salt' => 'your-salt-string',
            'length' => 'your-length-integer',
            // 'alphabet' => 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
        ],

    ],

With that, this is how the new file should look

Encoding Model Attributes.

Now that the package is all set, we can now start hashing the ids. I am going to create a new Blog model and its migration file

php artisan make:model Blog -mrc

The -mrc flag will instruct Laravel to generate a Blog Model, Its migration file and a Blog Controller that is resourceful(has all the relevant methods).

I will just add a simple database schema containing the id, title and body of the blog posts.

public function up()
    {
        Schema::create('blogs', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->longText('body');
            $table->timestamps();
        });
    }

The next step is to specify the mass assignable variables using the $fillable property.

We now need to mask the id attribute to contain the Hashed id. We can use the Eloquent Accessor to return a blog article’s id as a hashed string.

use Vinkla\Hashids\Facades\Hashids;
use Illuminate\Database\Eloquent\Casts\Attribute;
    /**
     * Hash the blog ids
     *
     * @return \Illuminate\Database\Eloquent\Casts\Attribute
     */
    protected function id(): Attribute
    {
        return Attribute::make(
            get: fn ($value) => Hashids::encode($value)
        );
    }

The encode method in the Hashids Facade creates a hash using the salt, alphabets and length we had specified in the config/hashids.php file.

Append Hashed ids to Routes

Once the accessor is set, it is now time to register a route for the blogs. We can use the resource method to register all the routes for the blog Resource in the routes/web.php file.

Route::resource('blog', BlogController::class);

This will return the URLs as http://localhost:8000/blog/QVyG as opposed to http://localhost:8000/blog/1.

Using the hashed ids in the controller

The next step is to use the hashed ids in the controller. We can use the decode function in the Hashids Facade to decode the hashed ids. To demonstrate this, I am going to use the default resourceful Controller methods and map them to their corresponding routes. The decode method returns an array of items so we will need to access the first index as seen in the consecutive methods below.

Index(/blog)

This method will retrieve all the records from the database and display them.

Create(/blog/create)

This method returns the view where we can add a blog post

We can now create blog posts normally through the store method.

Show(/blog/hashed_id)

This method decodes the hashed id and then returns the article from the database

use Vinkla\Hashids\Facades\Hashids;
public function show($blog)
    {
        $decoded_id = Hashids::decode($blog); //decode the hashed id
        $blog = Blog::find($decoded_id[0]);
        return view('show', compact('blog'));
    }

The article is accessible through http://127.0.0.1:8000/blog/Gbqw as opposed to http://127.0.0.1:8000/blog/1. We have masked the default blog id to a random string that can only be decoded at the server level thereby increasing the security of our application.

Edit(/blog/hashed_id/edit)

This method returns the edit view.

use Vinkla\Hashids\Facades\Hashids;
public function edit($blog)
    {
        $decoded_id = Hashids::decode($blog); //decode the hashed id
        $blog = Blog::find($decoded_id[0]);
        return view('edit', compact('blog'));
    }

Through the view, we can update an article through the update method. We would need to decode the hashed string before updating the article.

Delete(/blog/hashed_id)

We can use the same logic and decode the hashed string, getting the article and then deleting it.

use Vinkla\Hashids\Facades\Hashids;
public function destroy($blog)
    {
        $decoded_id = Hashids::decode($blog); //decode the hashed id
        $blog = Blog::find($decoded_id[0]);
        $blog->delete();
        return redirect()->route('blog.index')->with('success', 'Blog Post Deleted Successfully');
    }

Conclusion

In this article, you have learnt how to hide ids from URLs in Laravel using the Hashids package. There are multiple ways we can use the package to our advantage. Another example is hashing user ids in a system. This will return the user ids as hashed and an example of a URL could be http://localhost:8000/users/Gbqw which could be mapped to http://localhost:8000/users/1. I hope this article was able to shed some light on how to use the package. If you have any questions, feel free to ask them in the comment section. Thank you for reading.

The post Laravel Hide Id from URLs: A Simple Implementation appeared first on Ian Kumu's Blog.