Milvus Helm Charts

https://github.com/zilliztech/milvus-helm
Admin
Milvus Helm Charts provides official Kubernetes Helm charts for deploying, configuring, and managing...
Tokens:15,477
Snippets:201
Trust Score:9.8
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install with Custom Credentials

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Override default access and secret keys during installation.

```bash
$ helm install --set accessKey=myaccesskey,secretKey=mysecretkey --generate-name minio/minio
```

--------------------------------

### Install with Custom Release Name

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Deploy the chart with a specific release name.

```bash
$ helm install my-release minio/minio
```

--------------------------------

### Install MinIO Chart

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Deploy MinIO to the Kubernetes cluster using default settings.

```bash
$ helm install --namespace minio --generate-name minio/minio
```

--------------------------------

### Create Buckets During Installation

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Define buckets to be automatically created upon chart installation with specific policies and purge settings.

```bash
$ helm install --set buckets[0].name=bucket1,buckets[0].policy=none,buckets[0].purge=false minio/minio
```

--------------------------------

### Install MinIO with a YAML values file

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Deploys the MinIO server using a configuration file to define parameter values.

```bash
$ helm install --name my-release -f values.yaml minio/minio
```

--------------------------------

### Install MinIO with TLS Enabled

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Deploy the MinIO chart while referencing the previously created TLS secret.

```bash
$ helm install --set tls.enabled=true,tls.certSecret=tls-ssl-minio minio/minio
```

--------------------------------

### Install MinIO with Helm CLI arguments

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Deploys the MinIO server with specific configuration parameters passed directly via the command line.

```bash
$ helm install --name my-release --set persistence.size=1Ti minio/minio
```

--------------------------------

### Migrate to MinIO Operator

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Commands to remove the legacy repository and install the new MinIO operator.

```bash
helm repo remove minio
helm repo add minio https://operator.min.io/
helm install --namespace minio-operator --create-namespace --generate-name minio/minio-operator
kubectl apply -f https://github.com/minio/operator/blob/master/examples/tenant.yaml
```

--------------------------------

### Scale Milvus Query Node

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Example command to scale the number of query node replicas in an existing cluster.

```bash
# Helm v3.14.0+
$ helm upgrade --reset-then-reuse-values --install --set queryNode.replicas=2 my-release zilliztech/milvus
```

--------------------------------

### Upgrade to Milvus v2.5.16

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Commands to upgrade to v2.5.16, either enabling mixCoordinator or upgrading an existing mixCoordinator setup.

```bash
helm upgrade my-release zilliztech/milvus \
  --set image.all.tag="v2.5.16" \
  --set mixCoordinator.enabled=true \
  --set rootCoordinator.enabled=false \
  --set indexCoordinator.enabled=false \
  --set queryCoordinator.enabled=false \
  --set dataCoordinator.enabled=false \
  --reset-then-reuse-values \
  --version=4.2.58
```

```bash
helm upgrade my-release zilliztech/milvus \
  --set image.all.tag="v2.5.16" \
  --reset-then-reuse-values \
  --version=4.2.58
```

--------------------------------

### Configure MinIO Client (mc) for External Access

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/templates/NOTES.txt

Steps to retrieve credentials and configure the MinIO client alias for external LoadBalancer access.

```bash
ACCESS_KEY=$(kubectl get secret {{ template "minio.secretName" . }} --namespace {{ .Release.Namespace }} -o jsonpath="{.data.accesskey}" | base64 --decode)
SECRET_KEY=$(kubectl get secret {{ template "minio.secretName" . }} --namespace {{ .Release.Namespace }} -o jsonpath="{.data.secretkey}" | base64 --decode)
mc alias set {{ template "minio.fullname" . }} http://<External-IP>:{{ .Values.service.port }} "$ACCESS_KEY" "$SECRET_KEY" --api s3v4

mc ls {{ template "minio.fullname" . }}
```

--------------------------------

### Export Release Values for Upgrade

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Retrieve current configuration values to prepare for an upgrade.

```bash
$ helm get values my-release > old_values.yaml
```

--------------------------------

### Deploy MinIO NAS Gateway

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Provisions MinIO instances in NAS gateway mode backed by a single Persistent Volume.

```bash
$ helm install --set nasgateway.enabled=true minio/minio
```

```bash
$ helm install --set nasgateway.enabled=true,nasgateway.replicas=8 minio/minio
```

--------------------------------

### Deploy Standalone with Embedded ETCD and Local Storage

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Configuration and deployment steps for running Milvus standalone with embedded ETCD and local storage.

```bash
cat > values.yaml <<EOF
---
cluster:
  enabled: false

etcd:
  enabled: false

pulsarv3:
  enabled: false

minio:
  enabled: false
  tls:
    enabled: false

extraConfigFiles:
  user.yaml: |+
    etcd:
      use:
        embed: true
      data:
        dir: /var/lib/milvus/etcd
    common:
      storageType: local
EOF
```

