A practical implementation-level example for building a modular monolith using clean architecture in Laravel/PHP.

This document is written to be shared with engineers who want a concrete reference for structuring modules, separating business logic from frameworks, and keeping inter-module boundaries clean.

1. Goal

This architecture aims to achieve:

• one deployable application
• multiple business modules
• clear code ownership per module
• framework-independent domain logic
• controlled communication between modules

This is a modular monolith, not microservices.

That means:

• one Laravel application
• one deployment unit
• usually one database
• modules separated by code boundaries, not network boundaries

2. Core Architecture Rules

Rule 1: Keep business logic away from Laravel details

Business rules should not depend directly on:

• controllers
• requests
• Eloquent models
• facades
• route files

Rule 2: Modules talk through contracts

A module should not directly use another module's internal database models or repositories.

Use:

• interfaces
• gateways
• application contracts
• domain events when needed

Rule 3: Dependency direction goes inward

Presentation -> Application -> Domain
Infrastructure -> Application / Domain

The domain should be the most stable and framework-independent part.

3. Example Business Flow

We will model this use case:

Place Order Flow:

1. User sends an order request
2. Orders module validates input
3. Orders use case builds the order
4. Orders asks Inventory to reserve stock
5. Inventory checks and decrements stock
6. Orders saves the order
7. API returns the created order

4. Suggested Folder Structure

app/
  Modules/
    Orders/
      Domain/
        Entities/
          Order.php
          OrderItem.php
        Repositories/
          OrderRepositoryInterface.php
        Services/
          InventoryGatewayInterface.php
        Exceptions/
          InsufficientStockException.php

      Application/
        DTOs/
          PlaceOrderCommand.php
        UseCases/
          PlaceOrder.php

      Infrastructure/
        Persistence/
          Eloquent/
            Models/
              OrderModel.php
              OrderItemModel.php
            Repositories/
              EloquentOrderRepository.php
        Providers/
          OrdersServiceProvider.php

      Presentation/
        Http/
          Controllers/
            OrderController.php
          Requests/
            PlaceOrderRequest.php
          Resources/
            OrderResource.php
        Routes/
          api.php

      Database/
        Migrations/
          2026_03_29_000001_create_orders_table.php
          2026_03_29_000002_create_order_items_table.php
        Factories/
        Seeders/

    Inventory/
      Domain/
        Repositories/
          ProductStockRepositoryInterface.php

      Application/
        Services/
          ReserveStockService.php

      Infrastructure/
        Persistence/
          Eloquent/
            Models/
              ProductStockModel.php
            Repositories/
              EloquentProductStockRepository.php
        Services/
          StockReservationService.php
        Providers/
          InventoryServiceProvider.php

      Database/
        Migrations/
          2026_03_29_000003_create_product_stocks_table.php

    Shared/
      Domain/
        ValueObjects/
          Money.php
      Application/
        Contracts/
          ClockInterface.php

5. What Each Layer Does

Domain

Contains pure business concepts and rules.

Examples:

• entities
• value objects
• repository interfaces
• business exceptions
• gateway contracts

Domain should not know Laravel exists.

Application

Contains use cases.

Examples:

• PlaceOrder
• CancelOrder
• RefundPayment

Application orchestrates business flow using domain contracts.

Infrastructure

Contains Laravel and persistence details.

Examples:

• Eloquent models
• repository implementations
• service provider bindings
• adapter implementations

Presentation

Contains delivery-layer code.

Examples:

• controllers
• form requests
• API resources
• routes

6. Orders Module Implementation

6.1 Domain Entity: Order

<?php

namespace App\Modules\Orders\Domain\Entities;

class Order
{
    private ?int $id;
    private int $userId;
    private string $status;

    /** @var OrderItem[] */
    private array $items = [];

    public function __construct(?int \(id, int \)userId, array \(items, string \)status = 'pending')
    {
        \(this->id = \)id;
        \(this->userId = \)userId;
        \(this->items = \)items;
        \(this->status = \)status;
    }

    public static function create(int \(userId, array \)items): self
    {
        if (empty($items)) {
            throw new \InvalidArgumentException('Order must have at least one item.');
        }

        return new self(
            id: null,
            userId: $userId,
            items: $items,
            status: 'pending',
        );
    }

    public function confirm(): void
    {
        $this->status = 'confirmed';
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function setId(int $id): void
    {
        \(this->id = \)id;
    }

    public function getUserId(): int
    {
        return $this->userId;
    }

    public function getStatus(): string
    {
        return $this->status;
    }

    /** @return OrderItem[] */
    public function getItems(): array
    {
        return $this->items;
    }
}

6.2 Domain Entity: OrderItem

<?php

namespace App\Modules\Orders\Domain\Entities;

class OrderItem
{
    public function __construct(
        private int $productId,
        private int $quantity,
        private int $unitPrice,
    ) {
        if ($quantity < 1) {
            throw new \InvalidArgumentException('Quantity must be at least 1.');
        }
    }

