시작하기

설치

go get github.com/casbin/casbin/v3

v2에서 v3으로 마이그레이션

Casbin v2에서 v3으로 업그레이드하는 경우, 가져오기 경로를 github.com/casbin/casbin/v2에서 github.com/casbin/casbin/v3(으)로 업데이트하세요. 이는 모든 하위 패키지에도 적용됩니다(예: v2/model은 v3/model이 됨).

Go 모듈의 경우 다음을 실행하세요:

go get -u github.com/casbin/casbin/v3

그러면 코드 내의 모든 가져오기를 /v2에서 /v3(으)로 업데이트하세요.

Maven의 경우:

<!-- https://mvnrepository.com/artifact/org.casbin/jcasbin -->
<dependency>
    <groupId>org.casbin</groupId>
    <artifactId>jcasbin</artifactId>
    <version>1.x.y</version>
</dependency>

GraalVM Native Image 지원

Aviator expression engine을 사용하기 때문에 GraalVM(예: Quarkus 또는 Spring Native 사용)으로 네이티브 애플리케이션을 빌드하는 경우 jCasbin에는 특별한 구성이 필요합니다.

기본적으로 Aviator는 ASM을 통해 동적 클래스 생성을 사용하며, 이는 GraalVM 네이티브 이미지에서 지원되지 않습니다. 이를 해결하려면 컴파일 모드 대신 인터프리터 모드를 사용하도록 Aviator를 구성해야 합니다.

Quarkus 애플리케이션의 경우

application.properties 또는 pom.xml에 다음 내용을 추가하세요:

<properties>
    <quarkus.native.additional-build-args>
        -J-Daviator.eval.mode=INTERPRETER
    </quarkus.native.additional-build-args>
</properties>

기타 GraalVM 네이티브 빌드의 경우

네이티브 이미지를 빌드할 때 시스템 속성을 설정하세요:

-Daviator.eval.mode=INTERPRETER

또는 jCasbin 초기화 전에 프로그래밍 방식으로 구성하세요:

System.setProperty("aviator.eval.mode", "INTERPRETER");

노트

이 구성은 Aviator를 기본 컴파일 모드에서 인터프리터 모드로 전환합니다. 이는 약간의 성능 저하가 있을 수 있지만, 런타임 클래스 생성을 피하여 GraalVM 네이티브 이미지와의 완전한 호환성을 가능하게 합니다.

# NPM
npm install casbin --save

# Yarn
yarn add casbin

패키지를 다운로드하려면 프로젝트의 composer.json에서 이 패키지를 요구 사항으로 지정하세요:

composer require casbin/casbin

pip install casbin

dotnet add package Casbin.NET

# Download source
git clone https://github.com/apache/casbin-cpp.git

# Generate project files
cd casbin-cpp && mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release

# Build and install casbin
cmake --build . --config Release --target casbin install -j 10

cargo install cargo-edit
cargo add casbin

// If you use async-std as async executor
cargo add async-std

// If you use tokio as async executor, make sure you activate its `macros` feature
cargo add tokio

Casbin4D는 Delphi 10.3 Rio용으로 패키징되어 IDE에 직접 설치됩니다. 시각적 컴포넌트는 포함되지 않으며, 라이브러리는 프로젝트에 독립적으로 가져오는 스탠드얼론 유닛으로 구성되어 있음을 유의하세요.

luarocks install casbin

"Your user does not have write permissions in /usr/local/lib/luarocks/rocks" 오류가 발생하는 경우, 명령어를 관리자 권한으로 실행하거나 --local 플래그를 사용하여 로컬 트리에 설치하세요:

luarocks install casbin --local

Casbin Enforcer 생성하기

Casbin은 접근 제어 모델을 지정하기 위해 구성 파일에 의존합니다.

두 개의 구성 파일이 필요합니다: model.conf와 policy.csv. Model 파일은 접근 제어 모델을 정의하고, Policy 파일에는 권한 규칙이 포함됩니다. 실제로는 두 파일을 모두 로드하는 단일 컴포넌트인 Enforcer를 사용합니다.