```bash
helm upgrade --install -f values.yaml my-release zilliztech/milvus
```

--------------------------------

### Configure full TEI deployment parameters

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/tei/README.md

Define comprehensive settings for TEI deployment, including resources, persistence, and image specifications.

```yaml
modelId: "BAAI/bge-large-en-v1.5"    # Model ID
extraArgs: []                        # Additional command line arguments for TEI, such as "--max-batch-tokens=16384", "--max-client-batch-size=32", "--max-concurrent-requests=128", etc.
replicaCount: 1                      # Number of TEI replicas
image:
  repository: ghcr.io/huggingface/text-embeddings-inference  # Image repository
  tag: cpu-1.6                       # Image tag (CPU version)
  pullPolicy: IfNotPresent           # Image pull policy
service:
  type: ClusterIP                    # Service type
  port: 8080                         # Service port
  annotations: {}                    # Service annotations
  labels: {}                         # Service labels
resources:                           # Resource configuration
  requests:
    cpu: "4"                         # CPU request
    memory: "8Gi"                    # Memory request
  limits:
    cpu: "8"                         # CPU limit
    memory: "16Gi"                   # Memory limit
persistence:                         # Persistence storage configuration
  enabled: true                      # Enable persistence storage
  mountPath: "/data"                 # Mount path
  annotations: {}                    # Storage annotations
  persistentVolumeClaim:             # PVC configuration
    existingClaim: ""                # Use existing PVC
    storageClass:                    # Storage class
    accessModes: ReadWriteOnce       # Access modes
    size: 50Gi                       # Storage size
    subPath: ""                      # Sub path
nodeSelector: {}                     # Node selector
affinity: {}                         # Affinity configuration
tolerations: []                      # Tolerations
topologySpreadConstraints: []        # Topology spread constraints
extraEnv: []                         # Additional environment variables
```

--------------------------------

### Enable Proxy TLS via extraConfigFiles

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Configure TLS settings for the proxy service by providing paths to certificate and key files within the extra configuration.

```yaml
extraConfigFiles:
  user.yaml: |+
    #  Enable tlsMode and set the tls cert and key
       tls:
        serverPemPath: /etc/milvus/certs/tls.crt
        serverKeyPath: /etc/milvus/certs/tls.key
       common:
         security:
           tlsMode: 1
```

--------------------------------

### Configure MinIO Client (mc) for Local Access

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/templates/NOTES.txt

Steps to retrieve credentials from Kubernetes secrets and configure the MinIO client alias for local connections.

```bash
ACCESS_KEY=$(kubectl get secret {{ template "minio.secretName" . }} -o jsonpath="{.data.accesskey}" | base64 --decode)
SECRET_KEY=$(kubectl get secret {{ template "minio.secretName" . }} -o jsonpath="{.data.secretkey}" | base64 --decode)

mc alias set {{ template "minio.fullname" . }}-local http://localhost:{{ .Values.service.port }} "$ACCESS_KEY" "$SECRET_KEY" --api s3v4

mc ls {{ template "minio.fullname" . }}-local
```

--------------------------------

### Add MinIO Helm Repository

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Register the MinIO Helm repository to access the chart.

```bash
$ helm repo add minio https://helm.min.io/
```

--------------------------------

### Deploy Distributed MinIO

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Provisions a distributed MinIO server with a specified number of nodes.

```bash
$ helm install --set mode=distributed,replicas=8 minio/minio
```

```bash
$ helm install --set mode=distributed,replicas=8,zones=2 minio/minio
```

--------------------------------

### Access MinIO via Port Forwarding

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/templates/NOTES.txt

Commands to identify the pod name and establish a local port-forwarding connection for ClusterIP or NodePort services.

```bash
export POD_NAME=$(kubectl get pods --namespace {{ .Release.Namespace }} -l "release={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")

kubectl port-forward $POD_NAME 9000 --namespace {{ .Release.Namespace }}
```

--------------------------------

### Add and Update Helm Repository

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Commands to add the Zilliztech Helm repository and update local chart indices.

```bash
$ helm repo add zilliztech https://zilliztech.github.io/milvus-helm/
```

```bash
$ helm repo update
```

--------------------------------

### Use Existing Secret

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Configures MinIO to use a pre-existing Kubernetes secret for credentials.

```bash
$ kubectl create secret generic my-minio-secret --from-literal=accesskey=foobarbaz --from-literal=secretkey=foobarbazqux
```

```bash
$ helm install --set existingSecret=my-minio-secret minio/minio
```

--------------------------------

### Upgrade MinIO Helm Release

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Use this command to apply configuration changes from a values file to an existing MinIO release.

