A Laravel engedélyezési rendszere azt szabályozza, hogy egy hitelesített felhasználó mit tehet meg (megkülönböztetendő a hitelesítéstől — ki ők). A kapuk (gates) egyszerű lezárások az engedélyekhez; az irányelvek (policies) olyan osztályok, amelyek az engedélyezési logikát egy meghatározott modell körül szervezik (pl. ki frissíthet egy Post-ot).
// define a gate (e.g. in a service provider)
Gate::define('edit-settings', fn($user) => $user->isAdmin());
// check it
if (Gate::allows('edit-settings')) { ... }
Gate::authorize('edit-settings'); // throws a 403 if denied
A kapuk jó választás egyszerű, önálló engedélyekhez, amelyek nem kapcsolódnak egy meghatározott modellhez.
<?php
// php artisan make:policy PostPolicy --model=Post
class PostPolicy {
public function update(User $user, Post $post): bool {
return $user->id === $post->user_id; // only the author can update
}
public function delete(User $user, Post $post): bool {
return $user->id === $post->user_id || $user->isAdmin();
}
}
Egy Policy osztály egy modell engedélyezési szabályait csoportosítja — minden metódus arra válaszol, hogy "lehet-e a felhasználónak ezt a műveletet végrehajtani ezen a modellen?" Ez az engedélyezési logikát az erőforrás alapján szervezetten tartja.
// in a controller
public function update(Request $request, Post $post) {
$this->authorize('update', $post); // checks PostPolicy::update — throws 403 if denied
// ... proceed (we know the user is authorized)
}
// the user model
if ($request->user()->can('update', $post)) { ... }
{{-- in Blade — show UI only if authorized --}}
@can('update', $post)
<a href="{{ route('posts.edit', $post) }}">Edit</a>
@endcan
Az authorize()/can() metódusok (és a Blade-ben @can) automatikusan ellenőrzik az irányelvet — 403-at dobnak vagy elrejtik a felhasználói felületet, ha a felhasználónak nincs engedélye.
Az engedélyezés lényeges és biztonsági szempontból kritikus — az engedélyezési logika azt szabályozza, hogy a hitelesített felhasználók mit tehetnek meg (nem csak azt, hogy bejelentkeztek-e), és ez alapvető az alkalmazásbiztonság számára. A Laravel irányelvei és kaputai tiszta, szervezett módot nyújtanak ennek kezelésére.
A hitelesítés (ki vagy — bejelentkezés) és az engedélyezés (mit tehetsz — engedélyek) közötti különbség megértése alapvető, és az engedélyezési hibák komoly biztonsági sebezhetőségekhez vezetnek (felhasználók olyan adatokhoz férnek hozzá vagy módosítanak, amit nem kellene — a hozzáférés-szabályozás megsértése az egyik legfontosabb biztonsági kockázat).
A Laravel rendszere két kiegészítő eszközt kínál: az irányelveket (policies) — a szokásos, ajánlott megközelítés —, amelyek egy modell engedélyezési szabályait egy dedikált osztályba szervezik (pl. ki frissíthet vagy törölhet egy Post-ot), így az engedélyezési logika strukturált és karbantartható marad az egyes erőforrások szintjén, valamint az egyszerű, önálló engedélyekhez az irányelveket.
Annak megértése, hogy hogyan kell irányelveket/kapukat definiálni és kikényszeríteni őket ($this->authorize(), $user->can(), @can a Blade-ben — engedélyek ellenőrzése a kontroller-okban, 403-as hibák dobása, és feltételes felhasználói felület megjelenítése) fontos a biztonságos alkalmazások fejlesztéséhez, ahol a felhasználók csak az engedélyezett műveleteket hajthatják végre.
Mivel szinte minden valós alkalmazásnak szüksége van a részletes hozzáférés-szabályozásra (biztosítva, hogy a felhasználók csak a saját erőforrásaikat módosíthatják, korlátozzák az admin-műveleteket, stb.), és mivel az engedélyezés helytelen kezelése veszélyes biztonsági lyukakat hoz létre, a Laravel irányelvei és kapui — a helyes, szervezett módja az engedélyezés megvalósításának — fontos biztonsággal kapcsolatos senior szintű tudás, amely nélkülözhetetlen az olyan alkalmazások megépítéséhez, amelyek helyesen kikényszerítik azt, hogy ki mit tehet, ami a valós rendszerekben gyakori és kritikus követelmény.