    public function getProductId(): int
    {
        return $this->productId;
    }

    public function getQuantity(): int
    {
        return $this->quantity;
    }

    public function getUnitPrice(): int
    {
        return $this->unitPrice;
    }

    public function getSubtotal(): int
    {
        return \(this->quantity * \)this->unitPrice;
    }
}

6.3 Repository Contract

<?php

namespace App\Modules\Orders\Domain\Repositories;

use App\Modules\Orders\Domain\Entities\Order;

interface OrderRepositoryInterface
{
    public function save(Order $order): Order;

    public function findById(int $id): ?Order;
}

6.4 Cross-Module Contract: Inventory Gateway

Orders should not directly use Inventory Eloquent models.

Instead, it depends on an abstraction.

<?php

namespace App\Modules\Orders\Domain\Services;

interface InventoryGatewayInterface
{
    /**
     * @param array<int, array{product_id:int, quantity:int}> $items
     */
    public function reserve(array $items): void;
}

7. Orders Application Layer

7.1 Command DTO

<?php

namespace App\Modules\Orders\Application\DTOs;

class PlaceOrderCommand
{
    /**
     * @param array<int, array{product_id:int, quantity:int, unit_price:int}> $items
     */
    public function __construct(
        public readonly int $userId,
        public readonly array $items,
    ) {}
}

7.2 Use Case: PlaceOrder

<?php

namespace App\Modules\Orders\Application\UseCases;

use App\Modules\Orders\Application\DTOs\PlaceOrderCommand;
use App\Modules\Orders\Domain\Entities\Order;
use App\Modules\Orders\Domain\Entities\OrderItem;
use App\Modules\Orders\Domain\Repositories\OrderRepositoryInterface;
use App\Modules\Orders\Domain\Services\InventoryGatewayInterface;

class PlaceOrder
{
    public function __construct(
        private OrderRepositoryInterface $orders,
        private InventoryGatewayInterface $inventoryGateway,
    ) {}

    public function execute(PlaceOrderCommand $command): Order
    {
        $items = array_map(
            fn (array $item) => new OrderItem(
                productId: $item['product_id'],
                quantity: $item['quantity'],
                unitPrice: $item['unit_price'],
            ),
            $command->items
        );

        $order = Order::create(
            userId: $command->userId,
            items: $items,
        );

        $reservationItems = array_map(
            fn (OrderItem $item) => [
                'product_id' => $item->getProductId(),
                'quantity' => $item->getQuantity(),
            ],
            $items
        );

        \(this->inventoryGateway->reserve(\)reservationItems);

        $order->confirm();

        return \(this->orders->save(\)order);
    }
}

Why this is clean

This use case knows nothing about:

• HTTP request objects
• controllers
• Eloquent
• facades
• route definitions

It only works with domain entities and contracts.

8. Inventory Module Implementation

8.1 Inventory Repository Contract

<?php

namespace App\Modules\Inventory\Domain\Repositories;

interface ProductStockRepositoryInterface
{
    public function getAvailableQuantity(int $productId): int;

    public function decrement(int \(productId, int \)quantity): void;
}

8.2 Application Service: ReserveStockService

<?php

namespace App\Modules\Inventory\Application\Services;

use App\Modules\Inventory\Domain\Repositories\ProductStockRepositoryInterface;

class ReserveStockService
{
    public function __construct(
        private ProductStockRepositoryInterface $stocks,
    ) {}

    /**
     * @param array<int, array{product_id:int, quantity:int}> $items
     */
    public function execute(array $items): void
    {
        foreach (\(items as \)item) {
            \(available = \)this->stocks->getAvailableQuantity($item['product_id']);

            if (\(available < \)item['quantity']) {
                throw new \RuntimeException(
                    "Insufficient stock for product {$item['product_id']}"
                );
            }
        }

        foreach (\(items as \)item) {
            \(this->stocks->decrement(\)item['product_id'], $item['quantity']);
        }
    }
}

8.3 Adapter Exposed to Orders

Inventory implements the contract that Orders depends on.

<?php

namespace App\Modules\Inventory\Infrastructure\Services;

use App\Modules\Inventory\Application\Services\ReserveStockService;
use App\Modules\Orders\Domain\Services\InventoryGatewayInterface;

class StockReservationService implements InventoryGatewayInterface
{
    public function __construct(
        private ReserveStockService $reserveStockService,
    ) {}