```bash
$ helm upgrade -f old_values.yaml my-release minio/minio
```

--------------------------------

### MinIO Bucket Management Helper Script

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/templates/_helper_create_bucket.txt

This script defines functions to interact with the MinIO client (mc) to manage buckets. It includes logic for connection retries, bucket existence checks, and policy configuration.

```shell
#!/bin/sh
set -e ; # Have script exit in the event of a failed command.

{{- if .Values.configPathmc }}
MC_CONFIG_DIR="{{ .Values.configPathmc }}"
MC="/usr/bin/mc --insecure --config-dir ${MC_CONFIG_DIR}"
{{- else }}
MC="/usr/bin/mc --insecure"
{{- end }}

# connectToMinio
# Use a check-sleep-check loop to wait for Minio service to be available
connectToMinio() {
  SCHEME=$1
  ATTEMPTS=0 ; LIMIT=29 ; # Allow 30 attempts
  set -e ; # fail if we can't read the keys.
  ACCESS=$(cat /config/accesskey) ; SECRET=$(cat /config/secretkey) ;
  set +e ; # The connections to minio are allowed to fail.
  echo "Connecting to Minio server: $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT" ;
  MC_COMMAND="${MC} config host add myminio $SCHEME://$MINIO_ENDPOINT:$MINIO_PORT $ACCESS $SECRET" ;
  $MC_COMMAND ;
  STATUS=$? ;
  until [ $STATUS = 0 ]
  do
    ATTEMPTS=`expr $ATTEMPTS + 1` ;
    echo \"Failed attempts: $ATTEMPTS\" ;
    if [ $ATTEMPTS -gt $LIMIT ]; then
      exit 1 ;
    fi ;
    sleep 2 ; # 1 second intervals between attempts
    $MC_COMMAND ;
    STATUS=$? ;
  done ;
  set -e ; # reset `e` as active
  return 0
}

# checkBucketExists ($bucket)
# Check if the bucket exists, by using the exit code of `mc ls`
checkBucketExists() {
  BUCKET=$1
  CMD=$(${MC} ls myminio/$BUCKET > /dev/null 2>&1)
  return $?
}

# createBucket ($bucket, $policy, $purge)
# Ensure bucket exists, purging if asked to
createBucket() {
  BUCKET=$1
  POLICY=$2
  PURGE=$3
  VERSIONING=$4

  # Purge the bucket, if set & exists
  # Since PURGE is user input, check explicitly for `true`
  if [ $PURGE = true ]; then
    if checkBucketExists $BUCKET ; then
      echo "Purging bucket '$BUCKET'."
      set +e ; # don't exit if this fails
      ${MC} rm -r --force myminio/$BUCKET
      set -e ; # reset `e` as active
    else
      echo "Bucket '$BUCKET' does not exist, skipping purge."
    fi
  fi

  # Create the bucket if it does not exist
  if ! checkBucketExists $BUCKET ; then
    echo "Creating bucket '$BUCKET'"
    ${MC} mb myminio/$BUCKET
  else
    echo "Bucket '$BUCKET' already exists."
  fi


  # set versioning for bucket
  if [ ! -z $VERSIONING ] ; then
    if [ $VERSIONING = true ] ; then
        echo "Enabling versioning for '$BUCKET'"
        ${MC} version enable myminio/$BUCKET
    elif [ $VERSIONING = false ] ; then
        echo "Suspending versioning for '$BUCKET'"
        ${MC} version suspend myminio/$BUCKET
    fi
  else
      echo "Bucket '$BUCKET' versioning unchanged."
  fi

  # At this point, the bucket should exist, skip checking for existence
  # Set policy on the bucket
  echo "Setting policy of bucket '$BUCKET' to '$POLICY'."
  ${MC} policy set $POLICY myminio/$BUCKET
}

# Try connecting to Minio instance
{{- if .Values.tls.enabled }}
scheme=https
{{- else }}
scheme=http
{{- end }}
connectToMinio $scheme

{{- if or .Values.defaultBucket.enabled }}
# Create the bucket
createBucket {{ .Values.defaultBucket.name }} {{ .Values.defaultBucket.policy }} {{ .Values.defaultBucket.purge }} {{ .Values.defaultBucket.versioning }}
{{ else if .Values.buckets }}
# Create the buckets
{{- range .Values.buckets }}
createBucket {{ .name }} {{ .policy }} {{ .purge }} {{ .versioning }}
{{- end }}
{{- end }}
```

--------------------------------

### Complete TEI Configuration Options

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

A comprehensive list of configuration parameters for the TEI service, including resource limits, persistence, and environment variables.

