milvus-logo
LFAI
Home
  • Guide d'administration

Cryptage en transit

TLS (Transport Layer Security) est un protocole de cryptage qui garantit la sécurité des communications. Le proxy Milvus utilise l'authentification unidirectionnelle et bidirectionnelle TLS.

Cette rubrique décrit comment activer TLS dans le proxy Milvus pour les trafics gRPC et RESTful.

TLS et l'authentification utilisateur sont deux approches de sécurité distinctes. Si vous avez activé l'authentification utilisateur et TLS dans votre système Milvus, vous devrez fournir un nom d'utilisateur, un mot de passe et des chemins d'accès aux fichiers de certificats. Pour plus d'informations sur l'activation de l'authentification de l'utilisateur, voir Authentifier l'accès de l'utilisateur.

Créer votre propre certificat

Conditions préalables

Assurez-vous qu'OpenSSL est installé. Si vous ne l'avez pas installé, compilez et installez d'abord OpenSSL.

openssl version

Si OpenSSL n'est pas installé. Il peut être installé avec la commande suivante dans Ubuntu.

sudo apt install openssl

Créer des fichiers

  1. Créez le fichier gen.sh.
mkdir cert && cd cert
touch gen.sh
  1. Copiez le script suivant dans le fichier gen.sh.

Il est nécessaire de configurer le CommonName dans le fichier gen.sh. Le CommonName fait référence au nom du serveur que le client doit spécifier lors de la connexion.

gen.sh

#!/usr/bin/env sh
# your variables
Country="US"
State="CA"
Location="Redwood City"
Organization="zilliz"
OrganizationUnit="devops"
CommonName="localhost"
ExpireDays=3650 # 10 years

# generate private key for ca, server and client
openssl genpkey -quiet -algorithm rsa:2048 -out ca.key
openssl genpkey -quiet -algorithm rsa:2048 -out server.key
openssl genpkey -quiet -algorithm rsa:2048 -out client.key

# create a new ca certificate
openssl req -x509 -new -nodes -key ca.key -sha256 -days 36500 -out ca.pem \
  -subj "/C=$Country/ST=$State/L=$Location/O=$Organization/OU=$OrganizationUnit/CN=$CommonName"

# prepare extension config for signing certificates
echo '[v3_req]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names
[alt_names]
DNS = '$CommonName > openssl.cnf

# sign server certificate with ca
openssl req -new -key server.key\
  -subj "/C=$Country/ST=$State/L=$Location/O=$Organization/OU=$OrganizationUnit/CN=$CommonName"\
  | openssl x509 -req -days $ExpireDays -out server.pem -CA ca.pem -CAkey ca.key -CAcreateserial \
    -extfile ./openssl.cnf -extensions v3_req

# sign client certificate with ca
openssl req -new -key client.key\
  -subj "/C=$Country/ST=$State/L=$Location/O=$Organization/OU=$OrganizationUnit/CN=$CommonName"\
  | openssl x509 -req -days $ExpireDays -out client.pem -CA ca.pem -CAkey ca.key -CAcreateserial \
    -extfile ./openssl.cnf -extensions v3_req

Les variables du fichier gen.sh sont essentielles au processus de création d'un fichier de demande de signature de certificat. Les cinq premières variables sont les informations de signature de base, notamment le pays, l'état, l'emplacement, l'organisation et l'unité d'organisation. Il convient d'être prudent lors de la configuration de CommonName, car ces informations seront vérifiées lors de la communication client-serveur.

Exécuter gen.sh pour générer le certificat

Exécutez le fichier gen.sh pour créer le certificat.

chmod +x gen.sh
./gen.sh

Les sept fichiers suivants seront créés : ca.key ca.pem , ca.srl, server.key, server.pem, client.key, client.pem.

