# Laravel Middleware Derinlemesine: Kimlik Dogrulama, Rate Limiting ve Ozel Middleware

> Laravel middleware hakkinda kapsamli rehber - kimlik dogrulamadan rate limitinge, ozel middleware siniflari olusturmaya kadar. Pratik kod ornekleri ve uretim ortami desenleri.

- Published: 2026-04-16
- Updated: 2026-04-16
- Author: SharpSkill
- Tags: laravel, middleware, php, authentication, rate-limiting
- Reading time: 8 min

---

Laravel middleware, gelen HTTP istekleri ile uygulama mantigi arasinda bir filtreleme katmani gorevi gorur. Her istek, bir kontrolore ulasmadan once bir middleware siniflar potasinden gecer ve her yanit ayni potas uzerinden geri doner. Bu mekanizmayi anlamak, 2026 yilinda guvenli ve performansli Laravel uygulamalari gelistirmek icin son derece onemlidir.

> **Middleware Ozeti**
>
> Middleware, HTTP isteklerini rotalara ulasmadan once yakalar. Laravel 12, tum middleware kayitlarini `bootstrap/app.php` dosyasinda akici bir API ile gerceklestirir. Yerlesik middleware, kimlik dogrulama, CSRF korumasi, oturum yonetimi ve rate limiting islemlerini kutudan cikar cikmaz destekler.

## Laravel Middleware Pipeline Nasil Calisir

Laravel HTTP cekirdegi her istegi bir middleware yigini uzerinden isler. Her middleware, istegi alir, kendi mantigini calistirir ve ardindan istegi `$next($request)` araciligiyla bir sonraki katmana iletir ya da dogrudan bir yanit dondurerek potayi keser.

Bu mimari, Sorumluluk Zinciri (Chain of Responsibility) desenini takip eder. Middleware, istek kontrolore **ulasmadan once** (ornegin kimlik dogrulama kontrolleri), yanit **olusturulduktan sonra** (ornegin baslik ekleme) veya her iki durumda da calisabilir.

```php
// app/Http/Middleware/LogRequestTime.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;

class LogRequestTime
{
    public function handle(Request $request, Closure $next): Response
    {
        $start = microtime(true);          // Capture start time

        $response = $next($request);       // Pass to next middleware

        $duration = microtime(true) - $start;
        Log::info('Request completed', [
            'url'      => $request->url(),
            'method'   => $request->method(),
            'duration' => round($duration * 1000, 2) . 'ms',
        ]);

        return $response;                  // Return response up the stack
    }
}
```

Bu middleware istegi sarar: isleme **baslamadan once** baslangic zamanini kaydeder ve yanit **geri geldikten sonra** sureyi loglar. Bu once/sonra deseni, middleware calisma prensibinin temelidir.

## Kimlik Dogrulama Middleware: Rotalari Koruma

Laravel, `Illuminate\Auth\Middleware\Authenticate` ile eslesmis `auth` middleware aliasini sunar. Bunu bir rotaya uygulamak, yalnizca kimlik dogrulanmis kullanicilarin erisebilmesini saglar. Dogrulanmamis kullanicilar 401 yaniti (API) veya giris sayfasina yonlendirme (web) alir.

```php
// routes/web.php
use App\Http\Controllers\DashboardController;
use App\Http\Controllers\ProfileController;

// Single route protection
Route::get('/dashboard', [DashboardController::class, 'index'])
    ->middleware('auth');

// Group protection for multiple routes
Route::middleware('auth')->group(function () {
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::put('/profile', [ProfileController::class, 'update']);
    Route::delete('/profile', [ProfileController::class, 'destroy']);
});
```

### Coklu Guard ile Kimlik Dogrulama

Birden fazla kullanici tipine sahip uygulamalar (yonetim paneli, musteri alani, API), [guard tabanli kimlik dogrulamadan](/technologies/laravel/interview-questions/authentication) yararlanir. `auth` middleware, hangi kimlik dogrulama surucusunun kullanilacagini belirten bir guard parametresi kabul eder.