```yaml
tei:
  enabled: true                        # Enable TEI service
  name: text-embeddings-inference      # Service name
  replicas: 1                          # Number of TEI replicas
  image:
    repository: ghcr.io/huggingface/text-embeddings-inference  # Image repository
    tag: cpu-1.6                       # Image tag (CPU version)
    pullPolicy: IfNotPresent           # Image pull policy
  service:
    type: ClusterIP                    # Service type
    port: 8080                         # Service port
    annotations: {}                    # Service annotations
    labels: {}                         # Service labels
  resources:                           # Resource configuration
    requests:
      cpu: "4"                         # CPU request
      memory: "8Gi"                    # Memory request
    limits:
      cpu: "8"                         # CPU limit
      memory: "16Gi"                   # Memory limit
  persistence:                         # Persistence storage configuration
    enabled: true                      # Enable persistence storage
    mountPath: "/data"                 # Mount path
    annotations: {}                    # Storage annotations
    persistentVolumeClaim:             # PVC configuration
      existingClaim: ""                # Use existing PVC
      storageClass:                    # Storage class
      accessModes: ReadWriteOnce       # Access modes
      size: 50Gi                       # Storage size
      subPath: ""                      # Sub path
  modelId: "BAAI/bge-large-en-v1.5"    # Model ID
  extraArgs: []                        # Additional command line arguments for TEI, such as "--max-batch-tokens=16384", "--max-client-batch-size=32", "--max-concurrent-requests=128", etc.
  nodeSelector: {}                     # Node selector
  affinity: {}                         # Affinity configuration
  tolerations: []                      # Tolerations
  topologySpreadConstraints: []        # Topology spread constraints
  extraEnv: []                         # Additional environment variables
```

--------------------------------

### Configure Persistence

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Manages persistent storage settings, including disabling PVCs or using existing claims.

```bash
$ helm install --set persistence.enabled=false minio/minio
```

```bash
$ helm install --set persistence.existingClaim=PVC_NAME minio/minio
```

--------------------------------

### Configure Proxy TLS via CLI

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Set TLS certificate and key values directly via the Helm CLI using base64 encoding.

```bash
  --set proxy.tls.enabled=true \
  --set prox.tls.key=$(cat /path/to/private_key_file | base64 -w 0) \
  --set prox.tls.crt=$(cat /path/to/certificate_file | base64 -w 0)
```

--------------------------------

### Check Coordinator Pods

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Command to inspect current coordinator pods to determine if a migration to mixCoordinator is required.

```bash
kubectl get pods
```

--------------------------------

### Create Trusted Certificates Secret

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Create Kubernetes secrets for third-party CA certificates.

```bash
kubectl -n minio create secret generic minio-trusted-certs --from-file=public.crt --from-file=keycloak.crt
```

```bash
kubectl -n minio create secret generic minio-trusted-certs --from-file=keycloak.crt
```

--------------------------------

### Enable Milvus Mix Coordinator Active Standby

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Use this command to deploy multiple mix coordinator pods for high availability.

```bash
helm upgrade --install my-release zilliztech/milvus --set mixCoordinator.activeStandby.enabled=true --set mixCoordinator.replicas=2
```

--------------------------------

### Enable File-based Logging

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Configure Milvus to output logs to a file instead of stdout. Requires a storage class with ReadWriteMany access mode.

```bash
# Install a milvus cluster with file log output
helm install my-release zilliztech/milvus --set log.persistence.enabled=true --set log.persistence.persistentVolumeClaim.storageClass=<read-write-many-storageclass>
```

--------------------------------

### Deploy MinIO in distributed mode

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Configures the MinIO deployment to run in distributed mode instead of the default standalone mode.

```bash
$ helm install --set mode=distributed minio/minio
```

--------------------------------

### Deploy Milvus Standalone Mode

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Commands to deploy Milvus in standalone mode with different message queue backends.

```bash
# Helm v3.x
$ helm upgrade --install my-release --set cluster.enabled=false --set etcd.replicaCount=1 --set pulsarv3.enabled=false --set minio.mode=standalone zilliztech/milvus
```

```bash
# Helm v3.x
# Milvus Standalone with pulsar as message queue
$ helm upgrade --install my-release --set cluster.enabled=false --set standalone.messageQueue=pulsar --set etcd.replicaCount=1 --set pulsarv3.enabled=true --set minio.mode=standalone zilliztech/milvus
```

```bash
# Helm v3.x
# Milvus Standalone with kafka as message queue
$ helm upgrade --install my-release --set cluster.enabled=false --set standalone.messageQueue=kafka --set etcd.replicaCount=1 --set pulsarv3.enabled=false --set kafka.enabled=true --set minio.mode=standalone zilliztech/milvus
```

--------------------------------

### Configure basic TEI model

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/tei/README.md

Set the model ID to initialize the TEI service.

```yaml
modelId: "BAAI/bge-large-en-v1.5"  # Specify the model to use
```

--------------------------------

