Kem Intensif Pembangunan Backend Node.js · Pelajaran

Kawalan Akses Berasaskan Peranan (RBAC)

Laksanakan kebenaran berasaskan peranan untuk mengehadkan akses kepada titik akhir tertentu berdasarkan peranan dan kebenaran pengguna.

Pelajaran 6 daripada 611 langkah

Kawalan Akses Berasaskan Peranan (RBAC) ialah pelajaran Kem Intensif Pembangunan Backend Node.js percuma di CoddyKit. Ini ialah pelajaran 6 daripada 6. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Backend Node.js, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 6 pelajaran.

Apakah RBAC?

Kawalan Akses Berasaskan Peranan (RBAC) ialah kaedah mengehadkan akses kepada sumber berdasarkan peranan yang dimiliki oleh pengguna dalam sesebuah organisasi.

Daripada menetapkan keizinan terus kepada pengguna, keizinan ditetapkan kepada peranan.
Pengguna kemudiannya ditetapkan kepada peranan dan mewarisi keizinan tersebut.
Ini memudahkan pengurusan keselamatan, terutamanya dalam aplikasi yang lebih besar.

Mentakrifkan Peranan Pengguna

Mula-mula, kita perlu mentakrifkan peranan yang akan digunakan oleh aplikasi kita. Biasanya, peranan ini ialah kategori umum seperti 'admin', 'editor' atau 'basic_user'.

Menggunakan Enum Python ialah cara yang kemas untuk mengurus peranan ini:

from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

# Example usage:
# role = UserRole.ADMIN

Penetapan Peranan Pengguna

Setiap pengguna dalam sistem anda akan mempunyai satu atau lebih peranan yang dikaitkan dengan mereka. Dalam aplikasi FastAPI sebenar, maklumat ini biasanya datang daripada token pengguna yang telah disahkan (contohnya, muatan JWT).

Untuk pelajaran ini, kita akan menggunakan model User ringkas dan fungsi olok-olok untuk mewakili pengguna yang sedang disahkan berserta peranan yang ditetapkan kepadanya.

from typing import List
from pydantic import BaseModel
from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user (normally from JWT)
async def get_current_user() -> User:
    # In a real app, this would decode a JWT
    # For demonstration, let's return a mock admin user
    return User(username="admin_user", roles=[UserRole.ADMIN])

Kebergantungan Peranan Tersuai

Sistem suntikan kebergantungan FastAPI amat sesuai untuk melaksanakan RBAC. Kita boleh mencipta kebergantungan tersuai yang menyemak sama ada pengguna yang telah disahkan mempunyai peranan yang diperlukan untuk mengakses titik akhir.

Kebergantungan ini boleh digunakan semula merentas banyak titik akhir.
Jika pengguna tidak mempunyai peranan yang diperlukan, kebergantungan ini menimbulkan HTTPException.

Membina Penyemak Peranan

Kebergantungan role_required kita akan menerima senarai peranan. Kemudian, kebergantungan ini akan mendapatkan pengguna semasa dan mengesahkan sama ada mana-mana peranan yang ditetapkan kepadanya sepadan dengan peranan yang diperlukan.

from fastapi import Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
async def get_current_user() -> User:
    return User(username="test_user", roles=[UserRole.BASIC_USER])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

Kod: Titik Akhir untuk Pentadbir Sahaja

Berikut ialah aplikasi FastAPI lengkap yang menunjukkan cara melindungi titik akhir supaya hanya pengguna dengan peranan 'admin' boleh mengaksesnya. Jalankan kod ini dan cuba mengakses /admin serta /public.

from fastapi import FastAPI, Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum
import uvicorn

app = FastAPI()

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
# Change roles here to test different access levels
async def get_current_user() -> User:
    # Try changing to [UserRole.BASIC_USER] or [UserRole.ADMIN]
    return User(username="admin_user", roles=[UserRole.ADMIN])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

@app.get("/public")
async def read_public_data():
    return {"message": "This is public data!"}