Enforcer를 생성하려면 Model과 Adapter를 제공하세요.

Casbin은 사용할 수 있는 FileAdapter를 제공합니다. 자세한 내용은 Adapter를 참조하세요.

• 기본 FileAdapter를 사용하는 Model 파일 예시:

import "github.com/casbin/casbin/v3"

e, err := casbin.NewEnforcer("path/to/model.conf", "path/to/policy.csv")

import org.casbin.jcasbin.main.Enforcer;

Enforcer e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

import { newEnforcer } from 'casbin';

const e = await newEnforcer('path/to/model.conf', 'path/to/policy.csv');

require_once './vendor/autoload.php';

use Casbin\Enforcer;

$e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

import casbin

e = casbin.Enforcer("path/to/model.conf", "path/to/policy.csv")

using NetCasbin;

var e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

#include <iostream>
#include <casbin/casbin.h>

int main() {
    // Create an Enforcer
    casbin::Enforcer e("path/to/model.conf", "path/to/policy.csv");

    // your code ..
}

var
  casbin: ICasbin;
begin
  casbin := TCasbin.Create('path/to/model.conf', 'path/to/policy.csv');
  ...
end

use casbin::prelude::*;

// If you use async_td as async executor
#[cfg(feature = "runtime-async-std")]
#[async_std::main]
async fn main() -> Result<()> {
    let mut e = Enforcer::new("path/to/model.conf", "path/to/policy.csv").await?;
    Ok(())
}

// If you use tokio as async executor
#[cfg(feature = "runtime-tokio")]
#[tokio::main]
async fn main() -> Result<()> {
    let mut e = Enforcer::new("path/to/model.conf", "path/to/policy.csv").await?;
    Ok(())
}

local Enforcer = require("casbin")
local e = Enforcer:new("path/to/model.conf", "path/to/policy.csv") -- The Casbin Enforcer

• 대체 Adapter를 사용하는 Model 텍스트 예시:

import (
    "log"

    "github.com/casbin/casbin/v3"
    "github.com/casbin/casbin/v3/model"
    xormadapter "github.com/casbin/xorm-adapter/v2"
    _ "github.com/go-sql-driver/mysql"
)

// Initialize a Xorm adapter with MySQL database.
a, err := xormadapter.NewAdapter("mysql", "mysql_username:mysql_password@tcp(127.0.0.1:3306)/")
if err != nil {
    log.Fatalf("error: adapter: %s", err)
}

m, err := model.NewModelFromString(`
[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act
`)
if err != nil {
    log.Fatalf("error: model: %s", err)
}

e, err := casbin.NewEnforcer(m, a)
if err != nil {
    log.Fatalf("error: enforcer: %s", err)
}

import casbin
import casbin_sqlalchemy_adapter


# Use SQLAlchemy Casbin adapter with SQLLite DB
adapter = casbin_sqlalchemy_adapter.Adapter('sqlite:///test.db')

# Create a config model policy
with open("rbac_example_model.conf", "w") as f:
    f.write("""
    [request_definition]
    r = sub, obj, act

    [policy_definition]
    p = sub, obj, act

    [policy_effect]
    e = some(where (p.eft == allow))

    [matchers]
    m = r.sub == p.sub && r.obj == p.obj && r.act == p.act
    """)

# Create enforcer from adapter and config policy
e = casbin.Enforcer('rbac_example_model.conf', adapter)

권한 확인

리소스에 접근하기 직전에 코드에 강제 적용 체크를 추가하세요:

sub := "alice" // the user that wants to access a resource.
obj := "data1" // the resource that is going to be accessed.
act := "read" // the operation that the user performs on the resource.

ok, err := e.Enforce(sub, obj, act)

if err != nil {
    // handle err
}

if ok == true {
    // permit alice to read data1
} else {
    // deny the request, show an error
}

