밀버스 소개
시작하기
개념
사용자 가이드
모델
Milvus 마이그레이션
관리 가이드
도구
통합
튜토리얼
자주 묻는 질문
API Reference

데이터베이스 관리

기존 데이터베이스 엔진과 마찬가지로 Milvus에서도 데이터베이스를 생성하고 특정 사용자에게 권한을 할당하여 관리할 수 있습니다. 그러면 해당 사용자는 데이터베이스의 컬렉션을 관리할 수 있는 권한을 갖게 됩니다. Milvus 클러스터는 최대 64개의 데이터베이스를 지원합니다.

이 페이지의 코드 스니펫은 PyMilvus ORM 모듈을 사용하여 Milvus와 상호 작용합니다. 새로운 MilvusClient SDK가 포함된 코드 스니펫은 곧 제공될 예정입니다.

데이터베이스 생성

connect()를 사용하여 Milvus 서버에 연결하고 create_database()를 사용하여 새 데이터베이스를 생성합니다:

MilvusClient를 사용하여 Milvus 서버에 연결하고 createDatabase()를 사용하여 새 데이터베이스를 생성합니다:

파이썬 자바 Node.js

from pymilvus import connections, db

conn = connections.connect(host="127.0.0.1", port=19530)

database = db.create_database("my_database")

import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam;
import io.milvus.param.collection.CreateDatabaseParam;

// 1. Connect to Milvus server
ConnectParam connectParam = ConnectParam.newBuilder()
    .withUri(CLUSTER_ENDPOINT)
    .withToken(TOKEN)
    .build();

MilvusServiceClient client = new MilvusServiceClient(connectParam);

// 3. Create a new database
CreateDatabaseParam createDatabaseParam = CreateDatabaseParam.newBuilder()
    .withDatabaseName("")
    .build();

R<RpcStatus> response = client.createDatabase(createDatabaseParam);

const address = "http://localhost:19530";

// 1. Set up a Milvus Client
client = new MilvusClient({ address });

// 3. Create a database
res = await client.createDatabase({
    db_name: "my_database",
});

console.log(res);

// {
//   error_code: 'Success',
//   reason: '',
//   code: 0,
//   retriable: false,
//   detail: ''
// }

위의 코드 조각은 기본 데이터베이스에 연결하여 my_database 라는 이름의 새 데이터베이스를 생성합니다.

데이터베이스 사용

Milvus 클러스터는 'default'라는 이름의 기본 데이터베이스와 함께 제공됩니다. 컬렉션은 별도로 지정하지 않는 한 기본 데이터베이스에 생성됩니다.

기본 데이터베이스를 변경하려면 다음과 같이 하세요:

파이썬 자바 Node.js

db.using_database("my_database")

// No equivalent method is available.

// 4. Activate another database
res = await client.useDatabase({
    db_name: "my_database",
});

console.log(res);

다음과 같이 Milvus 클러스터에 연결할 때 사용할 데이터베이스를 설정할 수도 있습니다:

파이썬 자바 노드.js

conn = connections.connect(
    host="127.0.0.1",
    port="19530",
    db_name="my_database"
)

ConnectParam connectParam = ConnectParam.newBuilder()
    .withDatabaseName("my_database")
    .withUri(CLUSTER_ENDPOINT)
    .withToken(TOKEN)
    .build();

MilvusServiceClient client = new MilvusServiceClient(connectParam);

const address = "http://localhost:19530";
const db_name = "my_database";

// 1. Set up a Milvus Client
client = new MilvusClient({ address, db_name });

데이터베이스 목록

Milvus 클러스터에 있는 모든 기존 데이터베이스를 찾으려면 list_database() 메서드를 사용합니다:

Milvus 클러스터에 있는 모든 기존 데이터베이스를 찾으려면 listDatabases() 메서드를 사용합니다:

파이썬 자바 Node.js

db.list_database()

# Output
['default', 'my_database']

import io.milvus.grpc.ListDatabasesResponse;
import io.milvus.param.R;

// 2. List all databases
R<ListDatabasesResponse> listDatabasesResponse = client.listDatabases();
System.out.println(listDatabasesResponse.getData());

