Verwalten von Datenbanken

Ähnlich wie bei herkömmlichen Datenbank-Engines können Sie auch in Milvus Datenbanken erstellen und bestimmten Benutzern Rechte zur Verwaltung dieser Datenbanken zuweisen. Diese Benutzer haben dann das Recht, die Sammlungen in den Datenbanken zu verwalten. Ein Milvus-Cluster unterstützt bis zu 64 Datenbanken.

Datenbank erstellen

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: ''
// }

Die obigen Codeschnipsel stellen eine Verbindung zur Standarddatenbank her und erstellen eine neue Datenbank namens my_database.

Eine Datenbank verwenden

Ein Milvus-Cluster wird mit einer Standarddatenbank mit dem Namen "default" ausgeliefert. Sammlungen werden in der Standarddatenbank erstellt, sofern nicht anders angegeben.

Um die Standarddatenbank zu ändern, gehen Sie wie folgt vor:

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);

Sie können auch eine Datenbank festlegen, die bei der Verbindung mit Ihrem Milvus-Cluster verwendet werden soll, wie folgt:

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 });

Datenbanken auflisten

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' ]

Datenbank löschen

Um eine Datenbank zu löschen, müssen Sie zuerst alle ihre Sammlungen löschen. Andernfalls schlägt das Löschen fehl.

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 mit Datenbank verwenden

RBAC deckt auch Datenbankoperationen ab und gewährleistet die Vorwärtskompatibilität. Das Wort Datenbank in den Permission APIs (Grant / Revoke / List Grant) hat die folgenden Bedeutungen:

• Wenn weder eine Milvus-Verbindung noch ein Permission-API-Aufruf eine db_name angibt, bezieht sich Datenbank auf die Standarddatenbank.
• Wenn eine Milvus-Verbindung eine db_name angibt, ein späterer Permission-API-Aufruf jedoch nicht, bezieht sich Datenbank auf die Datenbank, deren Name in der Milvus-Verbindung angegeben wurde.
• Wenn ein Permission-API-Aufruf auf eine Milvus-Verbindung erfolgt, mit oder ohne Angabe von db_name, bezieht sich die Datenbank auf die Datenbank, deren Name im Permission-API-Aufruf angegeben wurde.

Der folgende Codeschnipsel wird von den unten aufgeführten Blöcken gemeinsam genutzt.

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;
}

• Wenn weder in einer Milvus-Verbindung noch in einem Permission-API-Aufruf eine db_name angegeben ist, verweist die Datenbank auf die Standarddatenbank.

  Python JavaNode.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,
  });
  

• Wenn bei einer Milvus-Verbindung eine db_name angegeben wird, bei einem anschließenden Permission-API-Aufruf jedoch nicht, verweist die Datenbank auf die Datenbank, deren Name in der Milvus-Verbindung angegeben wurde.

  Python JavaNode.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,
  });
  

• Wenn ein Permission-API-Aufruf auf eine Milvus-Verbindung erfolgt, mit oder ohne Angabe von db_name, verweist die Datenbank auf die Datenbank, deren Name im Permission-API-Aufruf angegeben wurde.

  Python JavaNode.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.
  

Was kommt als Nächstes

• RBAC aktivieren

• Mehrmandantenfähigkeit