Gerir bases de dados

À semelhança dos motores de bases de dados tradicionais, também é possível criar bases de dados no Milvus e atribuir privilégios a determinados utilizadores para as gerir. Assim, esses utilizadores têm o direito de gerir as colecções nas bases de dados. Um cluster Milvus suporta um máximo de 64 bases de dados.

Criar base de dados

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

Os fragmentos de código acima ligam-se à base de dados predefinida e criam uma nova base de dados com o nome my_database.

Usar uma base de dados

Um cluster Milvus é fornecido com uma base de dados predefinida, denominada 'default'. As colecções são criadas na base de dados predefinida, salvo indicação em contrário.

Para alterar a base de dados predefinida, proceda da seguinte forma:

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

Também pode definir uma base de dados a utilizar ao ligar-se ao seu cluster Milvus da seguinte forma:

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

Listar bases de dados

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

Eliminar uma base de dados

Para eliminar uma base de dados, é necessário eliminar primeiro todas as suas colecções. Caso contrário, a eliminação falha.

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

Utilizar RBAC com base de dados

O RBAC também abrange as operações com bases de dados e assegura a compatibilidade futura. A palavra base de dados nas API de permissões (Grant / Revoke / List Grant) tem os seguintes significados:

• Se nem uma ligação Milvus nem uma chamada à API Permission especificarem uma db_name, a base de dados refere-se à base de dados predefinida.
• Se uma ligação Milvus especificar um db_name, mas uma chamada à API Permission não o fizer posteriormente, a base de dados refere-se à base de dados cujo nome foi especificado na ligação Milvus.
• Se for efectuada uma chamada à API de autorização sobre uma ligação Milvus, com ou sem db_name especificado, a base de dados refere-se à base de dados cujo nome foi especificado na chamada à API de autorização.

O seguinte excerto de código é partilhado entre os blocos listados abaixo.

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

• Se nem uma ligação Milvus nem uma chamada à API Permission especificarem um db_name, a base de dados refere-se à base de dados predefinida.

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

• Se uma ligação Milvus especificar um db_name, mas uma chamada à API Permission não o fizer posteriormente, a base de dados refere-se à base de dados cujo nome foi especificado na ligação Milvus.

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

• Se for efectuada uma chamada à API Permission numa ligação Milvus, com ou sem db_name especificado, a base de dados refere-se à base de dados cujo nome foi especificado na chamada à API Permission.

  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.
  

O que se segue

• Ativar o RBAC

• Multi-tenancy