Veillez à sécuriser les fichiers ca.key, ca.pem, ca.srl afin de pouvoir renouveler vos certificats ultérieurement. Les fichiers server.key et server.pem sont utilisés par le serveur, et les fichiers client.key et client.pem sont utilisés par le client.

Renouveler les certificats (optionnel)

Si vous souhaitez renouveler les certificats dans certains cas, par exemple s'ils expirent bientôt, vous pouvez utiliser le script suivant.

Vous avez besoin de ca.key, ca.pem, ca.srl dans votre répertoire de travail.

renew.sh

#!/usr/bin/env sh
# your variables
Country="US"
State="CA"
Location="Redwood City"
Organization="zilliz"
OrganizationUnit="devops"
CommonName="localhost"
ExpireDays=3650 # 10 years

# generate private key for ca, server and client
openssl genpkey -quiet -algorithm rsa:2048 -out server.key
openssl genpkey -quiet -algorithm rsa:2048 -out client.key

# prepare extension config for signing certificates
echo '[v3_req]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names
[alt_names]
DNS = '$CommonName > openssl.cnf

# sign server certificate with ca
openssl req -new -key server.key\
  -subj "/C=$Country/ST=$State/L=$Location/O=$Organization/OU=$OrganizationUnit/CN=$CommonName"\
  | openssl x509 -req -days $ExpireDays -out server.pem -CA ca.pem -CAkey ca.key -CAcreateserial \
    -extfile ./openssl.cnf -extensions v3_req

# sign client certificate with ca
openssl req -new -key client.key\
  -subj "/C=$Country/ST=$State/L=$Location/O=$Organization/OU=$OrganizationUnit/CN=$CommonName"\
  | openssl x509 -req -days $ExpireDays -out client.pem -CA ca.pem -CAkey ca.key -CAcreateserial \
    -extfile ./openssl.cnf -extensions v3_req

Exécutez le fichier renew.sh pour créer le certificat.

chmod +x renew.sh
./renew.sh

Configuration d'un serveur Milvus avec TLS

Cette section décrit les étapes de configuration d'un serveur Milvus avec le cryptage TLS.

Configuration pour Docker Compose

1. Modifier la configuration du serveur Milvus

Pour activer TLS externe, ajoutez les configurations suivantes dans le fichier milvus.yaml:

proxy:
  http:
    # for now milvus do not support config restful on same port with grpc
    # so we set to 8080, grpc will still use 19530
    port: 8080 
tls:
  serverPemPath: /milvus/tls/server.pem
  serverKeyPath: /milvus/tls/server.key
  caPemPath: /milvus/tls/ca.pem

common:
  security:
    tlsMode: 1

Paramètres :

  • serverPemPath: Le chemin d'accès au fichier de certificat du serveur.
  • serverKeyPath: Le chemin d'accès au fichier de clés du serveur.
  • caPemPath: Le chemin d'accès au fichier du certificat de l'autorité de certification.
  • tlsMode: Le mode TLS pour le service externe. Valeurs valides :
    • 1: Authentification unidirectionnelle, où seul le serveur a besoin d'un certificat et le client le vérifie. Ce mode nécessite server.pem et server.key du côté du serveur, et server.pem du côté du client.
    • 2: Authentification bidirectionnelle, où le serveur et le client ont tous deux besoin de certificats pour établir une connexion sécurisée. Ce mode nécessite server.pem, server.key, et ca.pem du côté serveur, et client.pem, client.key, et ca.pem du côté client.

Pour activer TLS interne, ajoutez les configurations suivantes dans le fichier milvus.yaml:

internaltls:
  serverPemPath: /milvus/tls/server.pem
  serverKeyPath: /milvus/tls/server.key
  caPemPath: /milvus/tls/ca.pem

common:
  security:
    internaltlsEnabled: true

Paramètres :

  • serverPemPath: Le chemin d'accès au fichier de certificat du serveur.
  • serverKeyPath: Le chemin d'accès au fichier de clés du serveur.
  • caPemPath: Le chemin d'accès au fichier du certificat de l'autorité de certification.
  • internaltlsEnabled: L'activation ou non de TLS interne. Pour l'instant, seul le TLS unidirectionnel est pris en charge.