### Configure Dependency Tolerations

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/tolerations-configuration-guide.md

Sets specific tolerations for Milvus dependencies including MinIO, Etcd, Pulsar, and Kafka.

```yaml
minio:
  tolerations: []  # Specific tolerations for MinIO pods
```

```yaml
etcd:
  tolerations: []  # Specific tolerations for etcd pods
```

```yaml
pulsar:
  tolerations: {}  # Specific tolerations for Pulsar
  
  # Component-specific tolerations
  zookeeper:
    tolerations: []
  
  bookkeeper:
    tolerations: []
    
  broker:
    tolerations: []
    
  proxy:
    tolerations: []
```

```yaml
kafka:
  tolerations: []  # Specific tolerations for Kafka brokers
  
  zookeeper:
    tolerations: []  # Specific tolerations for Kafka's ZooKeeper
```

--------------------------------

### Deploy Milvus Cluster Mode

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Commands to deploy Milvus in cluster mode using default or Kafka message queues.

```bash
# Helm v3.x
$ helm upgrade --install my-release zilliztech/milvus
```

```bash
# Helm v3.x
$ helm upgrade --install my-release zilliztech/milvus --set pulsarv3.enabled=false --set kafka.enabled=true
```

--------------------------------

### Configure GPU Acceleration for TEI

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

Configuration snippet to enable GPU support for TEI by updating the image tag and resource limits.

```yaml
tei:
  enabled: true
  modelId: "BAAI/bge-large-en-v1.5"
  image:
    repository: ghcr.io/huggingface/text-embeddings-inference
    tag: 1.6  # GPU version
  resources:
    limits:
      nvidia.com/gpu: 1  # Allocate 1 GPU
```

--------------------------------

### Configure Milvus via extraConfigFiles

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Use the extraConfigFiles section in your values file to define configuration parameters that are no longer supported as direct shortcut options.

```yaml
extraConfigFiles:
  user.yaml: |+
    dataCoord:
      segment:
        maxSize: 1024
```

--------------------------------

### Configure Dependency Node Selectors

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/node-selector-configuration-guide.md

Sets node selector constraints for external dependencies like MinIO, etcd, Pulsar, and Kafka.

```yaml
minio:
  # MinIO will be scheduled on nodes with storage=high-performance label
  nodeSelector:
    storage: high-performance
    component: storage
```

```yaml
etcd:
  # Etcd will be scheduled on nodes with component=etcd and storage=fast label
  nodeSelector:
    component: etcd
    storage: fast
```

```yaml
pulsar:
  zookeeper:
    # Pulsar zookeeper will be scheduled on nodes with component=zookeeper label
    nodeSelector:
      component: zookeeper
  
  bookkeeper:
    # Pulsar bookkeeper will be scheduled on nodes with component=bookkeeper and storage=fast label
    nodeSelector:
      component: bookkeeper
      storage: fast
  
  broker:
    # Pulsar broker will be scheduled on nodes with component=broker label
    nodeSelector:
      component: broker
  
  proxy:
    # Pulsar proxy will be scheduled on nodes with component=pulsar-proxy label
    nodeSelector:
      component: pulsar-proxy

  autorecovery:
    # Pulsar autorecovery will be scheduled on nodes with component=autorecovery label
    nodeSelector:
      component: autorecovery
```

```yaml
kafka:
  # Kafka will be scheduled on nodes with component=kafka and storage=fast label
  nodeSelector:
    component: kafka
    storage: fast
  
  zookeeper:
    # Kafka zookeeper will be scheduled on nodes with component=zookeeper label
    nodeSelector:
      component: zookeeper
```

--------------------------------

### Create TLS Secret for MinIO

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Create a Kubernetes generic secret containing the private key and public certificate for TLS termination.

```bash
$ kubectl create secret generic tls-ssl-minio --from-file=path/to/private.key --from-file=path/to/public.crt
```

--------------------------------

### Configure NetworkPolicy

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Enables network isolation for MinIO pods using Kubernetes NetworkPolicy.

```bash
kubectl annotate namespace default "net.beta.kubernetes.io/network-policy={\"ingress\":{\"isolation\":\"DefaultDeny\"}}"
```

--------------------------------

### Enable TEI in values.yaml

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

The minimal configuration required to enable the TEI service within the Milvus Helm chart.

```yaml
tei:
  enabled: true
  modelId: "BAAI/bge-large-en-v1.5"  # Specify the model to use
```

--------------------------------

### Define a basic node selector

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/node-selectors-vs-node-affinity.md

Use this configuration for simple, hard constraints requiring a specific node label.

```yaml
nodeSelector:
  disktype: ssd
```

--------------------------------

### Upgrade to Milvus v2.6.x

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Command to upgrade an existing v2.5.16 cluster to v2.6.x.