```php
// routes/api.php
// API routes use the 'sanctum' guard
Route::middleware('auth:sanctum')->group(function () {
    Route::get('/user', fn (Request $request) => $request->user());
    Route::apiResource('/orders', OrderController::class);
});

// routes/web.php
// Admin routes use a custom 'admin' guard
Route::middleware('auth:admin')->prefix('admin')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'index']);
    Route::get('/users', [AdminController::class, 'users']);
});
```

Iki noktadan sonraki guard parametresi, Laravel'e hangi kimlik dogrulama yapilandirmasina karsi dogrulama yapilacagini bildirir. Bu, kimlik dogrulama mantiginin uygulamanin farkli bolumleri arasinda temiz ve ayri kalmasini saglar.

> **Guest Middleware**
>
> `guest` middleware, `auth` middleware'in tersidir — yalnizca kimlik dogrulanmamis kullanicilari gecirir. Giris ve kayit rotalarina uygulandiginda, zaten oturum acmis kullanicilarin bu sayfalara erismesini engeller.

## Throttle Middleware ile Rate Limiting

Laravel'de middleware rate limiting, yerlesik `throttle` middleware ile rotalari kotuye kullanimdan korur. En basit formu iki parametre kabul eder: maksimum istek sayisi ve dakika cinsinden zaman penceresi.

```php
// routes/api.php
// Allow 60 requests per minute per user
Route::middleware('throttle:60,1')->group(function () {
    Route::get('/posts', [PostController::class, 'index']);
    Route::get('/posts/{post}', [PostController::class, 'show']);
});

// Stricter limit for write operations
Route::middleware(['auth:sanctum', 'throttle:10,1'])->group(function () {
    Route::post('/posts', [PostController::class, 'store']);
    Route::put('/posts/{post}', [PostController::class, 'update']);
});
```

### Gelismis Kontrol icin Adlandirilmis Rate Limiterler

`AppServiceProvider` icerisinde adlandirilmis rate limiterler tanimlamak, kullanici baglamina gore limitler uzerinde hassas kontrol saglar. Bu yaklasim, satir ici throttle parametrelerinden cok daha esnektir.

```php
// app/Providers/AppServiceProvider.php
use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\Http\Request;

public function boot(): void
{
    // API rate limiter with tiered access
    RateLimiter::for('api', function (Request $request) {
        $user = $request->user();

        if ($user?->hasSubscription('enterprise')) {
            return Limit::perMinute(500)->by($user->id);   // Enterprise: 500/min
        }

        if ($user) {
            return Limit::perMinute(100)->by($user->id);   // Authenticated: 100/min
        }

        return Limit::perMinute(20)->by($request->ip());   // Anonymous: 20/min
    });

    // Login limiter to prevent brute force
    RateLimiter::for('login', function (Request $request) {
        return Limit::perMinute(5)
            ->by($request->ip())                            // Key by IP address
            ->response(function () {                        // Custom exceeded response
                return response()->json([
                    'message' => 'Too many login attempts. Try again in a minute.',
                ], 429);
            });
    });
}
```

Adlandirilmis limiterleri rotalara uygulamak `throttle:isim` sozdizimini kullanir:

```php
// routes/api.php
Route::middleware('throttle:api')->group(function () {
    Route::apiResource('/posts', PostController::class);
});

// routes/web.php
Route::middleware('throttle:login')
    ->post('/login', [AuthController::class, 'login']);
```

Yukaridaki katmanli rate limiter bir uretim ortami desenini gosterir: enterprise kullanicilar daha yuksek limitler alir, kimlik dogrulanmis kullanicilar orta duzey limitlerle sinirlandirilir ve anonim istekler agresif sekilde kisitlanir. `by()` metodu rate limit anahtarini belirler — kimlik dogrulanmis kullanicilar icin kullanici ID'si ve yedek olarak IP adresi kullanilir.

## Sifirdan Ozel Middleware Olusturma

Ozel [middleware](/technologies/laravel/interview-questions/middleware) olusturmak, yerlesik middleware'in kapsamadiigi senaryolari ele alir. `make:middleware` Artisan komutu, dogru yapiyla yeni bir sinif olusturur.

```bash
php artisan make:middleware EnsureUserHasRole
```

### Rol Tabanli Erisim Kontrolu Middleware

