milvus-logo
LFAI
Home
  • Benutzerhandbuch

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.

Die Codeschnipsel auf dieser Seite verwenden das PyMilvus ORM-Modul zur Interaktion mit Milvus. Codeschnipsel mit dem neuen MilvusClient SDK werden bald verfügbar sein.

Datenbank erstellen

Verwenden Sie connect(), um sich mit dem Milvus-Server zu verbinden und create_database(), um eine neue Datenbank zu erstellen:

Verwenden Sie MilvusClient, um sich mit dem Milvus-Server zu verbinden, und createDatabase(), um eine neue Datenbank zu erstellen:

Verwenden Sie MilvusClient, um sich mit dem Milvus-Server zu verbinden, und createDatabase(), um eine neue Datenbank zu 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

Um alle vorhandenen Datenbanken in Ihrem Milvus-Cluster zu finden, verwenden Sie die Methode list_database():

Um alle existierenden Datenbanken in Ihrem Milvus-Cluster zu finden, verwenden Sie die Methode listDatabases():

Um alle vorhandenen Datenbanken in Ihrem Milvus-Cluster zu finden, verwenden Sie die Methode listDatabases():

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.

Um eine Datenbank zu löschen, verwenden Sie die Methode drop_database():

Um eine Datenbank zu löschen, verwenden Sie die dropDatabase() -Methode:

Um eine Datenbank zu löschen, verwenden Sie die dropDatabase() -Methode:

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.

    _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.

    # 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.

    # 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

Übersetzt vonDeepLogo

Try Managed Milvus for Free

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

Get Started
Feedback

War diese Seite hilfreich?