milvus-logo
LFAI
Home
  • Leitfaden für die Verwaltung

Verschlüsselung bei der Übermittlung

TLS (Transport Layer Security) ist ein Verschlüsselungsprotokoll zur Gewährleistung der Kommunikationssicherheit. Milvus Proxy verwendet TLS für die einseitige und zweiseitige Authentifizierung.

In diesem Thema wird beschrieben, wie TLS in Milvus-Proxy sowohl für gRPC- als auch für RESTful-Verkehr aktiviert werden kann.

TLS und Benutzerauthentifizierung sind zwei unterschiedliche Sicherheitsansätze. Wenn Sie sowohl die Benutzerauthentifizierung als auch TLS in Ihrem Milvus-System aktiviert haben, müssen Sie einen Benutzernamen, ein Passwort und Pfade für Zertifikatsdateien angeben. Informationen zur Aktivierung der Benutzerauthentifizierung finden Sie unter Authentifizierung des Benutzerzugangs.

Erstellen Sie Ihr eigenes Zertifikat

Voraussetzungen

Stellen Sie sicher, dass OpenSSL installiert ist. Wenn Sie es nicht installiert haben, erstellen und installieren Sie zuerst OpenSSL.

openssl version

Wenn OpenSSL nicht installiert ist. Es kann mit dem folgenden Befehl in Ubuntu installiert werden.

sudo apt install openssl

Dateien erstellen

  1. Erstellen Sie die Datei gen.sh.
mkdir cert && cd cert
touch gen.sh
  1. Kopieren Sie das folgende Skript in die Datei gen.sh.

Es ist notwendig, die CommonName in der Datei gen.sh zu konfigurieren. Die CommonName bezieht sich auf den Servernamen, den der Client beim Verbindungsaufbau angeben muss.

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

Die Variablen in der Datei gen.sh sind für den Prozess der Erstellung einer Zertifikatsignierungsanforderungsdatei entscheidend. Die ersten fünf Variablen sind die grundlegenden Signierinformationen, einschließlich Land, Staat, Ort, Organisation und Organisationseinheit. Bei der Konfiguration von CommonName ist Vorsicht geboten, da sie während der Client-Server-Kommunikation überprüft wird.

Führen Sie gen.sh aus, um ein Zertifikat zu erzeugen

Führen Sie die Datei gen.sh aus, um das Zertifikat zu erstellen.

chmod +x gen.sh
./gen.sh

Die folgenden sieben Dateien werden erstellt: ca.key, ca.pem, ca.srl, server.key, server.pem, client.key, client.pem.

Achten Sie darauf, dass Sie die Dateien ca.key, ca.pem, ca.srl sicher aufbewahren, damit Sie Ihre Zertifikate später erneuern können. Die Dateien server.key und server.pem werden vom Server verwendet, während die Dateien client.key und client.pem vom Client verwendet werden.

Zertifikate erneuern (optional)

Wenn Sie die Zertifikate in einigen Fällen erneuern möchten, z. B. wenn sie bald ablaufen, können Sie das folgende Skript verwenden.

Sie benötigen ca.key, ca.pem, ca.srl in Ihrem Arbeitsverzeichnis.

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

Führen Sie die Datei renew.sh aus, um das Zertifikat zu erstellen.

chmod +x renew.sh
./renew.sh

Einrichten eines Milvus-Servers mit TLS

In diesem Abschnitt werden die Schritte zur Konfiguration eines Milvus-Servers mit TLS-Verschlüsselung beschrieben.

Einrichtung für Docker Compose

1. Ändern Sie die Konfiguration des Milvus-Servers

Um externes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei milvus.yaml hinzu:

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

Parameter:

  • serverPemPath: Der Pfad zur Serverzertifikatsdatei.
  • serverKeyPath: Der Pfad zur Server-Schlüsseldatei.
  • caPemPath: Der Pfad zur CA-Zertifikatsdatei.
  • tlsMode: Der TLS-Modus für den externen Dienst. Gültige Werte:
    • 1: Einweg-Authentifizierung, bei der nur der Server ein Zertifikat benötigt und der Client es verifiziert. Dieser Modus erfordert server.pem und server.key auf der Server-Seite und server.pem auf der Client-Seite.
    • 2: Zwei-Wege-Authentifizierung, bei der sowohl der Server als auch der Client Zertifikate benötigen, um eine sichere Verbindung herzustellen. Für diesen Modus sind server.pem, server.key und ca.pem auf der Serverseite und client.pem, client.key und ca.pem auf der Clientseite erforderlich.