Yaygin bir ozel middleware deseni, rota duzeyinde [rol tabanli yetkilendirmeyi](/technologies/laravel/interview-questions/authorization-policies) zorunlu kilar ve parametre olarak rol adlarini kabul eder.

```php
// app/Http/Middleware/EnsureUserHasRole.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureUserHasRole
{
    public function handle(Request $request, Closure $next, string ...$roles): Response
    {
        $user = $request->user();

        if (! $user || ! $user->hasAnyRole($roles)) {
            abort(403, 'Insufficient permissions.');
        }

        return $next($request);
    }
}
```

Variadic `...$roles` parametresi, virgullerle ayrilmis birden fazla rolun gecilmesine olanak tanir. Kayit ve kullanim su sekildedir:

```php
// bootstrap/app.php
->withMiddleware(function (Middleware $middleware) {
    $middleware->alias([
        'role' => \App\Http\Middleware\EnsureUserHasRole::class,
    ]);
})

// routes/web.php
Route::middleware('role:admin')->group(function () {
    Route::get('/admin', [AdminController::class, 'index']);
});

// Multiple roles: admin OR editor can access
Route::middleware('role:admin,editor')->group(function () {
    Route::resource('/articles', ArticleController::class);
});
```

### Istek Donusturme Middleware

Middleware, istegi kontrolore ulasmadan once degistirebilir. JSON API icin content type basliklarini zorunlu kilan ve string girdileri kesen bir middleware ornegi:

```php
// app/Http/Middleware/ApiRequestSanitizer.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class ApiRequestSanitizer
{
    public function handle(Request $request, Closure $next): Response
    {
        // Reject non-JSON requests on API routes
        if (! $request->expectsJson() && $request->isMethod('POST')) {
            return response()->json(
                ['error' => 'Content-Type must be application/json'],
                415
            );
        }

        // Trim all string inputs
        $input = $request->all();
        array_walk_recursive($input, function (&$value) {
            if (is_string($value)) {
                $value = trim($value);
            }
        });
        $request->merge($input);

        return $next($request);
    }
}
```

Bu middleware iki konuyu ele alir: POST istekleri icin icerik tipini dogrular ve tum string girdilerini bosluk karakterlerinden temizler.

## Laravel 12'de Middleware Kaydi

Laravel 12, tum middleware kaydini `bootstrap/app.php` dosyasinda merkezilestirmistir. Bu, Laravel 11 oncesinde var olan eski `app/Http/Kernel.php` yaklasiminin yerini almistir.

```php
// bootstrap/app.php
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware) {
        // Global middleware (runs on every request)
        $middleware->append(
            \App\Http\Middleware\LogRequestTime::class
        );

        // Add to the 'web' middleware group
        $middleware->web(append: [
            \App\Http\Middleware\TrackPageViews::class,
        ]);

        // Add to the 'api' middleware group
        $middleware->api(prepend: [
            \App\Http\Middleware\ApiRequestSanitizer::class,
        ]);

        // Register aliases for route-level use
        $middleware->alias([
            'role'       => \App\Http\Middleware\EnsureUserHasRole::class,
            'subscribed' => \App\Http\Middleware\EnsureUserIsSubscribed::class,
        ]);

        // Control execution order
        $middleware->priority([
            \Illuminate\Session\Middleware\StartSession::class,
            \Illuminate\Auth\Middleware\Authenticate::class,
            \App\Http\Middleware\EnsureUserHasRole::class,
        ]);
    })
    ->create();
```

`priority` dizisi, ayni rotaya birden fazla middleware atandiginda onem kazanir. Laravel bunlari bu listeye gore siralar; oturumun kimlik dogrulamadan once baslatilmasini ve kimlik dogrulamanin rol kontrollerinden once tamamlanmasini saglar.

> **Middleware Calistirma Sirasi**
>
> Middleware, kayit sirasina gore calisir. Rota duzeyindeki middleware icin `priority` dizisi varsayilan sirayi gecersiz kilar. Kimlik dogrulanmamis isteklerde rol kontrolu yapmaktan kacinmak icin kimlik dogrulama her zaman yetkilendirmeden once yerlestirilmelidir.

