DEV Community: Samson Ojugo

Automate Your Laravel Deployment on a VPS Using GitHub Actions: A Beginner's Guide

Samson Ojugo — Wed, 24 Sep 2025 22:27:49 +0000

Hey there, developers! 👋 I'm Ojugo Samson, a Lead Software Engineer, I build scalable solutions with PHP and Laravel.
Deploying code manually—logging into a server, pulling changes, running migrations—can be a hassle, especially for frequent updates. In this guide, I’ll show you how to automate deployments for your Laravel app on a Virtual Private Server (VPS) using GitHub Actions. This approach uses a secure SSH connection to trigger a deployment script on your server whenever you push to the main branch.

This tutorial is beginner-friendly, but I’ll assume you know the basics of Laravel, Git, and SSH. If you’re new to VPS, I recommend providers like DigitalOcean, Linode, or AWS Lightsail. Let’s get started!

Why Use GitHub Actions for Deployment?

Automation: Push to GitHub, and your server updates automatically.
Security: Store sensitive data like SSH keys in GitHub Secrets.
Flexibility: Customize workflows for testing, staging, or production.
Visibility: Track deployment status in GitHub’s Actions tab.

We’ll deploy a sample Laravel app (like my VerifyPlug project), but this works for any Laravel-based repo.

Prerequisites

Before we begin:

A GitHub repository with your Laravel project (e.g., on the main branch).
A VPS with Ubuntu (or similar Linux distro), PHP 8.3+, Composer, Git, and Laravel’s requirements installed.
Your Laravel app cloned and running on the VPS (e.g., in /var/www/your-app).
Nginx or Apache configured for your site.
Supervisor or similar for queue workers (if using queues).

If your VPS isn’t set up, check Laravel’s deployment docs for setup basics.

Step 1: Set Up SSH Keys for Secure Access

To let GitHub Actions connect to your VPS securely, generate an SSH key pair on your VPS and add the public key to GitHub Secrets.

SSH into your VPS:

   ssh youruser@your-vps-ip

Generate an SSH key pair (accept defaults or add a passphrase for extra security):

   ssh-keygen -t ed25519 -C "your_email@example.com"

This creates ~/.ssh/id_ed25519 (private key) and ~/.ssh/id_ed25519.pub (public key).

Add the public key to ~/.ssh/authorized_keys:

   cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys
   chmod 600 ~/.ssh/authorized_keys

Copy the private key for GitHub Secrets:

   cat ~/.ssh/id_ed25519

Save this securely—you’ll need it in Step 4.

Test SSH locally to ensure it works:

   ssh -i ~/.ssh/id_ed25519 youruser@your-vps-ip

Step 2: Clone Your Repository on the VPS (If Not Already Done)

Navigate to your web directory and clone your repo:

sudo mkdir -p /var/www/your-app
sudo chown -R $USER:www-data /var/www/your-app
cd /var/www/your-app
git clone git@github.com:yourusername/your-repo.git .

Replace your-app, yourusername, and your-repo with your details.

Install dependencies and configure:

composer install --optimize-autoloader --no-dev
cp .env.example .env
php artisan key:generate
php artisan migrate

Ensure your .env is set up with database credentials and other configs.

Step 3: Create the Deployment Script

We’ll create a deploy.sh script on the VPS to handle pulling code, updating dependencies, and restarting services.

In /var/www/your-app, create the script:

   nano deploy.sh

Add the following:

   #!/bin/bash
   set -e

   echo "Deployment started..."

   # Navigate to project directory
   cd /var/www/your-app

   # Enter maintenance mode (ignore if already down)
   (php artisan down --message "The app is being updated. Please try again in a minute.") || true

   # Pull the latest code from the main branch
   git fetch origin main
   git reset --hard origin/main

   # Install Composer dependencies
   composer install --no-dev --no-interaction --prefer-dist --optimize-autoloader

   # Clear and recreate caches
   php artisan cache:clear
   php artisan config:cache
   php artisan route:cache
   php artisan view:cache

   # Run database migrations
   php artisan migrate --force

   # Restart queue workers (if using database queue)
   php artisan queue:restart

   # Exit maintenance mode
   php artisan up

   # Reload PHP-FPM to update opcache (adjust version if needed)
   echo "" | sudo -S service php8.3-fpm reload

   echo "Deployment finished!"

