How to Scale Laravel Applications for High-Traffic Production Systems

use App\Models\Post;

$posts = Post::latest()->take(50)->get();

foreach ($posts as $post) {
    echo $post->author->name;
}

use App\Models\Post;

$posts = Post::with('author')
    ->latest()
    ->take(50)
    ->get();

foreach ($posts as $post) {
    echo $post->author->name;
}

$orders = Order::where('account_id', $accountId)
    ->where('status', 'paid')
    ->whereBetween('created_at', [$start, $end])
    ->latest()
    ->paginate(50);

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::table('orders', function (Blueprint $table) {
            $table->index(['account_id', 'status', 'created_at']);
        });
    }

    public function down(): void
    {
        Schema::table('orders', function (Blueprint $table) {
            $table->dropIndex(['account_id', 'status', 'created_at']);
        });
    }
};

$users = User::with([
    'profile',
    'teams',
    'roles.permissions',
    'invoices.lineItems.product',
])->get();

$users = User::query()
    ->select(['id', 'name', 'email'])
    ->with([
        'profile:id,user_id,avatar_url',
        'teams:id,name',
    ])
    ->latest()
    ->paginate(25);

public function store(Request $request)
{
    $order = Order::create($request->validated());

    Mail::to($order->user)->send(new OrderReceipt($order));

    return response()->json($order, 201);
}

public function store(StoreOrderRequest $request)
{
    $order = Order::create($request->validated());

    SendOrderReceipt::dispatch($order->id);

    return response()->json([
        'id' => $order->id,
        'status' => 'accepted',
    ], 202);
}

return User::with('orders', 'invoices', 'teams')->findOrFail($id);

use Illuminate\Http\Resources\Json\JsonResource;

class UserSummaryResource extends JsonResource
{
    public function toArray($request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'avatar_url' => $this->profile?->avatar_url,
            'plan' => $this->subscription_plan,
        ];
    }
}

$rows = DB::table('orders')
    ->join('users', 'users.id', '=', 'orders.user_id')
    ->join('accounts', 'accounts.id', '=', 'users.account_id')
    ->where('accounts.region', 'us-east')
    ->where('orders.status', 'paid')
    ->orderByDesc('orders.created_at')
    ->limit(100)
    ->get();

$subscription = Subscription::where('account_id', $accountId)
    ->where('status', 'active')
    ->where('renews_at', '>=', now())
    ->orderBy('renews_at')
    ->first();

$projects = Project::query()
    ->select(['id', 'account_id', 'name', 'updated_at'])
    ->withCount('openTasks')
    ->with([
        'owner:id,name',
    ])
    ->where('account_id', $accountId)
    ->latest('updated_at')
    ->paginate(30);

$teams = Team::query()
    ->withCount([
        'members',
        'invitations as pending_invitations_count' => fn ($query) => $query->whereNull('accepted_at'),
    ])
    ->paginate(25);

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

DB::listen(function (QueryExecuted $query) {
    if ($query->time > 100) {
        Log::warning('Slow query detected', [
            'sql' => $query->toRawSql(),
            'time_ms' => $query->time,
        ]);
    }
});

User::where('is_active', true)
    ->chunkById(1000, function ($users) {
        foreach ($users as $user) {
            RefreshUserSearchIndex::dispatch($user->id);
        }
    });

$events = AuditEvent::query()
    ->where('account_id', $accountId)
    ->orderByDesc('id')
    ->cursorPaginate(50);

return AuditEventResource::collection($events);

'mysql' => [
    'driver' => 'mysql',
    'read' => [
        'host' => [
            env('DB_READ_HOST', '127.0.0.1'),
        ],
    ],
    'write' => [
        'host' => [
            env('DB_WRITE_HOST', '127.0.0.1'),
        ],
    ],
    'sticky' => true,
    'database' => env('DB_DATABASE', 'laravel'),
    'username' => env('DB_USERNAME', 'root'),
    'password' => env('DB_PASSWORD', ''),
],

use Illuminate\Support\Facades\Cache;

$stats = Cache::remember(
    "accounts:{$account->id}:dashboard-stats",
    now()->addMinutes(5),
    fn () => DashboardStats::forAccount($account)->calculate()
);

Order::created(function (Order $order) {
    Cache::forget("accounts:{$order->account_id}:dashboard-stats");
});

SESSION_DRIVER=redis
CACHE_STORE=redis
QUEUE_CONNECTION=redis

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('api', function (Request $request) {
    return Limit::perMinute(120)->by(
        optional($request->user())->id ?: $request->ip()
    );
});

RateLimiter::for('exports', function (Request $request) {
    return Limit::perHour(10)->by($request->user()->id);
});

QUEUE_CONNECTION=redis

GenerateInvoicePdf::dispatch($invoice->id)
    ->onQueue('documents');

use App\Mail\OrderReceiptMail;
use App\Models\Order;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;
use Illuminate\Support\Facades\Mail;

class SendOrderReceipt implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;
    public int $backoff = 60;

    public function __construct(public int $orderId)
    {
    }

    public function handle(): void
    {
        $order = Order::with('user')->findOrFail($this->orderId);

        Mail::to($order->user)->send(new OrderReceiptMail($order));
    }
}

use App\Models\Order;
use App\Services\CrmClient;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Queue\Queueable;

class SyncOrderToCrm implements ShouldQueue
{
    use Queueable;

    public int $tries = 3;
    public int $backoff = 60;