// status {
// }
// db_names: "default"
// db_names: "my_database"
// created_timestamp: 1716794498117757990
// created_timestamp: 1716797196479639477

res = await client.listDatabases();

console.log(res.db_names);

// [ 'default', 'my_database' ]

데이터베이스 삭제

데이터베이스를 삭제하려면 먼저 모든 컬렉션을 삭제해야 합니다. 그렇지 않으면 삭제가 실패합니다.

데이터베이스를 삭제하려면 drop_database() 메서드를 사용합니다:

데이터베이스를 삭제하려면 dropDatabase() 메서드를 사용합니다:

Python Java Node.js

db.drop_database("my_database")

db.list_database()

# Output
['default']

import io.milvus.param.collection.DropDatabaseParam;

DropDatabaseParam dropDatabaseParam = DropDatabaseParam.newBuilder()
    .withDatabaseName("my_database")
    .build();

response = client.dropDatabase(dropDatabaseParam);

res = await client.dropDatabase({
    db_name: "my_database",
});

데이터베이스에 RBAC 사용

RBAC는 데이터베이스 작업에도 적용되며 앞으로의 호환성을 보장합니다. 권한 API(부여/취소/목록 부여)에서 데이터베이스라는 단어의 의미는 다음과 같습니다:

Milvus 연결이나 권한 API 호출에 db_name, 데이터베이스가 지정되지 않은 경우 데이터베이스는 기본 데이터베이스를 참조합니다.
Milvus 연결에서 db_name 을 지정했지만 이후 권한 API 호출에서 지정하지 않은 경우 데이터베이스는 Milvus 연결에 이름이 지정된 데이터베이스를 참조합니다.
Milvus 연결에서 db_name 을 지정하거나 지정하지 않고 권한 API 호출이 이루어진 경우 데이터베이스는 권한 API 호출에 이름이 지정된 데이터베이스를 참조합니다.

다음 코드 스니펫은 아래 나열된 블록에서 공유됩니다.

파이썬 자바 Node.js

from pymilvus import connections, Role

_URI = "http://localhost:19530"
_TOKEN = "root:Milvus"
_DB_NAME = "default"


def connect_to_milvus(db_name="default"):
    print(f"connect to milvus\n")
    connections.connect(
        uri=_URI,
        token=_TOKEN,
        db_name=db_name
    )

String URI = "http://localhost:19530";
String TOKEN = "root:Milvus";

public class ConnectToMilvus {
    private String _dbName = "default";

    public newBuilder() {}

    public MilvusServiceClient build() {
        ConnectParam connectParam = ConnectParam.newBuilder()
            .withUri(URI)
            .withToken(TOKEN)
            .withDatabaseName(_dbNAME)
            .build();

        return new MilvusServiceClient(connectParam);
    }

    public newBuilder withDbName(String dbName) {
        this._dbName = dbName;
        return this;
    }
}

const address = "http://localhost:19530";
const token = "root:Milvus";

function connectToMilvus(dbName = "default") {
    const client = new MilvusClient({
        address,
        token,
        dbName,
    });

    return client;
}

Milvus 연결이나 권한 API 호출 모두 db_name 을 지정하지 않으면 데이터베이스는 기본 데이터베이스를 참조합니다.

Python Java Node.js

_ROLE_NAME = "test_role"
_PRIVILEGE_INSERT = "Insert"

connect_to_milvus()
role = Role(_ROLE_NAME)
role.create()

connect_to_milvus()
role.grant("Collection", "*", _PRIVILEGE_INSERT)
print(role.list_grants())
print(role.list_grant("Collection", "*"))
role.revoke("Global", "*", _PRIVILEGE_INSERT)

String ROLE_NAME = "test_role";
String PRIVILEGE_INSERT = "Insert";

