Criar utilizadores e funções

O Milvus permite um controlo de acesso mais fino através do RBAC. Pode começar por criar utilizadores e funções, depois atribuir privilégios ou grupos de privilégios às funções e, por fim, gerir o controlo de acesso através da atribuição de funções aos utilizadores. Este método garante a eficiência e a segurança da gestão de acesso. Esta página apresenta a forma de criar utilizadores e funções no Milvus.

Utilizador

Após a inicialização de uma instância do Milvus, é gerado automaticamente um utilizador raiz para autenticação quando se liga ao Milvus pela primeira vez. O nome de utilizador do utilizador raiz é root e a palavra-passe é Milvus. A função predefinida do utilizador raiz é admin, que tem acesso a todos os recursos. Para garantir a segurança dos dados, mantenha as credenciais do utilizador raiz seguras para evitar o acesso não autorizado.

Para operações diárias, recomendamos a criação de utilizadores em vez de utilizar o utilizador raiz.

Criar um utilizador

O exemplo a seguir mostra como criar um usuário com o nome de usuário user_1 e a senha P@ssw0rd. O nome de utilizador e a palavra-passe do utilizador devem seguir estas regras:

• Nome de utilizador: Deve começar com uma letra e só pode incluir letras maiúsculas ou minúsculas, números e sublinhados.

• Palavra-passe: Deve ter entre 8 e 64 caracteres e deve incluir três das seguintes opções: letras maiúsculas, letras minúsculas, números e caracteres especiais.

from pymilvus import MilvusClient

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

client.create_user(user_name="user_1", password="P@ssw0rd")

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.rbac.request.CreateUserReq;

ConnectConfig connectConfig = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
        
MilvusClientV2 client = new MilvusClientV2(connectConfig);

CreateUserReq createUserReq = CreateUserReq.builder()
        .userName("user_1")
        .password("P@ssw0rd")
        .build();
        
client.createUser(createUserReq);

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.CreateUser(ctx, milvusclient.NewCreateUserOption("user_1", "P@ssw0rd"))
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.createUser({
   username: 'user_1',
   password: 'P@ssw0rd',
 });

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/users/create" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "userName": "user_1",
    "password": "P@ssw0rd"
}'

Atualizar palavra-passe

Depois de criar um utilizador, pode atualizar a palavra-passe caso se esqueça.

A nova palavra-passe também deve seguir a seguinte regra:

• Deve ter de 8 a 64 caracteres e incluir três dos seguintes: letras maiúsculas, letras minúsculas, números e caracteres especiais.

O exemplo a seguir mostra como atualizar a senha do usuário user_1 para NewP@ssw0rd.

from pymilvus import MilvusClient

client.update_password(
    user_name="user_1",
    old_password="P@ssw0rd",
    new_password="NewP@ssw0rd"
)

import io.milvus.v2.service.rbac.request.UpdatePasswordReq;

UpdatePasswordReq updatePasswordReq = UpdatePasswordReq.builder()
        .userName("user_1")
        .password("P@ssw0rd")
        .newPassword("NewP@ssw0rd")
        .build();
client.updatePassword(updatePasswordReq);

err = client.UpdatePassword(ctx, milvusclient.NewUpdatePasswordOption("user_1", "P@ssw0rd", "NewP@ssw0rd"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

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

await client.updateUser({
   username: 'user_1',
   newPassword: 'P@ssw0rd',
   oldPassword: 'NewP@ssw0rd',
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/users/update_password" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "newPassword": "P@ssw0rd!",
    "userName": "user_1",
    "password": "P@ssw0rd"
}'

Listar utilizadores

Depois de criar vários utilizadores, pode listar e visualizar todos os utilizadores existentes.

from pymilvus import MilvusClient

client.list_users()

List<String> resp = client.listUsers();

users, err := client.ListUsers(ctx, milvusclient.NewListUserOption())
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

await client.listUsers();

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/users/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{}'

Abaixo está um exemplo de saída. root é o utilizador predefinido gerado automaticamente em Milvus. user_1 é o novo utilizador que acabou de ser criado.

['root', 'user_1']

Função

O Milvus fornece uma função incorporada chamada admin, que é uma função de administrador que pode aceder a recursos em todas as instâncias e tem privilégios para todas as operações. Para uma gestão de acesso mais refinada e uma maior segurança dos dados, recomenda-se que crie funções personalizadas com base nas suas necessidades.

Criar uma função

O exemplo a seguir demonstra como criar uma função chamada role_a.

O nome da função deve seguir a seguinte regra:

• Deve começar com uma letra e só pode incluir letras maiúsculas ou minúsculas, números e sublinhados.

from pymilvus import MilvusClient

client.create_role(role_name="role_a")

import io.milvus.v2.service.rbac.request.CreateRoleReq;

CreateRoleReq createRoleReq = CreateRoleReq.builder()
        .roleName("role_a")
        .build();
       

err = client.CreateRole(ctx, milvusclient.NewCreateRoleOption("role_a"))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

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

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

Listar funções

Depois de criar várias funções, pode listar e visualizar todas as funções existentes.

from pymilvus import MilvusClient

client.list_roles()

List<String> roles = client.listRoles();

roles, err := client.ListRoles(ctx, milvusclient.NewListRoleOption())
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

await client.listRoles({
    includeUserInfo: true
});

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/roles/list" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{}'

Abaixo está um exemplo de saída. admin é a função padrão em Milvus. role_a é a nova função que acabou de ser criada.

['admin', 'role_a']