Conceder privilégios ou grupos de privilégios a funções

Uma vez criada uma função, pode conceder privilégios à mesma. Este guia apresenta a forma de conceder privilégios ou grupos de privilégios a uma função.

Conceder um privilégio ou um grupo de privilégios a uma função

O Milvus 2.5 introduz uma nova versão da API que simplifica a operação de concessão. Já não é necessário procurar o tipo de objeto quando se concede um privilégio a uma função. Seguem-se os parâmetros e as respectivas explicações.

• nome_da_função: o nome da função de destino à qual devem ser concedidos privilégios ou grupos de privilégios.

• Recurso: O recurso de destino de um privilégio, que pode ser uma instância específica, um banco de dados ou uma coleção.

A tabela a seguir explica como especificar o recurso no método client.grantV2().

 client.grant_privilege_v2(
     role_name="roleA", 
     privilege="CollectionAdmin",
     collection_name="col1", 
     db_name="db1"
 )

 client.grant_privilege_v2(
     role_name="roleA", 
     privilege="CollectionAdmin",
     collection_name="*", 
     db_name="db1"
 )

 client.grant_privilege_v2(
     role_name="roleA", 
     privilege="DatabaseAdmin", 
     collection_name="*", 
     db_name="db1"
 )

 client.grant_privilege_v2(
     role_name="roleA", 
     privilege="DatabaseAdmin", 
     collection_name="*", 
     db_name="*"
 )

 client.grant_privilege_v2(
     role_name="roleA", 
     privilege="ClusterAdmin", 
     collection_name="*", 
     db_name="*"
 )

• Privilégio: O privilégio específico ou o grupo de privilégios que é necessário conceder a uma função. Atualmente, o Milvus oferece 56 tipos de privilégios que podem ser concedidos. A tabela abaixo lista os privilégios no Milvus.

  A coluna do tipo na tabela abaixo é utilizada para facilitar a pesquisa rápida de privilégios e é utilizada apenas para fins de classificação. Ao conceder privilégios, não precisa de compreender os tipos. Basta introduzir os privilégios correspondentes.

  Tipo de privilégio	Privilégio	Descrição	Descrição da API relevante no lado do cliente
  Privilégios da base de dados	Listar bases de dados	Ver todas as bases de dados na instância atual	Listar bases de dados
  	DescreverBaseDeDados	Ver os detalhes de uma base de dados	DescreverBaseDeDados
  	CriarBaseDeDados	Criar uma base de dados	CreateDatabase
  	DropDatabase	Eliminar uma base de dados	DropDatabase
  	Alterar base de dados	Modificar as propriedades de uma base de dados	Alterar base de dados
  Privilégios da coleção	GetFlushState	Verificar o estado da operação de descarga da coleção	GetFlushState
  	GetLoadState	Verificar o estado de carregamento de uma coleção	GetLoadState
  	GetLoadingProgress	Verificar o progresso do carregamento de uma coleção	GetLoadingProgress
  	ShowCollections (Mostrar colecções)	Ver todas as colecções com privilégios de coleção	ShowCollections
  	ListAliases	Ver todos os aliases de uma coleção	ListAliases
  	Descrever coleção	Ver os detalhes de uma coleção	Descrever coleção
  	DescreverAlias	Ver os detalhes de um alias	DescreverAlias
  	Obter estatísticas	Obter as estatísticas de uma coleção (por exemplo, o número de entidades numa coleção)	Obter estatísticas da coleção
  	Criar coleção	Criar uma coleção	Criar coleção
  	DropCollection	Eliminar uma coleção	DropCollection
  	Carregar	Carregar uma coleção	LoadCollection/GetLoadingProgress/GetLoadState
  	Libertar	Libertar uma coleção	ReleaseCollection
  	Descarregar	Persiste todas as entidades numa coleção para um segmento selado. Qualquer entidade inserida após a operação de descarga será armazenada num novo segmento.	Flush/GetFlushState
  	Compactação	Acionar manualmente a compactação	Compactar
  	Renomear coleção	Renomear uma coleção	Renomear coleção
  	CriarAlias	Criar um pseudónimo para uma coleção	CriarAlias
  	DropAlias	Eliminar o nome alternativo de uma coleção	DropAlias
  	FlushAll	Elimina todas as colecções de uma base de dados	FlushAll
  Privilégios de partição	HasPartition	Verifica se existe uma partição	HasPartition
  	MostrarPartições	Ver todas as partições de uma coleção	MostrarPartições
  	CriarPartição	Criar uma partição	CriarPartição
  	DropPartition	Eliminar uma partição	DropPartition
  Privilégios do índice	Detalhes do índice	Ver os detalhes de um índice	DescreverIndex/GetIndexState/GetIndexBuildProgress
  	Criar índice	Criar um índice	CriarIndex
  	DropIndex	Eliminar um índice	DropIndex
  Privilégios de gestão de recursos	Balanceamento de carga	Alcançar o equilíbrio de carga	Balanceamento de carga
  	Criar grupo de recursos	Criar um grupo de recursos	CreateResourceGroup
  	DropResourceGroup	Eliminar um grupo de recursos	DropResourceGroup
  	UpdateResourceGroups (Atualizar grupos de recursos)	Atualizar um grupo de recursos	UpdateResourceGroups
  	Descrever o grupo de recursos	Visualizar os detalhes de um grupo de recursos	Descrever grupo de recursos
  	ListResourceGroups	Ver todos os grupos de recursos da instância atual	ListResourceGroups
  	TransferNode	Transferir nós entre grupos de recursos	TransferNode
  	TransferReplica	Transferir réplicas entre grupos de recursos	TransferirReplica
  	BackupRBAC	Criar uma cópia de segurança para todas as operações relacionadas com RBAC na instância atual	Cópia de segurançaRBAC
  	RestaurarRBAC	Restaurar uma cópia de segurança de todas as operações relacionadas com o RBAC na instância atual	RestaurarRBAC
  Privilégios da entidade	Consulta	Efetuar uma consulta	Consultar
  	Pesquisar	Efetuar uma pesquisa	Pesquisar
  	Inserir	Inserir entidades	Inserir
  	Eliminar	Eliminar entidades	Eliminar
  	Upsert	Inserir entidades	Upsert
  	Importar	Inserir ou importar entidades em massa	Inserir/Importar em massa
  Privilégios RBAC	Criar Propriedade	Criar um utilizador ou uma função	CriarUsuário/CriarFunção
  	Atualizar utilizador	Atualizar a palavra-passe de um utilizador	ActualizarCredencial
  	DropOwnership	Eliminar a palavra-passe de um utilizador ou uma função	ApagarCredencial/ApagarFunção
  	Selecionar propriedade	Ver todos os utilizadores a quem foi atribuída uma função específica	SelectRole/SelectGrant
  	GerirPropriedade	Gerir um utilizador ou uma função ou atribuir uma função a um utilizador	OperateUserRole/OperatePrivilege/OperatePrivilegeV2
  	SeleccionarUtilizador	Ver todas as funções atribuídas a um utilizador	Selecionar utilizador
  	Criar grupo de privilégios	Criar um grupo de privilégios	CreatePrivilegeGroup
  	DropPrivilegeGroup	Eliminar um grupo de privilégios	DropPrivilegeGroup
  	ListPrivilegeGroups	Ver todos os grupos de privilégios na instância atual	ListPrivilegeGroups
  	OperatePrivilegeGroup (Operar Grupo de Privilégios)	Adicionar privilégios a um grupo de privilégios ou remover privilégios de um grupo de privilégios	OperatePrivilegeGroup (Operar Grupo de Privilégios)

