Laravel యొక్క authorization సిస్టమ్ authenticated user ఏమి చేయడానికి అనుమతించబడ్డాడో నియంత్రిస్తుంది (authentication నుండి భిన్నమైనది — వారు ఎవరు). Gates అనేవి అనుమతుల కోసం సాధారణ closures; Policies అనేవి నిర్దిష్ట model (ఉదా. Post ను ఎవరు update చేయవచ్చు) చుట్టూ authorization logic ను నిర్వహించే classes.
::(, fn() => ->());
(::()) { ... }
::();
Gates నిర్దిష్ట model తో సంబంధం లేని సాధారణ, standalone అనుమతుల కోసం మంచివి.
<?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();
}
}
ఒక Policy class model కోసం authorization rules లను సమూహపరుస్తుంది — ప్రతిটి method "ఈ user ఈ model పై ఈ action చేయవచ్చా?" అని సమాధానం ఇస్తుంది. ఇది authorization logic ను resource కు సంబంధించి సంఘటితం ఉంచుతుంది.
// 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
authorize()/can() methods (మరియు Blade లో @can) policy ను స్వయంచాలకంగా చెక్ చేస్తాయి — user అనుమతించబడనప్పుడు 403 ను విసిరేయడం లేదా UI ను దాచడం.
Authorization అవసరమైనది మరియు security-critical — authenticated users చేయడానికి అనుమతించబడిన వాటిని నియంత్రించడం (కేవలం అవి లాగిన్ చేసిందా కాదు) అనేది application security కు ప్రాథమికమైనది, మరియు Laravel యొక్క policies మరియు gates దీన్ని నిర్వహించడానికి శుభ్రమైన, సంఘటిత మార్గం ను అందిస్తాయి.
authentication (మీరు ఎవరు — login) మరియు authorization (మీరు ఏమి చేయవచ్చు — permissions) మధ్య వ్యత్యాసాన్ని అర్థం చేసుకోవడం ప్రాథమికమైనది, మరియు authorization విఫలతలు తీవ్రమైన vulnerabilities కు దారితీస్తాయి (users వారు చేయకూడని data ను యాక్సెస్ చేయడం లేదా సవరించడం — broken access control ఒక top security risk).
Laravel యొక్క సిస్టమ్ రెండు complementary tools అందిస్తుంది: సాధారణ, standalone అనుమతుల కోసం Gates (closure-based checks), మరియు Policies — సాధారణ, సిఫార్సు చేయబడిన విధానం — ఇది model యొక్క authorization rules ను dedicated class కు సంఘటితం చేస్తుంది (ఉదా. ఎవరు Post ను update లేదా delete చేయవచ్చు), authorization logic ను resource కు సంబంధించి నిర్మాణాత్మకమైన మరియు నిర్వహణీయమైన ఉంచుతుంది.
Policies/gates ని ఎలా నిర్వచించాలి మరియు దానిని ఎలా enforce చేయాలి ($this->authorize(), $user->can(), Blade లో @can — controllers లో permissions ను చెక్ చేయడం, 403 లను విసిరేయడం, మరియు条件పూర్వకంగా UI ను చూపించడం) ఎలా చేయాలో అర్థం చేసుకోవడం secure applications ను నిర్మించడానికి ముఖ్యమైనది ఇక్కడ users only permitted actions చేయవచ్చు.
ప్రాయः ప్రతిটి real application fine-grained access control (users వారి స్వంత resources ను మాత్రమే సవరించగలరని నిশ్చితం చేయడం, admin actions ను నియమితం చేయడం, మొదలైనవి) అవసరం కాబట్టి, మరియు authorization ను కొట్టివేయడం ప్రమాదకరమైన security holes ను సృష్టిస్తుంది కాబట్టి, Laravel యొక్క policies మరియు gates ను తెలుసుకోవడం — authorization ను apply చేయడానికి సరైన, సంఘటిత మార్గం — important security-relevant senior knowledge ఇది applications ను సరిగ్గా enforcement చేయడానికి అవసరమైనది ఎవరు ఏమి చేయవచ్చు, real systems లో frequent మరియు critical requirement ఇది.