@app.get("/admin")
async def read_admin_data(current_user: User = Depends(role_required([UserRole.ADMIN]))):
    return {"message": f"Welcome, {current_user.username}! This is admin data."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Menguji Semakan Peranan

Apabila anda menjalankan kod sebelumnya:

Akses http://127.0.0.1:8000/public: Ini sepatutnya sentiasa berfungsi.
Akses http://127.0.0.1:8000/admin: Ini akan berfungsi jika get_current_user mengembalikan pengguna dengan UserRole.ADMIN.

Cuba ubah peranan pengguna olok-olok dalam get_current_user kepada [UserRole.BASIC_USER], kemudian jalankan semula aplikasi. Anda akan melihat ralat 403 Forbidden apabila cuba mengakses /admin.

Membenarkan Berbilang Peranan

Kadang-kadang, sesuatu titik akhir sepatutnya boleh diakses oleh lebih daripada satu peranan. Contohnya, pengguna 'admin' dan 'editor' mungkin dibenarkan mengemas kini artikel.

Kebergantungan role_required kita sudah direka untuk perkara ini! Kebergantungan ini menerima List[UserRole], dan semakan any() bermaksud akses diberikan jika pengguna mempunyai mana-mana satu daripada peranan yang dinyatakan.

Kod: Akses Berbilang Peranan

Contoh ini menunjukkan titik akhir yang boleh diakses oleh sama ada 'admin' atau 'editor'. Cuba ubah peranan pengguna olok-olok kepada [UserRole.EDITOR] dan [UserRole.BASIC_USER] untuk melihat kawalan akses.

from fastapi import FastAPI, Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum
import uvicorn

app = FastAPI()

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
# Change roles here to test different access levels
async def get_current_user() -> User:
    # Try [UserRole.ADMIN], [UserRole.EDITOR], or [UserRole.BASIC_USER]
    return User(username="editor_user", roles=[UserRole.EDITOR])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

@app.get("/edit_content")
async def edit_content(current_user: User = Depends(role_required([UserRole.ADMIN, UserRole.EDITOR]))):
    return {"message": f"Hello {current_user.username}! You can edit content."}

@app.get("/view_only")
async def view_only_content(current_user: User = Depends(role_required([UserRole.BASIC_USER]))):
    return {"message": f"Hello {current_user.username}! You can view content."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Semakan Pelaksanaan RBAC

Anda perlu mencipta titik akhir /dashboard yang hanya boleh diakses oleh pengguna dengan peranan ADMIN. Antara berikut, yang manakah cara yang betul untuk menggunakan kebergantungan role_required?

Jawab dalam pelajaran interaktif

Imbas Kembali RBAC

Anda telah mempelajari cara melaksanakan Kawalan Akses Berasaskan Peranan dalam aplikasi FastAPI anda:

Menentukan peranan menggunakan Python Enum supaya lebih jelas.
Memahami cara peranan pengguna biasanya dikaitkan, contohnya melalui JWT.
Mencipta kebergantungan tersuai yang boleh digunakan semula (role_required) untuk menyemak peranan pengguna.
Menggunakan kebergantungan ini pada titik akhir untuk mengehadkan akses berdasarkan satu atau beberapa peranan.

RBAC ialah cara yang berkesan untuk mengurus keizinan, menjadikan API anda lebih selamat dan mudah diselenggarakan!

Percuma untuk bermula

Pelajari JavaScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 92

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Kawalan Akses Berasaskan Peranan (RBAC)” percuma?

Ya — teks penuh “Kawalan Akses Berasaskan Peranan (RBAC)” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Kem Intensif Pembangunan Backend Node.js, tingkat taraf kepada CoddyKit PRO. Kursus Kem Intensif Pembangunan Backend Node.js merangkumi sejumlah 6 pelajaran.

Apakah yang akan saya pelajari dalam “Kawalan Akses Berasaskan Peranan (RBAC)”?

Laksanakan kebenaran berasaskan peranan untuk mengehadkan akses kepada titik akhir tertentu berdasarkan peranan dan kebenaran pengguna. Anda berlatih Kem Intensif Pembangunan Backend Node.js menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Backend Node.js?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Backend Node.js di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 6 daripada 6.

Berapa lamakah pelajaran “Kawalan Akses Berasaskan Peranan (RBAC)” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Backend Node.js ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Backend Node.js menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kem Intensif Pembangunan Backend Node.js