```bash
helm upgrade my-release zilliztech/milvus \
  --set image.all.tag="v2.6.x" \
  --set streaming.enabled=true \
  --set indexNode.enabled=false \
  --reset-then-reuse-values \
  --version=5.0.0
```

--------------------------------

### Retrieve External IP for LoadBalancer

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/templates/NOTES.txt

Command to fetch the external IP address assigned to the MinIO service when using a LoadBalancer.

```bash
kubectl get svc --namespace {{ .Release.Namespace }} -l app={{ template "minio.fullname" . }}
```

--------------------------------

### Co-locate MinIO with High-Performance Storage

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Uses node affinity to pin MinIO pods to nodes labeled for high-performance storage.

```yaml
# Co-locate MinIO with high-performance storage
minio:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          # Must run on nodes with storage-type=ssd label
          - key: storage-type
            operator: In
            values:
            - high-performance-storage
```

--------------------------------

### Upgrade Milvus Chart Repository

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Commands to update the Milvus Helm chart repository during the upgrade process.

```bash
helm repo add zilliztech https://zilliztech.github.io/milvus-helm
helm repo update zilliztech
```

--------------------------------

### Pass Environment Variables to MinIO

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Inject custom environment variables into MinIO containers using the Helm set flag.

```bash
$ helm install --set environment.MINIO_BROWSER=on,environment.MINIO_DOMAIN=domain-name minio/minio
```

--------------------------------

### Configure Global Node Selector

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/node-selector-configuration-guide.md

Applies node selector constraints to all Milvus components by default.

```yaml
# Global node selector

# Milvus components will be scheduled on nodes with ssd disk and compute-optimized instance type
nodeSelector:
  disk: ssd
  instance-type: compute-optimized
```

--------------------------------

### Configure Optional Component Tolerations

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/tolerations-configuration-guide.md

Overrides global tolerations for optional components like standalone or streaming nodes.

```yaml
standalone:
  tolerations: []  # Overrides global tolerations for standalone
```

```yaml
streamingNode:
  tolerations: []  # Overrides global tolerations for streamingNode
```

--------------------------------

### Configure Trusted Certificates via Helm

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Pass the trusted certificates secret name to the Helm chart.

```yaml
trustedCertsSecret: "minio-trusted-certs"
```

```bash
--set trustedCertsSecret=minio-trusted-certs
```

--------------------------------

### Test TEI Service Connectivity

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

Use these commands to verify the TEI service endpoint and test embedding generation via curl.

```bash
# Get the TEI service endpoint
export TEI_SERVICE=$(kubectl get svc -l component=text-embeddings-inference -o jsonpath='{.items[0].metadata.name}')

# Test the embedding functionality
kubectl run -it --rm curl --image=curlimages/curl -- curl -X POST "http://${TEI_SERVICE}:8080/embed" \
  -H "Content-Type: application/json" \
  -d '{"inputs":"This is a test text"}'
```

--------------------------------

### Uninstall MinIO Release

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/minio/README.md

Remove the MinIO release and associated Kubernetes components.

```bash
$ helm delete my-release
```

```bash
$ helm uninstall my-release
```

--------------------------------

### Distribute Coordinators Across Zones

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Uses pod anti-affinity to prevent multiple coordinator pods from residing in the same zone.

```yaml
# Distribute coordinators across zones
mixCoordinator:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          # Avoid nodes that already have pods with component=coordinator label
          - key: component
            operator: In
            values:
            - coordinator
        topologyKey: "topology.kubernetes.io/zone"
```

--------------------------------

### Distribute etcd Across Zones

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Uses pod anti-affinity to ensure etcd instances are spread across different availability zones.

```yaml
# Distribute etcd across zones
etcd:
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
          # Avoid nodes that already have pods with app=etcd label
          - key: app
            operator: In
            values:
            - etcd
        topologyKey: "topology.kubernetes.io/zone"
```

--------------------------------

### Configure Proxy TLS Secret

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Define the TLS secret and base64-encoded certificate data in your values file.

```yaml
proxy:
  enabled: true
  tls:
    enabled: true
    secretName: milvus-tls
  #expecting base64 encoded values here: i.e. $(cat tls.crt | base64 -w 0) and $(cat tls.key | base64 -w 0)
    key: LS0tLS1C....
    crt: LS0tLS1CR...
```

--------------------------------

### Configure External S3 Storage for Milvus

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Use this configuration to integrate Milvus with AWS S3 by disabling the internal MinIO and providing external credentials.

```yaml
minio:
  enabled: false
externalS3:
  enabled: true
  cloudProvider: aws
  host: s3.aws.com
  port: 443
  useSSL: true
  bucketName: <bucket-name>
  accessKey: <s3-access-key>
  secretKey: <s3-secret-key>
```

--------------------------------