Make it executable:

   chmod +x deploy.sh

Test it manually:

   ./deploy.sh

Fix any issues (e.g., permissions for www-data or PHP-FPM version).

This script handles maintenance mode, code updates, dependency installation, cache management, migrations, and service restarts.

Step 4: Set Up GitHub Actions Workflow

We’ll create a .github/workflows/deploy.yml file in your repository to automate the deployment.

In your local repo, create the directory and file:

   mkdir -p .github/workflows
   touch .github/workflows/deploy.yml

Add the following content:

   name: Deploy to Production
   on:
     push:
       branches:
         - main

   jobs:
     deploy:
       runs-on: ubuntu-latest
       steps:
         - name: Checkout Repository
           uses: actions/checkout@v3

         - name: Setup SSH
           uses: webfactory/ssh-agent@v0.5.4
           with:
             ssh-private-key: ${{ secrets.DEPLOY_SERVER_KEY }}

         - name: Deploy to VPS
           uses: appleboy/ssh-action@master
           with:
             host: ${{ secrets.DEPLOY_SERVER_IP }}
             username: ${{ secrets.DEPLOY_SERVER_USER }}
             key: ${{ secrets.DEPLOY_SERVER_KEY }}
             script: |
               cd ${{ secrets.DEPLOY_PATH }}
               ./deploy.sh

Commit and push:

   git add .github/workflows/deploy.yml
   git commit -m "Add GitHub Actions deployment workflow"
   git push origin main

This workflow triggers on pushes to main, checks out the code, sets up SSH, and runs deploy.sh on your VPS.

Step 5: Configure GitHub Secrets

To securely store sensitive data, add the following to your repo’s Settings > Secrets and variables > Actions > Secrets:

Go to your GitHub repo > Settings > Secrets and variables > Actions > New repository secret.
Add these secrets:
- DEPLOY_SERVER_KEY: The private SSH key from Step 1 (id_ed25519 content).
- DEPLOY_SERVER_IP: Your VPS IP address (e.g., 192.168.1.1).
- DEPLOY_SERVER_USER: Your VPS username (e.g., youruser).
- DEPLOY_PATH: The full path to your app (e.g., /var/www/your-app).

Step 6: Test the Deployment

Make a small change locally (e.g., update a view).
Commit and push to main:

   git commit -m "Test deployment"
   git push origin main

Go to your repo > Actions tab to monitor the workflow.
Check /var/www/your-app on the VPS to confirm updates. Debug using the Actions logs or by adding > deploy.log 2>&1 to the script step for output.

Common issues:

SSH errors: Verify the private key and authorized_keys setup.
Permissions: Ensure www-data has access to /var/www/your-app.
PHP-FPM version: Adjust the php8.3-fpm service name if using a different version.

Best Practices

Test First: Use a staging branch to test deployments.
Backups: Snapshot your VPS and database before migrations.
Monitoring: Use tools like Sentry for error tracking.
Zero-Downtime: For production, explore tools like Laravel Forge or Envoyer.
Security: Restrict SSH access to your GitHub Actions runner IP range.

This setup powers my projects like VerifyPlug, saving hours of manual work!

Wrapping Up

You’ve now automated your Laravel app’s deployment with GitHub Actions! Push to main, and your VPS updates seamlessly. If you hit issues, check the Actions logs or reach out on LinkedIn.

Happy coding! 🚀

Ojugo Samson

Lead Software Engineer @ Cargoplug | Techstars '24

LinkedIn: samsonojugo

GitHub: quitenoisemaker

Simplify Logistics with ShippingTracker v1.1.0 for Laravel

Samson Ojugo — Tue, 24 Jun 2025 16:00:41 +0000

As a Laravel developer passionate about e-commerce in Africa and Europe, I know logistics can be a headache. Couriers like Sendbox and Cargoplug use inconsistent APIs and webhook formats, making shipment tracking a chore. That’s why I built ShippingTracker v1.1.0, an open-source Laravel package to streamline logistics, and I’m excited to share it with you!

Why ShippingTracker?

ShippingTracker abstracts the mess of courier APIs, letting you focus on building great e-commerce apps. Here’s what it offers:

Easy Webhook Handling: Processes Sendbox and Cargoplug webhooks, saving tracking data (e.g., “delivered in Lagos”) with a clean event system.
Extensible: Add new providers (like DHL, planned for v1.2.1) without touching core code.
Laravel 9–12 Ready: Works across Laravel 9, 10, 11, and 12.
Beginner-Friendly: Simple setup with commands like composer install quitenoisemaker/shipping-tracker:^1.1`and a facade(ShippingTracker::use('sendbox')->track('101782511')).
Tested & Reliable: PHPUnit tests ensure webhook validation and provider switching work flawlessly.

Why It Matters

E-commerce is growing fast, but logistics remains tricky. ShippingTracker empowers devs to deliver real-time tracking to customers without API headaches, perfect for shops in Lagos or London.

Get Started

Install it in minutes:

` composer require quitenoisemaker/shipping-tracker:^1.1 php artisan vendor:publish --provider="Quitenoisemaker\ShippingTracker\ShippingTrackerServiceProvider" --tag=config `

Update config/shipping-tracker.php and .env with your courier credentials, run migrations, and you’re good to go! Check the GitHub repo for setup and webhook examples.

What’s Next?

I’m planning v1.2.1 with DHL support and more. Want a specific courier or feature? File an issue or PR on input shapes the future!

Try ShippingTracker today:

What’s your biggest logistics challenge in Laravel? Drop a comment below!

Laravel #PHP #Ecommerce #Logistics #OpenSource

Building a simple Referral System API with Laravel 11

Samson Ojugo — Tue, 28 May 2024 08:24:49 +0000

With the use of special referral codes, referral systems are an effective marketing technique that encourages current customers to promote business offerings. For those who are new to using Laravel 11 and want to handle user referrals through APIs, this tutorial will show you how to create a basic referral system API.

Let's get started.

Prerequisites:

Basic understanding of PHP, Laravel concepts, and RESTful APIs
A local development environment with Laravel 11 installed
A database (e.g., MySQL) configured with Laravel

Step 1: Project Setup and Modify the User Migration Schema

Create a new Laravel project using the Artisan command and navigate to the project directory. We'll need a table to store user information. Laravel provides a User model by default.

Go to the users migration and modify accordingly.

 Schema::create('users', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->rememberToken();
            $table->string('referral_code')->index()->unique();
            $table->unsignedBigInteger('referred_by')->nullable();
            $table->integer('referral_count')->default(0);
            $table->string('password');    
            $table->timestamps();

            $table->foreign('referred_by')->references('id')->on('users')->onUpdate('cascade')->onDelete('set null');
        });

Then run the php artisan migrate to run your migrations.

Step 2: Define API route

We'll create two main API endpoints to manage referrals:

POST /users - This endpoint will handle user registration and potentially generate a referral code for the new user.
GET /users/{user}/referrals - This endpoint will retrieve referral data for a specific user

Enable API routing using the install:api Artisan command and define the route in your routes/api.php file.

Note:

The install:api command installs Laravel Sanctum, which provides a robust, yet simple API token authentication guard which can be used to authenticate third-party API consumers, SPAs, or mobile applications. In addition, the install:api command creates the routes/api.php file: read more https://laravel.com/docs/11.x/routing.

Route::prefix('/users')->group(function () {
    Route::post('/', [UserReferralProgramController::class, 'store']);
    Route::get('/{user}/referrals', [UserReferralProgramController::class, 'fetchUserReferral']);
});

Consider using versioning in your API URL structure (e.g., /api/v1/users) to maintain flexibility for future changes. You may change the prefix by modifying your application's bootstrap/app.php file.

->withRouting(
        web: __DIR__ . '/../routes/web.php',
        api: __DIR__ . '/../routes/api.php',
        commands: __DIR__ . '/../routes/console.php',
        health: '/up',
        apiPrefix: 'api/v1',
    )

Step 3: Define Methods in your Controller

Run the command php artisan make:controller Api/UserReferralProgramController
Goto app\Http\Controllers\Api\UserReferralProgramController.php and define the methods. Later, we shall return to the controller.

class UserReferralProgramController extends Controller
{
    /**
     * Store a newly created resource in storage.
     */
    public function store(UserStoreRequest $request): void
    {
    }

    /**
     * fetch user referrals.
     */
    public function fetchUserReferral(User $user): void
    {
    }
}

Step 4: Utilize the service class(if applicable).

run the command php artisan make:class Service/ReferralCodeGenerator to create the class

<?php

namespace App\Service;

use App\Models\User;

class ReferralCodeGenerator
{
    /**
     * Generates a random referral code.
     *
     * This method generates a random string of specified length using the provided character set.
     * It then checks for existing codes in the database and regenerates if necessary.
     *
     * @return string The generated referral code.
     * 
     * @throws \Exception If an error occurs during code generation or validation.
     */
    public function generate(): string
    {
        $codeLength = 10;
        $characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
        $code = '';

        $code = substr(str_shuffle(str_repeat($characters, 5)), 0, $codeLength);

        return $this->checkAndRegenerate($code);
    }

    /**
     * Checks if a referral code already exists in the database and regenerates if necessary.
     *
     * This method takes a generated referral code as input and checks if it exists in the database.
     * If the code already exists, it regenerates a new code using the `generate` method and calls itself recursively to check again.
     * This process continues until a unique, non-existing code is found.
     *
     * @param string $code The referral code to be checked.
     * 
     * @return string A unique, non-existing referral code.
     * 
     */
    private function checkAndRegenerate(string $code): string
    {
        if (User::where('referral_code', $code)->exists()) {
            return $this->checkAndRegenerate($this->generate());
        }

        return $code;
    }

    /**
     * Finds a user by referral code and increments their referral count in a single database query.
     *
     * This method takes a referral code as input and attempts to find a matching user in the database.
     * If a user is found, it atomically increments their `referral_count` by 1 and retrieves the user's ID.
     * 
     * This method utilizes a single database query with Laravel's `update` method and raw expressions for efficiency.
     *
     * @param string $referralCode The referral code to be checked.
     * 
     * @return int|null The user ID if found, otherwise null.
     *
     */
    public function getUserIdByReferralCodeAndIncrementCount(string $referralCode): int|null
    {
        $userId = User::where('referral_code', $referralCode)->value('id');

        if ($userId) {
            $this->incrementReferralCount($userId);
            return $userId;
        }
        return null;
    }

    private function incrementReferralCount(int $userId): void
    {
        User::where('id', $userId)->increment('referral_count');
    }
}

Code Explanation:

The ReferralCodeGenerator class provides functionality to generate unique referral codes and manage user referral counts. Here's a summary:

generate Method: Creates a random 10-character referral code using a specified character set and ensures its uniqueness by checking against the database.
checkAndRegenerate Method: Recursively verifies the uniqueness of a referral code and regenerates it if necessary.
getUserIdByReferralCodeAndIncrementCount Method: Finds a user by referral code, increments their referral count atomically, and returns the user's ID.
incrementReferralCount Method: Increments the referral_count of a user by their ID.

This class ensures that generated referral codes are unique and facilitates updating user referral counts efficiently.

Step 8: Modify our existing Controller

Let’s go back to our controller app\Http\Controllers\Api\UserReferralProgramController.php and make some modifications.

class UserReferralProgramController extends Controller
{

    /**
     * Create a new class instance.
     */
    public function __construct(public ReferralCodeGenerator $referralCodeGenerator)
    {
        //
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(UserStoreRequest $request): JsonResponse
    {

        $validatedData = $request->validated();

        $referredBy = null;

        if ($request->has('referral_code')) {
            $referredBy = $this->referralCodeGenerator->getUserIdByReferralCodeAndIncrementCount($request->referral_code);
        }

        $requestData = array_merge(
            $validatedData,
            [
                'referred_by' => $referredBy,
                'referral_code' => $this->referralCodeGenerator->generate()
            ]
        );

        $user  = User::create($requestData);

        return response()->json([
            'message' => 'user created',
            'data' => $user
        ], Response::HTTP_CREATED);
    }

    /**
     * fetch user referrals.
     */
    public function fetchUserReferral(User $user): JsonResponse
    {
        $referrals = User::where('referred_by', $user->id)->get();

        return response()->json([
            'message' => 'success',
            'data' => [
                'referrals_count' => $user->referral_count,
                'referrals' => $referrals
            ]
        ], Response::HTTP_OK);
    }
}

In our controller method:

I Initialized the controller with a ReferralCodeGenerator instance, which is used for generating and validating referral codes.
Also validated the incoming request data (name, email, password, etc.).
If a referral_code parameter is present in the request, use it to find the referring user.
Created a new User model instance with the provided data and generated code.
Saved the user to the database and potentially update the referring user's referral count
Returned a successful response with relevant user information (excluding password) or an error response in case of validation issues or database errors.

Remember

This example has been simplified. Ensure that your system is production-ready by integrating strong authentication methods, Database transaction, resource to transform the result, extensive error handling, and extra features depending on your requirements.

Using Laravel 11, you can create a robust referral system API that facilitates user growth and acquisition for your application by following these instructions and experimenting with advanced features.

Test our Endpoint on POSTMAN

{{url}}/api/v1/users to store users

{{url}}/api/v1/users/:userId/referrals to fetch user referrals

You can get the complete code from https://github.com/quitenoisemaker/customer_incentive_programs

Creating a Laravel Artisan command that sends mail to all active users in the database.

Samson Ojugo — Wed, 24 May 2023 09:23:02 +0000

I’ll be guiding you through some fundamental artisan command creation implementations. Our objective is to develop an artisan command that sends email to every active user in the database.

Artisan is the command line interface included with Laravel. Artisan exists at the root of your application as the artisan script and provides a number of helpful commands that can assist you while you build your application.

Let's get started.

Step 1: Modify the User Migration Schema

I’m assuming that you just created a fresh Laravel application. Let’s add a new column to the user migration file, which Laravel has already produced.

Go to the users migration and modify accordingly.

Schema::create('users', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('email')->unique();
    $table->timestamp('email_verified_at')->nullable();
    $table->string('password');
    $table->boolean('is_active');
    $table->rememberToken();
    $table->timestamps();
});

I added the boolean column “is_active” which indicates whether the user’s account is active or inactive.

Then run the php artisan migrate to run your migrations.

Step 2: Generate fake user data and seed data

We will need to generate fake data for the user table. The UserFactory class is already created by Laravel upon installation.

Go to database\factories\UserFactory.php and make modifications to it. I will be adding the key-value pair ‘is_active’ =>fake()->boolean().

public function definition()
{
    return [
        'name' => fake()->name(),
        'email' => fake()->unique()->safeEmail(),
        'email_verified_at' => now(),
        'is_active' =>fake()->boolean(),//generate 1 or 0
        'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
        'remember_token' => Str::random(10),
    ];
}

Next, we go to the database\seeders\DatabaseSeeder.php and uncomment the following:

\App\Models\User::factory(10)->create();// add 10 records to the user table

Then we can run php artisan db:seed to seed our data.

Step 3: Generate a command and define appropriate values.

Create a new command by running

php artisan make:command SendMailToActiveUsers.

Go to the newly created command class, app/Console/Commands/SendMailToActiveUsers.php and define appropriate values for the signature and description properties of the class. These properties will be used when displaying your command on the list screen.

The signature property also allows you to define your command’s input expectations. Modify your signature and description properties.

protected $signature = 'send:active-user-mail';

/**
 * The console command description.
 *
 * @var string
 */
protected $description = 'Command sends mail to all active users';

Now you can view your newly created command by running the php artisan list command to view the list of all commands.

Step 4: Generate Mailables class

I will be generating Markdown Mailable. The Markdown mailable messages allow you to take advantage of the pre-built templates and components of mail notifications in your mailables. Run the command.

php artisan make:mail ActiveUser — markdown=emails.active-user

The command above will create the app/Mail/ActiveUser.php class and a blade file, resources/views/emails/active-user.blade.php.

Note: You can customize the blade template message with any text of your choice. Also configure Laravel’s email services via your application’s config/mail.php configuration file.

Step 4: Implement logic

First, I’ll place DB-related functionality into Eloquent models by defining the query constraints in the User model class using the Eloquent local scope. In app/Models/User.php, define the following method:

/**
 * Scope a query to only include active users.
 */
public function scopeActive($query): void
{
    $query->where('is_active', 1);
}

Second, I will implement my logic in the SendMailToActiveUsers class handle method (created in step 3).

Modify the handle method in app/Console/Commands/SendMailToActiveUsers.php to this

use App\Mail\ActiveUser;
use App\Models\User;


public function handle()
{
    $activeUsersEmail = User::active()->pluck('email');
    foreach ($activeUsersEmail as $user) {
        Mail::to($user)->send(new ActiveUser());
    }
    return Command::SUCCESS;
}

Explanation

The active scope methods were used when querying the user model. The pluck() method retrieves a collection of values from a single column of the database table, in this case, the email column of the active users. It returns a Laravel collection containing only the values of the email column of the active users.
Send individual emails in a loop by passing an instance of your mailable class to the send method

Note: There are a few ways to improve this technique so that fewer requests are made to your mail server. You can batch process the email sending procedure to send emails instead of sending each one one at a time in a loop. To outsource the email sending process, you may also think about leveraging Laravel’s queueing system.

Test
Run php artisan send:active-user-mail to send mail.

Code Documentation

Samson Ojugo — Wed, 10 May 2023 10:55:20 +0000

A DocBlock explains the purpose of a specific class, method, or other structural component. DocComments are a specific form of comment that always enclose DocBlocks. A DocComment is denoted by the characters /** (opener) and */ (closer).
There should be an asterisk (*) at the beginning of every line between the DocComment opener and its closer.

The phpdoc command can be used with phpDocumentor to provide comprehensive documentation for your Laravel project.

How effectively is your source code documented?

How to read data from an API and populate the database without duplicates in Laravel

Samson Ojugo — Thu, 04 May 2023 16:20:58 +0000

Today in this tutorial, you will learn how to read data from an External API and populate the database without duplicates in Laravel 8 applications. This tutorial assumes you are already familiar with basic Laravel implementations. I will be using a Public API that fetches entry records https://api.publicapis.org/entries. This API does not require a token for authorization.

Before getting started, you should ensure that you have installed the Guzzle package as a dependency of your application. By default, Laravel automatically includes this dependency. However, if you have previously removed the package, you may install it again via Composer.

Step 1: Create a model and migration

Generate a database migration when you generate the model with this command

php artisan make:model ApiEntry -m

Step 2: Define database Schema

Go to the migration file that was just created and define your database schema :

public function up()
    {
        Schema::create('api_entries', function (Blueprint $table) {
            $table->id();
            $table->string('api');
            $table->string('description');
            $table->string('auth')->nullable();
            $table->boolean('https');
            $table->string('cors');
            $table->string('link');
            $table->string('category');
            $table->timestamps();
    });
    }

Note: The column here is what I’m expecting from the external API I will be consuming.

Then run the php artisan migrate command to migrate your table

Step 3: Define the model attribute

You should define which model attributes you want to make mass assignable. You may do this using the $fillable property on the model.

Go to app\Models\ApiEntry.php

<?php

namespace App\Models;

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

class ApiEntry extends Model
{
    use HasFactory;

    protected $fillable = [
        'api',
        'description',
        'auth',
        'https',
        'cors',
        'link',
        'category'
    ];
}

Step 4: Define routes

Define your routes/web.php file. You can also define your route in routes/api.php (if you want to create an API route).

<?php

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

/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/
Route::get('/public/endpoint', [ApiEntryController::class, 'insertApiRecords']);

Step 5: Create a Controller

Create the ApiEntryController using the command

Php artisan make:controller ApiEntryController

Step 6: Implement logic
Here I choose to keep my controller skinny and the model thin. So I put my logic in a Service class and import it into the controller.

<?php
namespace App\Services\ReadDataApiService;
use App\Models\ApiEntry;
use Illuminate\Support\Facades\Http;

class ReadDataApi
{
    public function getApiEntry()
    {
        $url = "https://api.publicapis.org/entries";//assign API to a variable
        $response = Http::get(
            $url
        );
        $responseBodyClient = $response->json();
        $externalApiEntries = $responseBodyClient['entries'];

        foreach ($externalApiEntries as $externalApiEntry) {
            ApiEntry::updateOrInsert(
                [
                    'api' => $externalApiEntry['API'],
                    'description' => $externalApiEntry['Description'],
                    'link' => $externalApiEntry['Link'],
                    'category' => $externalApiEntry['Category'],
                ],
                [
                    'auth' => $externalApiEntry['Auth'],
                    'httpS' => $externalApiEntry['HTTPS'],
                    'cors' => $externalApiEntry['Cors'],
                ]
            );
        }
    }
}

Explanation

I created the file ReadDataApi.php - app/Services/ReadDataApiService/ReadDataApi.php
Assign the API URL to a variable $url.
I make a get request to the URL
Convert the response to a JSON format
I loop through the response and use the updateOrInsert method (I made sure to specify the unique attributes in the first parameter to ensure that there are no duplicates)

The updateOrInsert method will attempt to locate a matching database record using the first argument's column and value pairs. If the record exists, it will be updated with the values in the second argument. If the record can not be found, a new record will be inserted with the merged attributes of both arguments. Read more here.

Note: You can also use the firstOrCreate or UpdateOrCreate method. Also, make sure to specify the unique attributes in the first parameter to ensure that there are no duplicates.

Step 7: Import it into your controller

Go to app/Http/Controllers/ApiEntryController and use Controller dependency injection.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\ReadDataApiService\ReadDataApi;

class ApiEntryController extends Controller
{
    protected $readDataApi;

    public function __construct(ReadDataApi $readDataApi)
    {
        $this->readDataApi = $readDataApi;
    }

    public function insertApiRecords()
    {
        try {

            $this->readDataApi->getApiEntry();
        } catch (\Throwable $th) {
            return $th->getMessage();//you can also return you custom exception
        }
        return 'Operation Successful';//you can return a view or JSON
    }
}

Testing

Go to http://127.0.0.1:8000/public/endpoint to test your implementation. You can get the complete code from the Github repo

How to create Laravel middleware that only allows specific users.

Samson Ojugo — Sun, 30 Apr 2023 13:09:35 +0000

Today in this post, you will learn how to create middleware that allows specific users (emails) only in Laravel 8 applications.

Laravel middleware provide a convenient mechanism for inspecting and filtering HTTP requests entering your application. For example, Laravel includes a middleware that verifies the user of your application is authenticated. If the user is not authenticated, the middleware will redirect the user to your application’s login screen. However, if the user is authenticated, the middleware will allow the request to proceed further into the application.

Step1 :Create Helper function that return arrays of the specific users email

Let's create a function in our helper file that return arrays of specific user's email address. Go to in app\helpers.php and create the function

function usersThatCanAccessClientLogPage()
    {
        $userEmails = [
            "samadmin@example.com",
            "johndoe@example.com"
        ];
       return $userEmails;
  }

We will later call this function when implementing the logic in our middleware.

Step 2 :Create Middleware:

Lets assume there is a page for Client logs and only certain email can access that page

Open the terminal and execute the following command to create custom middleware in Laravel 8. So let’s open our command prompt and execute below command:

php artisan make:middleware CheckClientDownloadPage

This command will create a new CheckClientDownloadPage class within your app/Http/Middleware directory

After successfully creating your middleware, go to app/http/kernel.php and register your custom middleware here :

//Register your CheckClientDownloadPage middleware and import the class
protected $routeMiddleware = [
    'auth' => \App\Http\Middleware\Authenticate::class,
    'auth.basic' => \Illuminate\Auth\Middleware\AuthenticateWithBasicAuth::class,
    'bindings' => \Illuminate\Routing\Middleware\SubstituteBindings::class,
    'cache.headers' => \Illuminate\Http\Middleware\SetCacheHeaders::class,
    'can' => \Illuminate\Auth\Middleware\Authorize::class,
    'guest' => \App\Http\Middleware\RedirectIfAuthenticated::class,
    'signed' => \Illuminate\Routing\Middleware\ValidateSignature::class,
    'throttle' => \Illuminate\Routing\Middleware\ThrottleRequests::class,
    'verified' => \Illuminate\Auth\Middleware\EnsureEmailIsVerified::class,
    'client.log' => CheckClientDownloadPage::class,
];

Step 3: Implement Logic In Middleware:

After successfully registering your middleware in app/http/kernel.php, go to app/Http/Middleware/CheckClientDownloadPage.php and implement your logic here :

app/Http/Middleware/CheckClientDownloadPage.php

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Support\Facades\Auth;

class CheckClientDownloadPage
{
    /**
     * Handle an incoming request.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
     */
    public function handle($request, Closure $next)
    {
        $loginUser = Auth::user(); // Get the currently authenticated user...
        if (Auth::check()) {
          // The user is logged in...
            if (in_array($loginUser->email, usersThatCanAccessClientLogPage())) {
                return $next($request);
            }
            return redirect('/user/admin/dashboard');
        }
        return redirect('/login');
    }
}

Step 4:Add Route

Simply create a Laravel route and use custom middleware with routes to filter every HTTP request:

routes/web.php

//Route group for route that uses the middleware
Route::middleware(['client.log'])->group(function () {
//add your route here
});

Thanks