    public function reserve(array $items): void
    {
        \(this->reserveStockService->execute(\)items);
    }
}

This is the clean boundary between modules.

9. Infrastructure Layer

9.1 Eloquent Models

<?php

namespace App\Modules\Orders\Infrastructure\Persistence\Eloquent\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class OrderModel extends Model
{
    protected $table = 'orders';

    protected $fillable = [
        'user_id',
        'status',
    ];

    public function items(): HasMany
    {
        return $this->hasMany(OrderItemModel::class, 'order_id');
    }
}

<?php

namespace App\Modules\Orders\Infrastructure\Persistence\Eloquent\Models;

use Illuminate\Database\Eloquent\Model;

class OrderItemModel extends Model
{
    protected $table = 'order_items';

    protected $fillable = [
        'order_id',
        'product_id',
        'quantity',
        'unit_price',
    ];
}

9.2 Repository Implementation

<?php

namespace App\Modules\Orders\Infrastructure\Persistence\Eloquent\Repositories;

use App\Modules\Orders\Domain\Entities\Order;
use App\Modules\Orders\Domain\Entities\OrderItem;
use App\Modules\Orders\Domain\Repositories\OrderRepositoryInterface;
use App\Modules\Orders\Infrastructure\Persistence\Eloquent\Models\OrderItemModel;
use App\Modules\Orders\Infrastructure\Persistence\Eloquent\Models\OrderModel;
use Illuminate\Support\Facades\DB;

class EloquentOrderRepository implements OrderRepositoryInterface
{
    public function save(Order $order): Order
    {
        return DB::transaction(function () use ($order) {
            $orderModel = OrderModel::create([
                'user_id' => $order->getUserId(),
                'status' => $order->getStatus(),
            ]);

            foreach (\(order->getItems() as \)item) {
                OrderItemModel::create([
                    'order_id' => $orderModel->id,
                    'product_id' => $item->getProductId(),
                    'quantity' => $item->getQuantity(),
                    'unit_price' => $item->getUnitPrice(),
                ]);
            }

            return new Order(
                id: $orderModel->id,
                userId: $orderModel->user_id,
                items: array_map(
                    fn ($item) => new OrderItem(
                        productId: $item->product_id,
                        quantity: $item->quantity,
                        unitPrice: $item->unit_price,
                    ),
                    $orderModel->items()->get()->all()
                ),
                status: $orderModel->status,
            );
        });
    }

    public function findById(int $id): ?Order
    {
        \(model = OrderModel::with('items')->find(\)id);

        if (! $model) {
            return null;
        }

        return new Order(
            id: $model->id,
            userId: $model->user_id,
            items: array_map(
                fn ($item) => new OrderItem(
                    productId: $item->product_id,
                    quantity: $item->quantity,
                    unitPrice: $item->unit_price,
                ),
                $model->items->all()
            ),
            status: $model->status,
        );
    }
}

9.3 Inventory Stock Repository

<?php

namespace App\Modules\Inventory\Infrastructure\Persistence\Eloquent\Repositories;

use App\Modules\Inventory\Domain\Repositories\ProductStockRepositoryInterface;
use App\Modules\Inventory\Infrastructure\Persistence\Eloquent\Models\ProductStockModel;

class EloquentProductStockRepository implements ProductStockRepositoryInterface
{
    public function getAvailableQuantity(int $productId): int
    {
        \(stock = ProductStockModel::where('product_id', \)productId)->first();

        return $stock?->available_quantity ?? 0;
    }

    public function decrement(int \(productId, int \)quantity): void
    {
        \(stock = ProductStockModel::where('product_id', \)productId)->firstOrFail();

        \(stock->decrement('available_quantity', \)quantity);
    }
}

10. Presentation Layer

10.1 Request Validation

<?php

namespace App\Modules\Orders\Presentation\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class PlaceOrderRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true;
    }

    public function rules(): array
    {
        return [
            'user_id' => ['required', 'integer'],
            'items' => ['required', 'array', 'min:1'],
            'items.*.product_id' => ['required', 'integer'],
            'items.*.quantity' => ['required', 'integer', 'min:1'],
            'items.*.unit_price' => ['required', 'integer', 'min:1'],
        ];
    }
}

10.2 Controller

<?php

namespace App\Modules\Orders\Presentation\Http\Controllers;

use App\Http\Controllers\Controller;
use App\Modules\Orders\Application\DTOs\PlaceOrderCommand;
use App\Modules\Orders\Application\UseCases\PlaceOrder;
use App\Modules\Orders\Presentation\Http\Requests\PlaceOrderRequest;
use App\Modules\Orders\Presentation\Http\Resources\OrderResource;
use Illuminate\Http\JsonResponse;