2. Mapper les fichiers de certificats au conteneur

Préparer les fichiers de certificats

Créez un nouveau dossier nommé tls dans le même répertoire que votre docker-compose.yaml. Copiez les fichiers server.pem, server.key et ca.pem dans le dossier tls. Placez-les dans une structure de répertoire comme suit :

├── docker-compose.yml
├── milvus.yaml
└── tls
     ├── server.pem
     ├── server.key
     └── ca.pem

Mise à jour de la configuration de Docker Compose

Modifiez le fichier docker-compose.yaml pour mapper les chemins d'accès aux fichiers de certificats à l'intérieur du conteneur comme indiqué ci-dessous :

  standalone:
    container_name: milvus-standalone
    image: milvusdb/milvus:latest
    command: ["milvus", "run", "standalone"]
    security_opt:
    - seccomp:unconfined
    environment:
      ETCD_ENDPOINTS: etcd:2379
      MINIO_ADDRESS: minio:9000
    volumes:
      - ${DOCKER_VOLUME_DIRECTORY:-.}/volumes/milvus:/var/lib/milvus
      - ${DOCKER_VOLUME_DIRECTORY:-.}/tls:/milvus/tls
      - ${DOCKER_VOLUME_DIRECTORY:-.}/milvus.yaml:/milvus/configs/milvus.yaml
Déployer Milvus à l'aide de Docker Compose

Exécutez la commande suivante pour déployer Milvus :

sudo docker compose up -d

Configuration de l'opérateur Milvus

Placez les fichiers de certificat dans votre répertoire de travail. La structure du répertoire doit ressembler à ceci :

├── milvus.yaml (to be created later)
├── server.pem
├── server.key
└── ca.pem

Créez un secret avec les fichiers de certificat :

kubectl create secret generic certs --from-file=server.pem --from-file=server.key --from-file=ca.pem

Pour activer TLS externe, ajoutez les configurations suivantes dans le fichier milvus.yaml:

apiVersion: milvus.io/v1beta1
kind: Milvus
metadata:
  name: my-release
spec:
  config:
    proxy:
      http:
        # for now not support config restful on same port with grpc
        # so we set to 8080, grpc will still use 19530
        port: 8080 
    common:
      security:
        tlsMode: 1 # tlsMode for external service 1 for one-way TLS, 2 for Mutual TLS, 0 for disable
    tls:
      serverPemPath: /certs/server.pem
      serverKeyPath: /certs/server.key
      caPemPath: /certs/ca.pem
  components:
    # mount the certs secret to the milvus container
    volumes:
      - name: certs
        secret:
          secretName: certs
    volumeMounts:
      - name: certs
        mountPath: /certs
        readOnly: true

Pour activer le TLS interne, ajoutez les configurations suivantes dans le fichier milvus.yaml:

N'oubliez pas de remplacer le champ internaltls.sni par le CommonName dans vos certificats.

apiVersion: milvus.io/v1beta1
kind: Milvus
metadata:
  name: my-release
spec:
  config:
    proxy:
      http:
        # for now not support config restful on same port with grpc
        # so we set to 8080, grpc will still use 19530
        port: 8080 
    common:
      security:
        internaltlsEnabled: true # whether to enable internal tls
    # Configure tls certificates path for internal service
    internaltls:
      serverPemPath: /certs/server.pem
      serverKeyPath: /certs/server.key
      caPemPath: /certs/ca.pem
      sni: localhost # the CommonName in your certificates
  components:
    # mount the certs secret to the milvus container
    volumes:
      - name: certs
        secret:
          secretName: certs
    volumeMounts:
      - name: certs
        mountPath: /certs
        readOnly: true

créer le CR Milvus :

kubectl create -f milvus.yaml