## Yanit Sonrasi Gorevler icin Terminable Middleware

Terminable middleware, yanit istemciye **gonderildikten sonra** mantik calistirir. Bu, kullaniciyi engellememen gereken loglama, analitik veya temizlik gorevleri icin kullanislidir.

```php
// app/Http/Middleware/CollectAnalytics.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Symfony\Component\HttpFoundation\Response;

class CollectAnalytics
{
    public function handle(Request $request, Closure $next): Response
    {
        return $next($request);  // Pass through without delay
    }

    public function terminate(Request $request, Response $response): void
    {
        // Runs after response is sent to client
        DB::table('analytics')->insert([
            'path'        => $request->path(),
            'method'      => $request->method(),
            'status_code' => $response->getStatusCode(),
            'user_id'     => $request->user()?->id,
            'ip'          => $request->ip(),
            'created_at'  => now(),
        ]);
    }
}
```

`terminate` metodu hem orijinal istegi hem de nihai yaniti alir. Ayni ornegin hem `handle()` hem de `terminate()` islemlerini yonetmesini saglamak icin middleware'i `AppServiceProvider` icerisinde singleton olarak kaydetmek gerekir.

## Uretim Ortaminda Pratik Middleware Desenleri

Birkac middleware deseni, uretim ortamindaki [Laravel uygulamalarinda](/blog/laravel/laravel-11-building-complete-application) tutarli sekilde kullanilir.

**Bakim modu gecisi** — bakim sirasinda dahili IP adreslerinin uygulamaya erismesine izin verir:

```php
// app/Http/Middleware/MaintenanceBypass.php
class MaintenanceBypass
{
    private array $allowedIps = ['192.168.1.0/24', '10.0.0.1'];

    public function handle(Request $request, Closure $next): Response
    {
        if (app()->isDownForMaintenance()) {
            foreach ($this->allowedIps as $ip) {
                if ($request->ip() === $ip) {
                    return $next($request);
                }
            }
        }

        return $next($request);
    }
}
```

**Guvenlik basliklari** — her yanita HSTS, icerik guvenlik politikasi ve diger basliklari ekler:

```php
// app/Http/Middleware/SecurityHeaders.php
class SecurityHeaders
{
    public function handle(Request $request, Closure $next): Response
    {
        $response = $next($request);

        $response->headers->set('X-Content-Type-Options', 'nosniff');
        $response->headers->set('X-Frame-Options', 'SAMEORIGIN');
        $response->headers->set('Referrer-Policy', 'strict-origin-when-cross-origin');
        $response->headers->set(
            'Strict-Transport-Security',
            'max-age=31536000; includeSubDomains'
        );

        return $response;
    }
}
```

Bu desenler iki temel middleware konumunu gosterir: istekten **once** (bakim modu gecisi IP'yi kontrol eder ve potansiyel olarak engeller) ve yanittan **sonra** (guvenlik basliklari giden yaniti degistirir).

## Sonuc

- Laravel middleware bir potas olarak calisir: her sinif istegi isler, uzerinde islem yapar ve ileri iletir veya bir yanitla zinciri keser
- `auth` middleware, guard tabanli kimlik dogrulama ile rotalari korur ve `auth:guard` sozdizimi ile birden fazla kullanici tipini destekler
- `throttle` middleware ve adlandirilmis `RateLimiter::for()` tanimlari araciligiyla rate limiting, kullanici baglamina dayali katmanli erisim kontrolu saglar
- Ozel middleware, rol kontrolleri, istek sanitizasyonu ve guvenlik basliklari gibi capraz kesim konularini kontrolorleri karistirmadan ele alir
- Laravel 12'de tum middleware kaydi `bootstrap/app.php` icerisinde akici bir API ile yapilir ve `priority` calistirma sirasini kontrol eder
- Terminable middleware, yanit sonrasi gorevleri (analitik, loglama) kullaniciya yonelik gecikmeyi etkilemeden calistirir
- `:param` sozdizimi ile middleware parametreleri, rota tanimlarini ifade edici tutar ve middleware siniflarini farkli baglamlarda yeniden kullanilabilir kilar

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/tr/blog/laravel/laravel-middleware-deep-dive