O exemplo a seguir demonstra como conceder o privilégio PrivilegeSearch em collection_01 no banco de dados default, bem como um grupo de privilégios chamado privilege_group_1 para a função role_a.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

client.grant_privilege_v2(
    role_name="role_a",
    privilege="Search",
    collection_name='collection_01',
    db_name='default',
)
    
client.grant_privilege_v2(
    role_name="role_a",
    privilege="privilege_group_1",
    collection_name='collection_01',
    db_name='default',
)

client.grant_privilege_v2(
    role_name="role_a",
    privilege="ClusterReadOnly",
    collection_name='*',
    db_name='*',
)

import io.milvus.v2.service.rbac.request.GrantPrivilegeReqV2

client.grantPrivilegeV2(GrantPrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("Search")
        .collectionName("collection_01")
        .dbName("default")
        .build());

client.grantPrivilegeV2(GrantPrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("privilege_group_1")
        .collectionName("collection_01")
        .dbName("default")
        .build());

client.grantPrivilegeV2(GrantPrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("ClusterReadOnly")
        .collectionName("*")
        .dbName("*")
        .build());

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}
defer client.Close(ctx)

err = client.GrantV2(ctx, milvusclient.NewGrantV2Option("role_a", "Search", "default", "collection_01"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.GrantV2(ctx, milvusclient.NewGrantV2Option("role_a", "privilege_group_1", "default", "collection_01"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.GrantV2(ctx, milvusclient.NewGrantV2Option("role_a", "ClusterReadOnly", "*", "*"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

const { MilvusClient, DataType } = require("@zilliz/milvus2-sdk-node")

const address = "http://localhost:19530";
const token = "root:Milvus";
const client = new MilvusClient({address, token});

await client.grantPrivilegeV2({
    role: "role_a",
    privilege: "Search"
    collection_name: 'collection_01'
    db_name: 'default',
});
    
await client.grantPrivilegeV2({
    role: "role_a",
    privilege: "privilege_group_1"
    collection_name: 'collection_01'
    db_name: 'default',
});

await client.grantPrivilegeV2({
    role: "role_a",
    privilege: "ClusterReadOnly"
    collection_name: '*'
    db_name: '*',
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/grant_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "Search",
    "collectionName": "collection_01",
    "dbName":"default"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/grant_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "privilege_group_1",
    "collectionName": "collection_01",
    "dbName":"default"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/grant_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "ClusterReadOnly",
    "collectionName": "*",
    "dbName":"*"
}'

Descrever uma função

O exemplo a seguir demonstra como visualizar os privilégios concedidos à função role_a usando o método describe_role.

from pymilvus import MilvusClient

client.describe_role(role_name="role_a")

import io.milvus.v2.service.rbac.response.DescribeRoleResp;
import io.milvus.v2.service.rbac.request.DescribeRoleReq

DescribeRoleReq describeRoleReq = DescribeRoleReq.builder()
        .roleName("role_a")
        .build();
DescribeRoleResp resp = client.describeRole(describeRoleReq);
List<DescribeRoleResp.GrantInfo> infos = resp.getGrantInfos();

import "github.com/milvus-io/milvus/client/v2/milvusclient"

role, err := client.DescribeRole(ctx, milvusclient.NewDescribeRoleOption("role_a"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

await client.describeRole({roleName: 'role_a'});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/describe" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a"
}'

Abaixo está um exemplo de saída.

{
     "role": "role_a",
     "privileges": [
         {
             "collection_name": "collection_01",
             "db_name": "default",
             "role_name": "role_a",
             "privilege": "Search",
             "grantor_name": "root"
         },
         "privilege_group_1"
     ]
}

Revogar um privilégio ou um grupo de privilégios de uma função

O exemplo a seguir demonstra como revogar o privilégio PrivilegeSearch em collection_01 no banco de dados default, bem como o grupo de privilégios privilege_group_1 que foram concedidos à função role_a.

client.revoke_privilege_v2(
    role_name="role_a",
    privilege="Search",
    collection_name='collection_01',
    db_name='default',
)
    
client.revoke_privilege_v2(
    role_name="role_a",
    privilege="privilege_group_1",
    collection_name='collection_01',
    db_name='default',
)

client.revoke_privilege_v2(
    role_name="role_a",
    privilege="ClusterReadOnly",
    collection_name='*',
    db_name='*',
)

import io.milvus.v2.service.rbac.request.RevokePrivilegeReqV2

client.revokePrivilegeV2(RevokePrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("Search")
        .collectionName("collection_01")
        .dbName("default")
        .build());

client.revokePrivilegeV2(RevokePrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("privilege_group_1")
        .collectionName("collection_01")
        .dbName("default")
        .build());

client.revokePrivilegeV2(RevokePrivilegeReqV2.builder()
        .roleName("role_a")
        .privilege("ClusterReadOnly")
        .collectionName("*")
        .dbName("*")
        .build());

err = client.RevokePrivilegeV2(ctx, milvusclient.NewRevokePrivilegeV2Option("role_a", "Search", "collection_01").
        WithDbName("default"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.RevokePrivilegeV2(ctx, milvusclient.NewRevokePrivilegeV2Option("role_a", "privilege_group_1", "collection_01").
    WithDbName("default"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

err = client.RevokePrivilegeV2(ctx, milvusclient.NewRevokePrivilegeV2Option("role_a", "ClusterReadOnly", "*").
    WithDbName("*"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

await client.revokePrivilegeV2({
    role: 'role_a',
    privilege: 'Search',
    collection_name: 'collection_01',
    db_name: 'default'
});

await client.revokePrivilegeV2({
    role: 'role_a',
    collection_name: 'collection_01',
    privilege: 'Search',
    db_name: 'default'
});

await client.revokePrivilegeV2({
    role: 'role_a',
    collection_name: '*',
    privilege: 'ClusterReadOnly',
    db_name: '*'
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/revoke_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "Search",
    "collectionName": "collection_01",
    "dbName":"default"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/revoke_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "Search",
    "collectionName": "collection_01",
    "dbName":"default"
}'

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/revoke_privilege_v2" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
--header "Request-Timeout: 10" \
-d '{
    "roleName": "role_a",
    "privilege": "ClusterReadOnly",
    "collectionName": "*",
    "dbName":"*"
}'