Gestion des bases de données

Comme pour les moteurs de base de données traditionnels, vous pouvez également créer des bases de données dans Milvus et attribuer des privilèges à certains utilisateurs pour les gérer. Ces utilisateurs ont alors le droit de gérer les collections dans les bases de données. Un cluster Milvus prend en charge un maximum de 64 bases de données.

Créer une base de données

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

Les extraits de code ci-dessus se connectent à la base de données par défaut et créent une nouvelle base de données nommée my_database.

Utiliser une base de données

Un cluster Milvus est livré avec une base de données par défaut, appelée "default". Les collections sont créées dans la base de données par défaut, sauf indication contraire.

Pour modifier la base de données par défaut, procédez comme suit :

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

Vous pouvez également définir une base de données à utiliser lors de la connexion à votre cluster Milvus comme suit :

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

Liste des bases de données

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

Abandonner une base de données

Pour supprimer une base de données, vous devez d'abord supprimer toutes ses collections. Sinon, l'abandon échoue.

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

Utiliser RBAC avec une base de données

RBAC couvre également les opérations de base de données et assure la compatibilité avec l'avenir. Le mot base de données dans les API de permission (Grant / Revoke / List Grant) a les significations suivantes :

• Si ni une connexion Milvus ni un appel à l'API de permission ne spécifie une db_name, la base de données fait référence à la base de données par défaut.
• Si une connexion Milvus spécifie un db_name, mais qu'un appel Permission API ultérieur ne le fait pas, la base de données renvoie à la base de données dont le nom a été spécifié dans la connexion Milvus.
• Si un appel Permission API est effectué sur une connexion Milvus, avec ou sans db_name, la base de données fait référence à la base de données dont le nom a été spécifié dans l'appel Permission API.

L'extrait de code suivant est partagé entre les blocs énumérés ci-dessous.

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

• Si aucune connexion Milvus ni aucun appel à l'API Permission ne spécifie une adresse db_name, la base de données renvoie à la base de données par défaut.

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

• Si une connexion Milvus spécifie un db_name, mais qu'un appel Permission API ultérieur ne le fait pas, la base de données renvoie à la base de données dont le nom a été spécifié dans la connexion 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,
  });
  

• Si un appel à l'API Permission est effectué sur une connexion Milvus, avec ou sans db_name, la base de données fait référence à la base de données dont le nom a été spécifié dans l'appel à l'API Permission.

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

Prochaines étapes

• Activer le RBAC

• Multi-tenance