Um internes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei milvus.yaml hinzu:

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

common:
  security:
    internaltlsEnabled: true

Parameter:

  • serverPemPath: Der Pfad zur Server-Zertifikatsdatei.
  • serverKeyPath: Der Pfad zur Server-Schlüsseldatei.
  • caPemPath: Der Pfad zur CA-Zertifikatsdatei.
  • internaltlsEnabled: Ob internes TLS aktiviert werden soll. Zur Zeit wird nur einseitiges TLS unterstützt.

2. Zertifikatsdateien dem Container zuordnen

Vorbereiten der Zertifikatsdateien

Erstellen Sie einen neuen Ordner mit dem Namen tls im gleichen Verzeichnis wie Ihr docker-compose.yaml. Kopieren Sie die Dateien server.pem, server.key und ca.pem in den Ordner tls. Legen Sie sie in einer Verzeichnisstruktur wie folgt ab:

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

Aktualisieren Sie die Konfiguration von Docker Compose

Bearbeiten Sie die Datei docker-compose.yaml, um die Pfade der Zertifikatsdateien innerhalb des Containers wie unten gezeigt zuzuordnen:

  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
Bereitstellen von Milvus mit Docker Compose

Führen Sie den folgenden Befehl aus, um Milvus bereitzustellen:

sudo docker compose up -d

Einrichtung für Milvus Operator

Legen Sie die Zertifikatsdateien in Ihrem Arbeitsverzeichnis ab. Die Verzeichnisstruktur sollte wie folgt aussehen:

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

Erstellen Sie ein Geheimnis mit den Zertifikatsdateien:

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

Um externes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei milvus.yaml hinzu:

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

Um internes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei milvus.yaml hinzu:

Denken Sie daran, das Feld internaltls.sni durch den CommonName in Ihren Zertifikaten zu ersetzen.

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

Erstellen Sie die Milvus CR:

kubectl create -f milvus.yaml

Einrichtung für Milvus Helm

Legen Sie die Zertifikatsdateien in Ihrem Arbeitsverzeichnis ab. Die Verzeichnisstruktur sollte wie folgt aussehen:

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

Erstellen Sie ein Geheimnis mit den Zertifikatsdateien:

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

Um externes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei values.yaml hinzu:

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

Um internes TLS zu aktivieren, fügen Sie die folgenden Konfigurationen in der Datei values.yaml hinzu:

Denken Sie daran, das Feld internaltls.sni durch den CommonName in Ihren Zertifikaten zu ersetzen.

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

Erstellen Sie die milvus-Version:

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

Überprüfen Sie, ob internes TLS aktiviert ist

Es ist schwierig, internes TLS direkt zu verifizieren. Sie können im Milvus-Protokoll nachsehen, ob internes TLS aktiviert ist.

Im Milvus-Protokoll sollten Sie die folgende Meldung sehen, wenn internes TLS aktiviert ist:

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

Verbindung zum Milvus-Server mit TLS

Verwenden Sie für SDK-Interaktionen je nach TLS-Modus die folgenden Konfigurationen.

Einseitige TLS-Verbindung

Geben Sie den Pfad zu server.pem an und stellen Sie sicher, dass server_name mit dem im Zertifikat konfigurierten CommonName übereinstimmt.

from pymilvus import MilvusClient

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

Zweiseitige TLS-Verbindung

Geben Sie die Pfade zu client.pem, client.key und ca.pem an und stellen Sie sicher, dass server_name mit dem im Zertifikat konfigurierten CommonName übereinstimmt.

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

Siehe example_tls1.py und example_tls2.py für weitere Informationen.

Verbinden mit dem Milvus RESTful Server mit TLS

Für RESTful-APIs können Sie tls mit dem Befehl curl überprüfen.

Einseitige TLS-Verbindung

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

Zwei-Wege-TLS-Verbindung

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

Übersetzt vonDeepL

Tabelle der Inhalte

Try Managed Milvus for Free

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

Get Started
Feedback

War diese Seite hilfreich?