### Search with Automatic Query Embedding

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

Perform a search using raw text, allowing Milvus to automatically convert the query into a vector via the TEI service.

```python
# Search directly using text, Milvus will automatically call the TEI service to generate query vectors
results = client.search(
    collection_name="test_collection",
    data=["Tell me about AI technology"],
    anns_field="embedding",
    search_params={
        "metric_type": "COSINE",
        "params": {}
    },
    limit=3
)
```

--------------------------------

### Uninstall Milvus Helm Release

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Standard command to remove the Milvus release using Helm v3.

```bash
# Helm v3.x
$ helm uninstall my-release
```

--------------------------------

### Configure Pod Affinity

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Prefers scheduling pods on nodes that already host pods with specific labels.

```yaml
podAffinity:
  preferredDuringSchedulingIgnoredDuringExecution:
  - weight: 100
    podAffinityTerm:
      labelSelector:
        matchExpressions:
        # Must run on pods with app=cache label
        - key: app
          operator: In
          values:
          - cache
      topologyKey: kubernetes.io/hostname
```

--------------------------------

### Configure Core Component Tolerations

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/tolerations-configuration-guide.md

Overrides global tolerations for specific Milvus core components.

```yaml
proxy:
  tolerations: []  # Overrides global tolerations for proxy
```

```yaml
mixCoordinator:
  tolerations: []  # Overrides global tolerations for mixCoordinator
```

```yaml
queryNode:
  tolerations: []  # Overrides global tolerations for queryNode
```

```yaml
indexNode:
  tolerations: []  # Overrides global tolerations for indexNode
```

```yaml
dataNode:
  tolerations: []  # Overrides global tolerations for dataNode
```

--------------------------------

### Configure Global Tolerations

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/tolerations-configuration-guide.md

Sets default tolerations applied to all Milvus components when no component-specific override is provided.

```yaml
tolerations: []  # Global tolerations applied to all Milvus components
```

```yaml
tolerations:
  # Allow scheduling on nodes dedicated to Milvus
  - key: "dedicated"
    operator: "Equal"
    value: "milvus"
    effect: "NoSchedule"
    
  # Allow scheduling on nodes with high memory usage
  - key: "memory-intensive"
    operator: "Exists"
    effect: "PreferNoSchedule"
```

--------------------------------

### Mount Custom TLS Volumes

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README.md

Define custom volume mounts for TLS secrets if using a non-default secret name or path.

```yaml
  volumes:
  - secret:
      secretName: Your-tls-secret-name
    name: milvus-tls
  volumeMounts:
  - mountPath: /Your/tls/files/path/
    name: milvus-tls
```

--------------------------------

### Configure Milvus Collection with TEI Embedding Function

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

Define a schema and embedding function in Milvus to automatically process text using a TEI provider.

```python
from pymilvus import MilvusClient, DataType, Function, FunctionType

# Connect to Milvus
client = MilvusClient(uri="http://localhost:19530")

# 1. Create schema
schema = client.create_schema()

# 2. Add fields
schema.add_field("id", DataType.INT64, is_primary=True, auto_id=False)  # Primary key
schema.add_field("text", DataType.VARCHAR, max_length=65535)             # Text field
schema.add_field("embedding", DataType.FLOAT_VECTOR, dim=768)              # Vector field, dimension must match TEI model output

# 3. Define TEI embedding function
tei_embedding_function = Function(
    name="tei_func",                            # Unique identifier for this embedding function
    function_type=FunctionType.TEXTEMBEDDING,   # Indicates a text embedding function
    input_field_names=["text"],                # Scalar field(s) containing text data to embed
    output_field_names=["embedding"],             # Vector field(s) for storing embeddings
    params={                                    # TEI specific parameters
        "provider": "TEI",                   # Must be set to "TEI"
        "endpoint": "http://tei-service:8080", # TEI service address
        # Optional: "api_key": "your_secure_api_key",
        # Optional: "truncate": "true",
        # Optional: "truncation_direction": "right",
        # Optional: "max_client_batch_size": 64,
        # Optional: "ingestion_prompt": "passage: ",
        # Optional: "search_prompt": "query: "
    }
)
schema.add_function(tei_embedding_function)

# 4. Create collection with schema and index param
index_params = client.prepare_index_params()
index_params.add_index(
    field_name="embedding",
    index_name="embedding_index",
    index_type="HNSW",
    metric_type="COSINE",
)
client.create_collection(
    name="test_collection",
    schema=schema,
    index_params=index_params
)
client.load_collection(
    collection_name="test_collection"
)
```

--------------------------------

### Configure Global SecurityContext

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/security-context-configuration-guide.md

Defines the global securityContext applied to all Milvus components.

```yaml
securityContext: {}  # Global securityContext applied to all Milvus components
```