// You could use BatchEnforce() to enforce some requests in batches.
// This method returns a bool slice, and this slice's index corresponds to the row index of the two-dimensional array.
// e.g. results[0] is the result of {"alice", "data1", "read"}
results, err := e.BatchEnforce([][]interface{}{{"alice", "data1", "read"}, {"bob", "data2", "write"}, {"jack", "data3", "read"}})

String sub = "alice"; // the user that wants to access a resource.
String obj = "data1"; // the resource that is going to be accessed.
String act = "read"; // the operation that the user performs on the resource.

if (e.enforce(sub, obj, act) == true) {
    // permit alice to read data1
} else {
    // deny the request, show an error
}

GraalVM 네이티브 이미지 참고 사항

jCasbin을 GraalVM 네이티브 이미지 환경에서 실행하는 경우, 위 설치 섹션에 설명된 대로 Aviator가 인터프리터 모드를 사용하도록 구성했는지 확인하세요. 이 구성이 없으면 런타임 클래스 생성 시도 때문에 UnsupportedFeatureError가 발생할 수 있습니다.

const sub = 'alice'; // the user that wants to access a resource.
const obj = 'data1'; // the resource that is going to be accessed.
const act = 'read'; // the operation that the user performs on the resource.

if ((await e.enforce(sub, obj, act)) === true) {
    // permit alice to read data1
} else {
    // deny the request, show an error
}

$sub = "alice"; // the user that wants to access a resource.
$obj = "data1"; // the resource that is going to be accessed.
$act = "read"; // the operation that the user performs on the resource.

if ($e->enforce($sub, $obj, $act) === true) {
    // permit alice to read data1
} else {
    // deny the request, show an error
}

sub = "alice"  # the user that wants to access a resource.
obj = "data1"  # the resource that is going to be accessed.
act = "read"  # the operation that the user performs on the resource.

if e.enforce(sub, obj, act):
    # permit alice to read data1
    pass
else:
    # deny the request, show an error
    pass

var sub = "alice";  // the user that wants to access a resource.
var obj = "data1";  // the resource that is going to be accessed.
var act = "read";   // the operation that the user performs on the resource.

if (await e.EnforceAsync(sub, obj, act))
{
    // permit alice to read data1
}
else
{
    // deny the request, show an error
}

    casbin::Enforcer e("../assets/model.conf", "../assets/policy.csv");

    if (e.Enforce({"alice", "/alice_data/hello", "GET"})) {
        std::cout << "Enforce OK" << std::endl;
    } else {
        std::cout << "Enforce NOT Good" << std::endl;
    }

    if (e.Enforce({"alice", "/alice_data/hello", "POST"})) {
        std::cout << "Enforce OK" << std::endl;
    } else {
        std::cout << "Enforce NOT Good" << std::endl;
    }

if casbin.enforce(['alice,data1,read']) then
  // Alice is super happy as she can read data1
else
  // Alice is sad

  let sub = "alice"; // the user that wants to access a resource.
  let obj = "data1"; // the resource that is going to be accessed.
  let act = "read"; // the operation that the user performs on the resource.

  if e.enforce((sub, obj, act)).await? {
      // permit alice to read data1
  } else {
      // error occurs
  }

if e:enforce("alice", "data1", "read") then
   -- permit alice to read data1
else
   -- deny the request, show an error
end

Casbin은 런타임 권한 관리를 위한 API를 제공합니다. 예를 들어, 사용자에게 할당된 모든 역할을 검색할 수 있습니다:

roles, err := e.GetRolesForUser("alice")

List<String> roles = e.getRolesForUser("alice");

const roles = await e.getRolesForUser('alice');

$roles = $e->getRolesForUser("alice");

roles = e.get_roles_for_user("alice")

var roles = e.GetRolesForUser("alice");

roles = e.rolesForEntity("alice")

let roles = e.get_roles_for_user("alice");

local roles = e:GetRolesForUser("alice")

더 많은 예제는 Management API 및 RBAC API를 참조하세요. 각 언어 저장소의 테스트 케이스도 살펴볼 수 있습니다.