    public function __construct(public int $orderId)
    {
    }

    public function handle(CrmClient $crm): void
    {
        $order = Order::findOrFail($this->orderId);

        if ($order->crm_synced_at) {
            return;
        }

        $crm->upsertOrder($order->external_reference, [
            'total' => $order->total,
            'status' => $order->status,
        ]);

        $order->forceFill(['crm_synced_at' => now()])->save();
    }
}

'production' => [
    'supervisor-default' => [
        'connection' => 'redis',
        'queue' => ['default', 'emails'],
        'balance' => 'auto',
        'maxProcesses' => 20,
        'tries' => 3,
    ],

    'supervisor-documents' => [
        'connection' => 'redis',
        'queue' => ['documents'],
        'balance' => 'simple',
        'maxProcesses' => 5,
        'tries' => 2,
        'timeout' => 300,
    ],
],

use DateTime;
use Throwable;

public function retryUntil(): DateTime
{
    return now()->addMinutes(30);
}

public function failed(Throwable $exception): void
{
    ImportBatch::whereKey($this->batchId)->update([
        'status' => 'failed',
        'failed_reason' => $exception->getMessage(),
    ]);
}

class OrderResource extends JsonResource
{
    public function toArray($request): array
    {
        return [
            'id' => $this->id,
            'status' => $this->status,
            'total' => $this->total,
            'placed_at' => $this->created_at->toIso8601String(),
            'customer' => new CustomerSummaryResource($this->whenLoaded('customer')),
        ];
    }
}

$orders = Order::query()
    ->with('customer:id,name')
    ->where('account_id', $accountId)
    ->latest()
    ->paginate(50);

return OrderResource::collection($orders);

$perPage = min((int) request('per_page', 50), 100);

$orders = Order::where('account_id', $accountId)
    ->latest()
    ->paginate($perPage);

$products = Product::query()
    ->select(['id', 'name', 'slug', 'price', 'thumbnail_url'])
    ->where('is_visible', true)
    ->orderBy('name')
    ->paginate(40);

Route::middleware(['auth:sanctum', 'throttle:api'])
    ->group(function () {
        Route::get('/orders', [OrderController::class, 'index']);
        Route::post('/exports/orders', [OrderExportController::class, 'store'])
            ->middleware('throttle:exports');
    });

public function index(Request $request)
{
    $accountId = $request->user()->account_id;
    $page = $request->integer('page', 1);

    $cacheKey = "api:accounts:{$accountId}:orders:v1:page:{$page}";

注意键中的 v1。当响应格式发生变化时，增加版本号可以一次性使整个响应失效。对于任何非全局的内容，始终将键作用域限定在租户或用户上。

## 如何在生产环境中监控 Laravel

那些在客户发现问题之前就捕获问题的团队，是从各个方面收集信号的：Laravel、队列、数据库、Redis、基础设施和外部服务。

Laravel 为你提供了几个良好的起点。Horizon 显示队列吞吐量、失败任务、等待时间和工作器平衡。Telescope 展示请求详情、查询、异常、任务、邮件和缓存事件。你的日志记录了缓慢的操作、意外的重试和外部失败。你的指标跟踪延迟、错误率、队列深度、任务运行时间、数据库 CPU、锁等待、缓存命中率和 Redis 内存。你的警报将所有这些与客户实际会感受到的问题联系起来。

最后一部分往往是团队容易出错的地方。最好的警报是关于症状，而不是机器是否繁忙：比如 p95 API 延迟超过 800 毫秒持续 10 分钟，结账错误率超过 1%，邮件队列等待超过 5 分钟，数据库 CPU 超过 85% 且慢查询增加，Redis 内存超过 80%，或失败的支付 Webhook 超过阈值。

一个有用的思维模型是这样的：日志告诉你发生了什么，指标告诉你系统是否健康，而追踪告诉你时间都花在哪里了。实际上，将昂贵的业务操作用一些监控工具包装起来，会迅速带来回报：

当凌晨 2 点有东西出错时，像这样的日志行可以告诉你哪个账户、导入或报告导致了压力。

还有一个值得内化的内容：监控等待时间，而不仅仅是吞吐量。一个队列每分钟可以处理数千个任务，但如果重要的任务在开始之前等待太久，它仍然可能是不健康的。用户感受到的是等待时间，而不是吞吐量。

## 一个高流量 Laravel 架构示例

一个高流量的 Laravel 设置通常会将四部分分离：无状态的 Web 请求、共享缓存和会话存储、异步工作器和数据库角色。

用户通过负载均衡器，负载均衡器将流量分发到一组无状态的 Laravel 应用服务器上。这些服务器使用 Redis 作为缓存、会话、速率限制、队列和 Horizon 数据。队列工作器处理缓慢或不可靠的工作。一个 MySQL 主数据库处理所有写入和任何一致性敏感的读取，而一个读取副本则吸收可以容忍一些复制延迟的读取密集型端点。

流程如下所示：

Redis 队列  
  -> 队列工作者  
  -> 数据库、外部 API、邮件服务提供商、对象存储及其他服务  

DB::transaction(function () use ($request) {
    $order = Order::create([...]);
    $order->items()->createMany($request->items);

    GenerateInvoicePdf::dispatch($order->id);
    SyncOrderToCrm::dispatch($order->id);
});

GenerateInvoicePdf::dispatch($order->id)->afterCommit();
SyncOrderToCrm::dispatch($order->id)->afterCommit();