class OrderController extends Controller
{
    public function store(
        PlaceOrderRequest $request,
        PlaceOrder $placeOrder,
    ): JsonResponse {
        $command = new PlaceOrderCommand(
            userId: $request->integer('user_id'),
            items: $request->input('items'),
        );

        \(order = \)placeOrder->execute($command);

        return response()->json([
            'data' => (new OrderResource(\(order))->toArray(\)request),
        ], 201);
    }
}

10.3 Resource

<?php

namespace App\Modules\Orders\Presentation\Http\Resources;

use App\Modules\Orders\Domain\Entities\Order;
use App\Modules\Orders\Domain\Entities\OrderItem;

class OrderResource
{
    public function __construct(
        private Order $order
    ) {}

    public function toArray($request): array
    {
        return [
            'id' => $this->order->getId(),
            'user_id' => $this->order->getUserId(),
            'status' => $this->order->getStatus(),
            'items' => array_map(
                fn (OrderItem $item) => [
                    'product_id' => $item->getProductId(),
                    'quantity' => $item->getQuantity(),
                    'unit_price' => $item->getUnitPrice(),
                    'subtotal' => $item->getSubtotal(),
                ],
                $this->order->getItems()
            ),
        ];
    }
}

10.4 Module Route File

<?php

use Illuminate\Support\Facades\Route;
use App\Modules\Orders\Presentation\Http\Controllers\OrderController;

Route::prefix('orders')->group(function () {
    Route::post('/', [OrderController::class, 'store']);
});

11. Service Providers and Dependency Injection

11.1 Orders Service Provider

<?php

namespace App\Modules\Orders\Infrastructure\Providers;

use Illuminate\Support\ServiceProvider;
use App\Modules\Orders\Domain\Repositories\OrderRepositoryInterface;
use App\Modules\Orders\Domain\Services\InventoryGatewayInterface;
use App\Modules\Orders\Infrastructure\Persistence\Eloquent\Repositories\EloquentOrderRepository;
use App\Modules\Inventory\Infrastructure\Services\StockReservationService;

class OrdersServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(OrderRepositoryInterface::class, EloquentOrderRepository::class);
        $this->app->bind(InventoryGatewayInterface::class, StockReservationService::class);
    }

    public function boot(): void
    {
        $this->loadRoutesFrom(app_path('Modules/Orders/Presentation/Routes/api.php'));
        $this->loadMigrationsFrom(app_path('Modules/Orders/Database/Migrations'));
    }
}

11.2 Inventory Service Provider

<?php

namespace App\Modules\Inventory\Infrastructure\Providers;

use Illuminate\Support\ServiceProvider;
use App\Modules\Inventory\Domain\Repositories\ProductStockRepositoryInterface;
use App\Modules\Inventory\Infrastructure\Persistence\Eloquent\Repositories\EloquentProductStockRepository;

class InventoryServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->bind(
            ProductStockRepositoryInterface::class,
            EloquentProductStockRepository::class
        );
    }

    public function boot(): void
    {
        $this->loadMigrationsFrom(app_path('Modules/Inventory/Database/Migrations'));
    }
}

Why this matters

This is what makes the architecture real:

• the use case depends on interfaces
• the container provides implementations
• modules remain replaceable behind contracts

12. Database Migrations

12.1 Orders Table

<?php

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