MilvusServiceClient client = new ConnectToMilvus().build();
R<RpcStatus> response = client.createRole(CreateRoleParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

response = client.grantRolePrivilege(GrantRolePriviledgeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

R<SelectGrantResponse> grants = client.selectGrantForRole(SelectGrantForRoleParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

grants = client.selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

response = client.revokeRolePrivilege(RevokeRolePrivilegeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Global")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

response = client.revokeRolePrivilege(RevokeRolePrivilegeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Global")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

const ROLE_NAME = "test_role";
const PRIVILEGE_INSERT = "Insert";

const client = connectToMilvus();

async function demo() {}
await client.createRole({
  roleName: ROLE_NAME,
});

const grants = await client.listGrants({
  roleName: ROLE_NAME,
});

console.log(grants.grants);

await client.revokePrivilege({
  roleName: ROLE_NAME,
  object: "Global",
  objectName: "*",
  privilege: PRIVILEGE_INSERT,
});

Milvus 연결에 db_name 이 지정되어 있지만 이후 권한 API 호출에 지정되지 않은 경우 데이터베이스는 Milvus 연결에 이름이 지정된 데이터베이스를 참조합니다.

파이썬 자바 Node.js

# NOTE: please make sure the 'foo' db has been created
connect_to_milvus(db_name="foo")

# This role will have the insert permission of all collections under foo db,
# excluding the insert permissions of collections under other dbs
role.grant("Collection", "*", _PRIVILEGE_INSERT)
print(role.list_grants())
print(role.list_grant("Collection", "*"))
role.revoke("Global", "*", _PRIVILEGE_INSERT)

// NOTE: please make sure the 'foo' db has been created
MilvusServiceClient client = new ConnectToMilvus().withDbName("foo").build();

// This role will have the insert permission of all collections under foo db,
// excluding the insert permissions of collections under other dbs
R<RpcStatus> response = client.grantRolePrivilege(GrantRolePriviledgeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

R<SelectGrantResponse> grants = client.selectGrantForRole(SelectGrantForRoleParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

grants = client.selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

response = client.revokeRolePrivilege(RevokeRolePrivilegeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Global")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

const client = connectToMilvus("foo");

async function demo() {}
await client.createRole({
  roleName: ROLE_NAME,
});

const grants = await client.listGrants({
  roleName: ROLE_NAME,
});

console.log(grants.grants);

await client.revokePrivilege({
  roleName: ROLE_NAME,
  object: "Global",
  objectName: "*",
  privilege: PRIVILEGE_INSERT,
});

Milvus 연결에서 db_name 을 지정하거나 지정하지 않고 권한 API 호출이 수행되는 경우 데이터베이스는 권한 API 호출에 이름이 지정된 데이터베이스를 참조합니다.

파이썬 자바 Node.js

# NOTE: please make sure the 'foo' db has been created

db_name = "foo"
connect_to_milvus()
role.grant("Collection", "*", _PRIVILEGE_INSERT, db_name=db_name)
print(role.list_grants(db_name=db_name))
print(role.list_grant("Collection", "*", db_name=db_name))
role.revoke("Global", "*", _PRIVILEGE_INSERT, db_name=db_name)

// NOTE: please make sure the 'foo' db has been created

String dbName = "foo";
MilvusServiceClient client = new ConnectToMilvus().build();

R<RpcStatus> response = client.grantRolePrivilege(GrantRolePriviledgeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .withDatabaseName(dbName)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

R<SelectGrantResponse> grants = client.selectGrantForRole(SelectGrantForRoleParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withDatabaseName(dbName)
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

grants = client.selectGrantForRoleAndObject(SelectGrantForRoleAndObjectParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Collection")
    .withObjectName("*")
    .withDatabaseName(dbName)
    .build());

if (grants.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(grants.getMessage());
}

System.out.println(grants.getData());

response = client.revokeRolePrivilege(RevokeRolePrivilegeParam.newBuilder()
    .withRoleName(ROLE_NAME)
    .withObject("Global")
    .withObjectName("*")
    .withPrivilege(PRIVILEGE_INSERT)
    .withDatabaseName(dbName)
    .build());

if (response.getStatus() != R.Status.Success.getCode()) {
    throw new RuntimeException(response.getMessage());
}

// The Node.js SDK currently cannot support this case.

다음 단계

번역 DeepL

Try Managed Milvus for Free

Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.

Get Started

피드백

이 페이지가 도움이 되었나요?