configuration pour Milvus Helm

Placez les fichiers de certificats dans votre répertoire de travail. La structure du répertoire doit ressembler à ceci :

├── values.yaml (to be created later)
├── server.pem
├── server.key
└── ca.pem

Créez un secret avec les fichiers de certificat :

kubectl create secret generic certs --from-file=server.pem --from-file=server.key --from-file=ca.pem

Pour activer TLS externe, ajoutez les configurations suivantes dans le fichier values.yaml:

extraConfigFiles:
  user.yaml: |+
    proxy:
      http:
        # for now not support config restful on same port with grpc
        # so we set to 8080, grpc will still use 19530
        port: 8080 
    common:
      security:
        tlsMode: 1 # tlsMode for external service 1 means set to 2 to enable Mutual TLS
    # Configure tls certificates path for external service
    tls:
      serverPemPath: /certs/server.pem
      serverKeyPath: /certs/server.key
      caPemPath: /certs/ca.pem
# mount the certs secret to the milvus container
volumes:
  - name: certs
    secret:
      secretName: certs
volumeMounts:
  - name: certs
    mountPath: /certs
    readOnly: true

Pour activer le TLS interne, ajoutez les configurations suivantes dans le fichier values.yaml:

N'oubliez pas de remplacer le champ internaltls.sni par le CommonName dans vos certificats.

extraConfigFiles:
  user.yaml: |+
    common:
      security:
        internaltlsEnabled: true # whether to enable internal tls
    # Configure tls certificates path for internal service
    internaltls:
      serverPemPath: /certs/server.pem
      serverKeyPath: /certs/server.key
      caPemPath: /certs/ca.pem
      sni: localhost
# mount the certs secret to the milvus container
volumes:
  - name: certs
    secret:
      secretName: certs
volumeMounts:
  - name: certs
    mountPath: /certs
    readOnly: true

Créez la version milvus :

helm repo add milvus https://zilliztech.github.io/milvus-helm/
helm repo update milvus
helm install my-release milvus/milvus -f values.yaml

Vérification de l'activation du TLS interne

Il est difficile de vérifier directement le TLS interne. Vous pouvez consulter le journal Milvus pour voir si TLS interne est activé.

Dans le journal Milvus, vous devriez voir le message suivant si TLS interne est activé :

[...date time...] [INFO] [utils/util.go:56] ["Internal TLS Enabled"] [value=true]

Se connecter au serveur Milvus avec TLS

Pour les interactions SDK, utilisez les configurations suivantes en fonction du mode TLS.

Connexion TLS unidirectionnelle

Fournir le chemin d'accès à server.pem et s'assurer que server_name correspond à CommonName configuré dans le certificat.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="https://localhost:19530",
    secure=True,
    server_pem_path="path_to/server.pem",
    server_name="localhost"
)

Connexion TLS bidirectionnelle

Fournir les chemins d'accès à client.pem, client.key, et ca.pem, et s'assurer que server_name correspond à CommonName configuré dans le certificat.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="https://localhost:19530",
    secure=True,
    client_pem_path="path_to/client.pem",
    client_key_path="path_to/client.key",
    ca_pem_path="path_to/ca.pem",
    server_name="localhost"
)

Voir example_tls1.py et example_tls2.py pour plus d'informations.

Connexion au serveur RESTful Milvus avec TLS

Pour les API RESTful, vous pouvez vérifier tls à l'aide de la commande curl.

Connexion TLS unidirectionnelle

curl --cacert path_to/ca.pem https://localhost:8080/v2/vectordb/collections/list

Connexion TLS bidirectionnelle

curl --cert path_to/client.pem --key path_to/client.key --cacert path_to/ca.pem https://localhost:8080/v2/vectordb/collections/list

Traduit parDeepL

Table de contenu

Try Managed Milvus for Free

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

Get Started
Feedback

Cette page a-t - elle été utile ?