```yaml
securityContext:
  runAsNonRoot: true
  runAsUser: 1000
  runAsGroup: 1000
  fsGroup: 1000
```

--------------------------------

### Configure Node Affinity

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Restricts pod scheduling to nodes matching specific instance types using nodeSelectorTerms.

```yaml
nodeAffinity:
  requiredDuringSchedulingIgnoredDuringExecution:
    nodeSelectorTerms:
    - matchExpressions:
      # Must run on nodes with kubernetes.io/instance-type=m5.2xlarge or m5.4xlarge label
      - key: kubernetes.io/instance-type
        operator: In
        values:
        - m5.2xlarge
        - m5.4xlarge
```

--------------------------------

### Optimize Pulsar BookKeeper Performance

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Pins BookKeeper pods to storage-optimized nodes using node affinity.

```yaml
# For Pulsar BookKeeper optimal performance
pulsar:
  bookkeeper:
    affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            # Must run on nodes with node-type=storage-optimized label
            - key: node-type
              operator: In
              values:
              - storage-optimized
```

--------------------------------

### Insert Data with Automatic Embedding

Source: https://github.com/zilliztech/milvus-helm/blob/master/charts/milvus/README-TEI.md

Insert raw text into a collection configured with a TEI embedding function to trigger automatic vector generation.

```python
# Insert data, Milvus will automatically call the TEI service to generate embedding vectors
client.insert(
    collection_name="test_collection",
    data=[
        {"id": 1, "text": "This is a sample document about artificial intelligence."},
        {"id": 2, "text": "Vector databases are designed to handle embeddings efficiently."}
    ]
)
```

--------------------------------

### Configure Pod Anti-Affinity

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Prevents pods from being scheduled on nodes that already host pods with the specified label.

```yaml
podAntiAffinity:
  requiredDuringSchedulingIgnoredDuringExecution:
  - labelSelector:
      matchExpressions:
      # Must run on pods with app=milvus label
      - key: app
        operator: In
        values:
        - milvus
    topologyKey: "kubernetes.io/hostname"
```

--------------------------------

### Configure Component-Specific Node Selectors

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/node-selector-configuration-guide.md

Overrides global node selector settings for individual Milvus components.

```yaml
proxy:
  # Milvus proxy will be scheduled on nodes with component=proxy label
  nodeSelector:
    component: proxy
```

```yaml
queryNode:
  # Milvus query node will be scheduled on nodes with component=query and gpu=true label
  nodeSelector:
    component: query
    gpu: "true"
```

```yaml
indexNode:
  # Milvus index node will be scheduled on nodes with component=index label
  nodeSelector:
    component: index
```

```yaml
dataNode:
  # Milvus data node will be scheduled on nodes with component=data label
  nodeSelector:
    component: data
```

```yaml
mixCoordinator:
  # Milvus mix coordinator will be scheduled on nodes with component=coordinator label
  nodeSelector:
    component: coordinator
```

```yaml
standalone:
  # Milvus standalone will be scheduled on nodes with deployment=standalone label
  nodeSelector:
    deployment: standalone
```

--------------------------------

### Isolate Compute-Intensive Components

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/affinity-configuration-guide.md

Uses node affinity to ensure query nodes run on compute-optimized hardware.

```yaml
# Separate compute-intensive components
queryNode:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          # Must run on nodes with node-purpose=compute-optimized label
          - key: node-purpose
            operator: In
            values:
            - compute-optimized
```

--------------------------------

### Configure Component-Specific SecurityContext

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/security-context-configuration-guide.md

Overrides the global securityContext for specific Milvus components.

```yaml
proxy:
  securityContext: {}  # Overrides global securityContext for proxy
```

```yaml
mixCoordinator:
  securityContext: {}  # Overrides global securityContext for mixCoordinator
```

```yaml
queryNode:
  securityContext: {}  # Overrides global securityContext for queryNode
```

```yaml
indexNode:
  securityContext: {}  # Overrides global securityContext for indexNode
```

```yaml
dataNode:
  securityContext: {}  # Overrides global securityContext for dataNode
```

```yaml
standalone:
  securityContext: {}  # Overrides global securityContext for standalone
```

```yaml
streamingNode:
  securityContext: {}  # Overrides global securityContext for streamingNode
```

--------------------------------

### Define node affinity rules

Source: https://github.com/zilliztech/milvus-helm/blob/master/docs/node-selectors-vs-node-affinity.md

Use this configuration for complex scheduling requirements, including both mandatory constraints and weighted soft preferences.

```yaml
affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/os
          operator: In
          values:
          - linux
    preferredDuringSchedulingIgnoredDuringExecution:
    - weight: 1
      preference:
        matchExpressions:
        - key: disktype
          operator: In
          values:
          - ssd
```
Tokens:
Raw