return new class extends Migration {
    public function up(): void
    {
        Schema::create('orders', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->string('status');
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('orders');
    }
};

12.2 Order Items Table

<?php

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

return new class extends Migration {
    public function up(): void
    {
        Schema::create('order_items', function (Blueprint $table) {
            $table->id();
            $table->foreignId('order_id')->constrained('orders')->cascadeOnDelete();
            $table->unsignedBigInteger('product_id');
            $table->integer('quantity');
            $table->integer('unit_price');
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('order_items');
    }
};

12.3 Product Stocks Table

<?php

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

return new class extends Migration {
    public function up(): void
    {
        Schema::create('product_stocks', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('product_id')->unique();
            $table->integer('available_quantity')->default(0);
            $table->timestamps();
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('product_stocks');
    }
};

13. Shared Folder: What It Is For

The Shared folder is for things that are:

• generic
• reusable across modules
• not owned by one business module

Good examples:

• Money
• Email
• ClockInterface
• IdGeneratorInterface

Bad examples:

• OrderHelper
• BillingCommon
• InventoryUtils
• feature-specific services moved to shared just because two modules use them

Example Shared Value Object

<?php

namespace App\Modules\Shared\Domain\ValueObjects;

final class Money
{
    public function __construct(
        private int $amount,
        private string $currency = 'USD'
    ) {}

    public function add(Money $other): Money
    {
        if (\(this->currency !== \)other->currency) {
            throw new \InvalidArgumentException('Currency mismatch');
        }

        return new Money(\(this->amount + \)other->amount, $this->currency);
    }

    public function amount(): int
    {
        return $this->amount;
    }

    public function currency(): string
    {
        return $this->currency;
    }
}

14. Request Flow Summary

For POST /orders:

1. OrderController receives the request
2. PlaceOrderRequest validates input
3. Controller creates PlaceOrderCommand
4. PlaceOrder use case executes
5. Use case builds domain Order and OrderItem
6. Use case calls InventoryGatewayInterface
7. Laravel resolves it to StockReservationService
8. Inventory reserves stock
9. Orders repository persists the order
10. Resource returns JSON response

This is a modular monolith because the whole flow runs inside one Laravel app.

This is clean architecture because the business flow does not depend on framework details.

15. What Not to Do

Bad: Use Eloquent directly in the use case

$order = OrderModel::create([...]);

This makes the application layer depend on Laravel ORM.

Bad: Access another module's internal models

ProductStockModel::where('product_id', $id)->decrement(...);

This breaks module boundaries because Orders is now touching Inventory internals.

Bad: Put business logic in controllers

foreach (\(request->items as \)item) {
    // reserve stock
    // calculate total
    // create order
}

Controllers should adapt HTTP, not implement business rules.

16. Recommended Practical Rules

For a real Laravel modular monolith:

• keep Domain pure PHP
• keep Application focused on use cases
• keep Infrastructure responsible for Eloquent and framework integration
• keep Presentation thin
• let modules talk through interfaces
• keep Shared small and disciplined
• place migrations inside modules and load them through service providers

17. Final Takeaway

A clean modular monolith should let you say:

• Orders can be understood mostly by reading the Orders module
• Inventory can change its persistence internals without breaking Orders
• Business rules do not depend on Laravel controllers or Eloquent

If those are true, the architecture is in a good place.

If you haven’t install any Laravel project then let’s start and explore it -

composer create-project laravel/laravel:^10.0 example-app

Now integrate Laravel Modules Package -

composer require nwidart/laravel-modules

Also, integrate Tenancy for Laravel Package -

composer require stancl/tenancy

php artisan tenancy:install

// bootstrap/providers.php
return [
    App\Providers\AppServiceProvider::class,
    App\Providers\TenancyServiceProvider::class, // <-- here
];

First Configure all requirements for tenancy from Tenancy Docs. After preparing tenancy in the project create a fresh module like Blog -

php artisan module:make Blog

After creating a fresh Blog module there are all the essential files for Laravel app. Now we want to modify this for our tenant setup.

Well, first, we’re going to configure migrations for the tenant in the Modules/Blog/Database/migrations path. In this path, all migrations are for the central system. Now, create a tenant folder in that folder, like (Modules/Blog/Database/migrations/tenant), and configure it on the service provider. For this feature, we want a service provider, so create a service provider in the Blog Module.

php artisan module:make-provider TenantBlogServiceProvider Blog

<?php

namespace Modules\Blog\App\Providers;

use Illuminate\Support\ServiceProvider;

class TenantBlogServiceProvider extends ServiceProvider
{
    /**
     * Register the service provider.
     */
    public function register(): void
    {
        // Register module tenant migrations
        $this->app->booted(function () {
            config()->push(
                'tenancy.migration_parameters.--path',
                module_path('Blog', 'Database/migrations/tenant')
            );
        });
    }

    /**
     * Get the services provided by the provider.
     */
    public function provides(): array
    {
        return [];
    }
}

Register the provider in the BlogServiceProvider.php file

/**
 * Register the service provider.
*/
public function register(): void
{
    $this->app->register(RouteServiceProvider::class);
    $this->app->register(TenantBlogServiceProvider::class); // Register tenant service provider for this module
}

Now we’re going to config routes for tenants -

We know all routes are web.php for web guard and api.php for API guard. But for central system routes boundary we should configure RouteServiceProvider in Blog Module -

    /**
     * Define the "web" routes for the application.
     *
     * These routes all receive session state, CSRF protection, etc.
     */
    protected function mapWebRoutes(): void
    {
        foreach ($this->centralDomains() as $domain) {
            Route::middleware('web')
                ->namespace($this->moduleNamespace)
                ->domain($domain)
                ->group(module_path('Blog', '/routes/web.php'));
        }
    }

    /**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     */
    protected function mapApiRoutes(): void
    {
        foreach ($this->centralDomains() as $domain) {
            Route::prefix('api')
                ->middleware('api')
                ->namespace($this->moduleNamespace)
                ->domain($domain)
                ->group(module_path('Blog', '/routes/api.php'));
        }
    }

    /**
     * Define the "tenant" routes for the application.
     * 
     * These routes are typically stateless.
     */
    protected function mapTenantRoutes(): void
    {
        $this->app->booted(function () {
            if (file_exists(module_path('Blog', '/routes/tenant.php'))) {
                Route::namespace($this->moduleNamespace)
                    ->group(module_path('Blog', '/routes/tenant.php'));
            }
        });
    }

    /**
     * Define the routes for the application.
     */
    protected function centralDomains(): array
    {
        return config('tenancy.central_domains');
    }

Finally RouteServiceProvider.php for Blog Module

<?php

namespace Modules\Blog\App\Providers;

use Illuminate\Support\Facades\Route;
use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider;

class RouteServiceProvider extends ServiceProvider
{
    /**
     * The module namespace to assume when generating URLs to actions.
     */
    protected string $moduleNamespace = 'Modules\Blog\App\Http\Controllers';

    /**
     * Called before routes are registered.
     *
     * Register any model bindings or pattern based filters.
     */
    public function boot(): void
    {
        parent::boot();
    }

    /**
     * Define the routes for the application.
     */
    public function map(): void
    {
        $this->mapApiRoutes();

        $this->mapWebRoutes();

        // Register tenant routes
        $this->mapTenantRoutes();
    }

    /**
     * Define the "web" routes for the application.
     *
     * These routes all receive session state, CSRF protection, etc.
     */
    protected function mapWebRoutes(): void
    {
        foreach ($this->centralDomains() as $domain) {
            Route::middleware('web')
                ->namespace($this->moduleNamespace)
                ->domain($domain)
                ->group(module_path('Blog', '/routes/web.php'));
        }
    }

    /**
     * Define the "api" routes for the application.
     *
     * These routes are typically stateless.
     */
    protected function mapApiRoutes(): void
    {
        foreach ($this->centralDomains() as $domain) {
            Route::prefix('api')
                ->middleware('api')
                ->namespace($this->moduleNamespace)
                ->domain($domain)
                ->group(module_path('Blog', '/routes/api.php'));
        }
    }

    /**
     * Define the "tenant" routes for the application.
     * 
     * These routes are typically stateless.
     */
    protected function mapTenantRoutes(): void
    {
        $this->app->booted(function () {
            if (file_exists(module_path('Blog', '/routes/tenant.php'))) {
                Route::namespace($this->moduleNamespace)
                    ->group(module_path('Blog', '/routes/tenant.php'));
            }
        });
    }

    /**
     * Define the routes for the application.
     */
    protected function centralDomains(): array
    {
        return config('tenancy.central_domains');
    }
}

Now try it after the composer dump-autoload command.

php artisan route:list
php artisan serve

Go is a statically typed, open-source, compiled programming language. We are known for greater efficiency in speed, performance, and usability.

The above brief introduction may not be straightforward. So let's break down the definition a bit -

• First, let's talk about “statically typed”. Statically typed means that the data type of all variables used in Go is determined at compile time before runtime. That is, the data type is determined before the program is run.

• Then comes, “Open Source”. Due to its open-source nature, anyone can create packages for any task, and since Go is a package-based language, Go's community support can contribute directly.

• "Compiled" means that all Go code is directly converted to machine code and can be run directly on a computer's processor. Go performs better than other interpreted languages ​​(JavaScript, Python) for this feature.

Usage of Go

• For building any web application, web servers, APIs, and today's most popular microservices architecture.

• For system software, such as operating systems, device drivers, and network protocols.

• Go has its own concurrency support for distributed systems, data pipelining, and streaming applications.

• For network applications like servers, proxies, and load balancers.

• For various DevOps and cloud applications.

Go Install

We chose VS code as the IDE to start our Go journey, as it is one of the most widely used IDEs and is open source.

The process of installing Go is slightly different depending on the platform. For now, we are only providing guidelines for installing Go on Windows.

Install Go on Windows –

• First, download the .msi file for Windows from this link.

• Once the file is downloaded, open it and follow the prompts-

• First, after waiting for a while, I will click on the Next button.

• Then click on the Next button again.

• We can choose any directory we want, but now we will select the default directory and click Next button again.

  

• If you click on the Install button, Windows administrative will ask for permission, then click on the Yes button.

• When the installation is finished, we will click on the Finish button.

• To check whether it is installed correctly, open the command prompt and run the go version command, then we will see something like the image. Congratulations, Go has been successfully installed on your system.

Install Go on Linux –

• First of all, I will download the Linux binary release file by going to this link.

• If any version of Go is already installed on the system then remove it from the system by running the following command –

sudo rm -rf /usr/local/go

• Then extract the downloaded file to /usr/local location –

sudo tar -C /usr/local -xzf gox.x.x.linux-amd64.tar.gz

• Add /usr/local/Go/bin to PATH environment variable –

export PATH=$PATH:/usr/local/go/bin

• Log-out once and log in again.

• By opening the terminal and running the following command, if we see the version of Go, then we will understand that our installation process has been completed properly –

go version

The first program in Go -

When starting to learn a language, our first task is to run a program before we learn something well, with which we can say "Hello World!" to the terminal. I can print the output. Then, without delay, fulfill that responsibility -

• First, create a directory and open it with vs code –

> mkdir hello-world
> cd hello-world
> code .

main.go

package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

• The entry point of any Go program is its main() function. That is, a Go program must have func main().

• Inside the main() function, Println is a function of the fmt package. Go is a package based language. Since we have used the fmt package here, we have to import it. And by using this Println() function we can print “Hello World!” in the terminal.

• To run the above program, we will run the following command from the terminal –

go run main.go

• This will build and run the program together and we will see “Hello World!” in the terminal. I will get the output.

• If we want to save the program as an executable binary only, then run the following command –

go build main.go

𝐩𝐰𝐝 - Print working directory. 📂
𝐥𝐬 - List directory contents. 📋
𝐜𝐝 - Change directory. 📁
𝐭𝐨𝐮𝐜𝐡 - To create a file without any content. 📄
𝐜𝐚𝐭 - Concatenate and display file content. 🐱
𝐜𝐩 - Copy files or directories. 📁📂
𝐦𝐯 - Move or rename files or directories. 🔄
𝐫𝐦 - Remove files or directories. 🗑️
𝐦𝐤𝐝𝐢𝐫 - Create a new directory. 📁
𝐫𝐦𝐝𝐢𝐫 - Remove an empty directory. 📁🗑️
𝐞𝐜𝐡𝐨 - Display a line of text or a variable value. 📢
𝐧𝐚𝐧𝐨 - A simple text editor. ✏️
𝐯𝐢 - A powerful text editor. ✒️
𝐜𝐡𝐦𝐨𝐝 - Change file or directory permissions. 🔐
𝐜𝐡𝐨𝐰𝐧 - Change file or directory owner and group. 👤
𝐟𝐢𝐧𝐝 - Search for files in a directory hierarchy. 🔍
𝐠𝐫𝐞𝐩 - Search text using patterns. 🔎
𝐦𝐚𝐧 - Display the manual for a command. 📖
𝐩𝐬 - Display information about running processes. 🔄
𝐤𝐢𝐥𝐥 - Terminate processes by PID. ⚰️
𝐭𝐨𝐩 - Display and update sorted information about processes. 📊
𝐝𝐟 - Report file system disk space usage. 💾
𝐝𝐮 - Estimate file space usage. 📏
𝐟𝐫𝐞𝐞 - Display memory usage. 🧠
𝐮𝐧𝐚𝐦𝐞 - Print system information. ℹ️
𝐮𝐩𝐭𝐢𝐦𝐞 - Tell how long the system has been running. ⏳
𝐰𝐡𝐨𝐚𝐦𝐢 - Display the current user. 👤
𝐬𝐮𝐝𝐨 - Execute a command as another user, typically the superuser. 🛡️
𝐚𝐩𝐭-𝐠𝐞𝐭 - Package handling utility for Debian-based distributions. 📦
𝐲𝐮𝐦 - Package manager for RPM-based distributions. 🍲
𝐭𝐚𝐫 - Archive files. 🗃️
𝐳𝐢𝐩 - Package and compress (archive) files. 📦
𝐮𝐧𝐳𝐢𝐩 - Extract compressed files. 📂
𝐰𝐠𝐞𝐭 - Retrieve files from the web. 🌐
𝐜𝐮𝐫𝐥 - Transfer data from or to a server. 🔄
𝐬𝐬𝐡 - OpenSSH client (remote login program). 🚪
𝐬𝐜𝐩 - Secure copy (remote file copy program). 🔒
𝐫𝐬𝐲𝐧𝐜 - Remote file and directory synchronization. 🔄
𝐡𝐨𝐬𝐭𝐧𝐚𝐦𝐞 - Show or set the system's host name. 🏠
𝐩𝐢𝐧𝐠 - Send ICMP ECHO_REQUEST to network hosts. 📶
𝐧𝐞𝐭𝐬𝐭𝐚𝐭 - Print network connections, routing tables, interface statistics, masquerade connections, and multicast memberships. 🌐
𝐢𝐟𝐜𝐨𝐧𝐟𝐢𝐠 - Configure a network interface. 🌐
𝐢𝐩 - Show/manipulate routing, devices, policy routing, and tunnels. 🌐
𝐢𝐩𝐭𝐚𝐛𝐥𝐞𝐬 - Administration tool for IPv4 packet filtering and NAT. 🛡️
𝐬𝐲𝐬𝐭𝐞𝐦𝐜𝐭𝐥 - Control the systemd system and service manager. 🔄
𝐣𝐨𝐮𝐫𝐧𝐚𝐥𝐜𝐭𝐥 - Query and display messages from the journal. 📜
𝐜𝐫𝐨𝐧𝐭𝐚𝐛 - Schedule periodic background jobs. ⏰
𝐬𝐮𝐝𝐨 𝐬𝐮 - Allows us to switch to a different user and execute one or more commands in the shell without logging out from our current session. 🛡️
𝐦𝐨𝐮𝐧𝐭 - Mount a file system. 📂
𝐮𝐦𝐨𝐮𝐧𝐭 - Unmount a file system. 📂

🐧 Use these commands to interact with your Linux system and perform various administrative tasks! 🚀

Step 1: Update Your Package Repository

Before installing any software on Ubuntu, it’s essential to update the package repository to ensure you have the latest information about available packages. Open your terminal and run the following commands:

sudo apt update

The sudo apt update command is used to refresh the package information on a Debian-based Linux system. It ensures that your system’s package manager (APT, which stands for Advanced Package Tool) has the latest information about available packages and their versions from the configured software repositories.

Then Upgrade:

sudo apt upgrade

The sudo apt upgrade command is used to upgrade the installed packages on a Debian-based Linux system, such as Ubuntu. This command will search for updates to your installed packages and, if any updates are available, it will prompt you to confirm the upgrade. It is a good practice to regularly run this command to keep your system up to date with the latest software updates and security patches.

Step 2: Install MySQL

Now, let’s install MySQL by using the following command:

sudo apt install mysql-server

This command will prompt you to confirm the installation by typing “Y” and then hitting Enter. The MySQL server package and dependencies will be downloaded and installed.

Step 3: Secure Your MySQL Installation

After MySQL is installed, it’s important to secure it to prevent unauthorized access and enhance security. The following command will initiate the MySQL secure installation process:

sudo mysql_secure_installation

You will be asked a series of questions to configure security settings. It’s advisable to answer “Y” (yes) to most of the questions, but you can customize this to suit your requirements.

1. Question: Type your password and press Y to set up the VALIDATE PASSWORD component which checks whether the new password is strong enough. If you don’t want to VALIDATE PASSWORD Then press Nto set (No).

1. 1. If you press yes then follow those steps: Enter 0, 1, or 2 depending on the password strength you want to set :

• 1. • 0 – Low. The password consists of at least 8 characters.

       • 1 – Medium. The password consists of at least 8 characters (including numeric, mixed case, and special characters).

       • 2 – Strong. The password consists of at least 8 characters (including numeric, mixed case, and special characters, and compares the password to a dictionary file).

     • Please set the password for root and enter the password you want to set.

     • Once you specify the required strength, enter and re-enter the password.

     • The program evaluates the strength of your password and requires confirmation Y to continue.

2. Question: Remove anonymous users.

Answer: To remove the demo/test user, press Y. If you want to keep them, press N to set it to ‘No’.

3. Question: Disallow root login remotely?

Answer: Press Y to disable remote access to the MySQL server. If you want to enable remote access, press N.

4. Question: Remove the test database and access to it.

Answer: Y to remove the test database and access to it or N for allow. This is a recommended security measure to remove the default test database, which is often unnecessary and can be a potential security risk if left in place. Removing it helps to enhance the security of your MySQL installation.

5. Question: Reload privilege tables?

Answer: Y for “Yes.” and N for “No”. Reloading the privilege tables is essential after making changes to the MySQL user accounts and permissions. This ensures that the changes take effect immediately and that MySQL enforces the updated user privileges. It’s necessary to properly secure and configure MySQL as per your settings during the installation process.

Your MySQL installation is now secure.

Step 4: Start and Enable MySQL

MySQL may not start automatically after installation. To ensure MySQL starts with your system, you can use the following commands:

sudo systemctl start mysql

sudo systemctl enable mysql

Now, MySQL will start automatically every time your system boots.

Step 5: Check MySQL Status

You can check if MySQL is running properly with the following command:

sudo systemctl status mysql

You should see a status message indicating that MySQL is active and running.

Step 6: Test Your MySQL Installation

To verify that MySQL is functioning correctly, you can log in as the root user:

mysql -u root -p

You’ll be prompted to enter the root password you set during the secure installation. If you can log in without any issues, your MySQL installation is successful.

Conclusion

Congratulations! You have successfully installed MySQL on your Ubuntu system. MySQL is a powerful and versatile database management system that can be used for various applications, from web development to data analysis. You can now start creating databases, and tables, and managing your data with MySQL on your Ubuntu machine.

Happy Coding 😉