对于 AI 代理：可在 https://www.mongodb.com/zh-cn/docs/llms.txt 获取文档索引—通过在任何 URL 路径后添加 .md 可获取所有页面的 Markdown 版本。
Docs 菜单
Docs 主页
/ /
部署搜索和向量搜索
Docs 主页
/
管理
/
Kubernetes Operator 的控制器
/
部署搜索和向量搜索
Docs 主页
/
管理
/
Kubernetes Operator 的控制器
/
部署搜索和向量搜索

安装和使用 MongoDB Community Edition

您可以使用 Kubernetes 操作符，并部署 mongot 进程资源，以便在 Kubernetes 集群上运行 MongoDB Community Edition v8.2.0 或更高版本。mongot 进程同时支持 MongoDB Search 和向量搜索。以下步骤将展示如何部署和配置 MongoDB Search 和向量搜索，以便在您的 Kubernetes 集群中与新建或现有的副本集一起运行。该部署使用 TLS 证书以确保 MongoDB 节点与 mongot 搜索进程之间的安全通信。

先决条件

要部署MongoDB Search 和 Vector Search，您必须具备以下条件：

  • 正在运行的 Kubernetes 集群。

  • Kubernetes命令行工具 kubectl，配置为与集群通信。

  • Helm（ Kubernetes的包管理器），用于安装Kubernetes Operator。

  • cert-manager 或用于 TLS 证书预配的替代证书管理解决方案。

  • Bash v5.1 或更高版本，用于运行本教程中的命令。

步骤

1

必填。设置环境变量。

设置环境变量以供本过程中的后续步骤使用。复制以下命令，更新环境的值，然后运行这些命令以加载变量：

1# set it to the context name of the k8s cluster
2export K8S_CTX="<local cluster context>"
3
4# the following namespace will be created if not exists
5export MDB_NS="mongodb"
6
7# MongoDBCommunity resource name referenced throughout the guide
8export MDB_RESOURCE_NAME="mdbc-rs"
9# Number of replica set members deployed in the sample MongoDBCommunity
10export MDB_MEMBERS=3
11
12# TLS-related secret names used for MongoDBCommunity and MongoDBSearch
13export MDB_TLS_CA_SECRET_NAME="${MDB_RESOURCE_NAME}-ca"
14export MDB_TLS_SERVER_CERT_SECRET_NAME="${MDB_RESOURCE_NAME}-tls"
15export MDB_SEARCH_TLS_SECRET_NAME="${MDB_RESOURCE_NAME}-search-tls"
16
17export MDB_TLS_CA_CONFIGMAP="${MDB_RESOURCE_NAME}-ca-configmap"
18export MDB_TLS_SELF_SIGNED_ISSUER="${MDB_RESOURCE_NAME}-selfsigned-cluster-issuer"
19export MDB_TLS_CA_CERT_NAME="${MDB_RESOURCE_NAME}-selfsigned-ca"
20export MDB_TLS_CA_ISSUER="${MDB_RESOURCE_NAME}-cluster-issuer"
21
22# minimum required MongoDB version for running MongoDB Search is 8.2.0
23export MDB_VERSION="8.2.0"
24
25# root admin user for convenience, not used here at all in this guide
26export MDB_ADMIN_USER_PASSWORD="admin-user-password-CHANGE-ME"
27# regular user performing restore and search queries on sample mflix database
28export MDB_USER_PASSWORD="mdb-user-password-CHANGE-ME"
29# user for MongoDB Search to connect to the replica set to synchronise data from
30export MDB_SEARCH_SYNC_USER_PASSWORD="search-sync-user-password-CHANGE-ME"
31
32export OPERATOR_HELM_CHART="mongodb/mongodb-kubernetes"
33# comma-separated key=value pairs for additional parameters passed to the helm-chart installing the operator
34export OPERATOR_ADDITIONAL_HELM_VALUES=""
35
36# TLS is mandatory; connection string must include tls=true
37export MDB_CONNECTION_STRING="mongodb://mdb-user:${MDB_USER_PASSWORD}@${MDB_RESOURCE_NAME}-0.${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local:27017/?replicaSet=${MDB_RESOURCE_NAME}&tls=true&tlsCAFile=/tls/ca.crt"
38
39export CERT_MANAGER_NAMESPACE="cert-manager"
2

有条件。添加MongoDB Helm存储库。

Helm 自动部署和管理 Kubernetes 上的 MongoDB 实例。如果您已经拥有包含用于安装 Kubernetes 操作符的 Helm 图表的 Helm 存储库，请跳过此步骤。否则，请添加 Helm存储库。

要添加 Helm存储库，请复制、粘贴并运行以下命令：

1helm repo add mongodb https://mongodb.github.io/helm-charts
2helm repo update mongodb
3helm search repo mongodb/mongodb-kubernetes
3

有条件。为Kubernetes Operator 安装MongoDB控制器。

Kubernetes Operator 监视 MongoDBCommunity 和 MongoDBSearch 自定义资源，并管理MongoDB部署的生命周期。如果您已经安装了MongoDB Controllers for Kubernetes 操作符，请跳过此步骤。否则，请从您在上一步中添加的 Helm存储库安装MongoDB Controllers for Kubernetes Operator。

要在 mongodb 命名空间中安装 MongoDB Controllers for Kubernetes 操作符，请复制、粘贴并运行以下命令：

1helm upgrade --install --debug --kube-context "${K8S_CTX}" \
2  --create-namespace \
3  --namespace="${MDB_NS}" \
4  mongodb-kubernetes \
5  ${OPERATOR_ADDITIONAL_HELM_VALUES:+--set ${OPERATOR_ADDITIONAL_HELM_VALUES}} \
6  "${OPERATOR_HELM_CHART}"
4

可选。等待操作符部署。

在继续MongoDB Search 和 向量搜索部署之前，确保Kubernetes Operator 完全运行。运行以下命令，验证所有操作符组件都在运行且可用。

1kubectl --context "${K8S_CTX}" -n "${MDB_NS}" rollout status --timeout=2m deployment/mongodb-kubernetes-operator
2echo "Operator deployment in ${MDB_NS} namespace"
3kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get deployments
4echo; echo "Operator pod in ${MDB_NS} namespace"
5kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
5

必需。创建并加载MongoDB用户密钥。

MongoDB需要身份验证才能安全访问权限。在此步骤中，您将创建三个Kubernetes密钥：

  • mdb-admin-user-password： MongoDB管理员的档案。

  • mdb-user-password：授权执行搜索查询的用户的档案。

  • mdbc-rs-search-sync-source-password：专用搜索用户的档案，由 mongot进程在内部用于同步数据和管理索引。

Kubernetes 操作符使用这些密钥中的密码在 MongoDB 数据库中自动创建用户。

要创建密钥，请复制、粘贴并运行以下命令：

1# Create admin user secret
2kubectl create secret generic mdb-admin-user-password \
3  --from-literal=password="${MDB_ADMIN_USER_PASSWORD}" \
4  --dry-run=client -o yaml | kubectl apply --context "${K8S_CTX}" --namespace "${MDB_NS}" -f -
5
6# Create search sync source user secret
7kubectl create secret generic "${MDB_RESOURCE_NAME}-search-sync-source-password" \
8  --from-literal=password="${MDB_SEARCH_SYNC_USER_PASSWORD}" \
9  --dry-run=client -o yaml | kubectl apply --context "${K8S_CTX}" --namespace "${MDB_NS}" -f -
10
11# Create regular user secret
12kubectl create secret generic mdb-user-password \
13  --from-literal=password="${MDB_USER_PASSWORD}" \
14  --dry-run=client -o yaml | kubectl apply --context "${K8S_CTX}" --namespace "${MDB_NS}" -f -
15
16echo "User secrets created."
6

有条件。安装 cert-manager。

管理TLS证书需要 cert-manager。如果您已在集群中安装 cert-manager，请跳过此步骤。否则，请使用Helm 安装 cert-manager。

要在 cert-manager命名空间中安装 cert-manager，请在终端中运行以下命令：

1helm upgrade --install \
2  cert-manager \
3  oci://quay.io/jetstack/charts/cert-manager \
4  --kube-context "${K8S_CTX}" \
5  --namespace "${CERT_MANAGER_NAMESPACE}" \
6  --create-namespace \
7  --set crds.enabled=true
8
9for deployment in cert-manager cert-manager-cainjector cert-manager-webhook; do
10  kubectl --context "${K8S_CTX}" \
11    -n "${CERT_MANAGER_NAMESPACE}" \
12    wait --for=condition=Available "deployment/${deployment}" --timeout=300s
13done
14
15echo "cert-manager is ready in namespace ${CERT_MANAGER_NAMESPACE}."
7

必需。准备证书颁发者和 CA 基础架构。

创建证书授权机构基础设施，用于针对 MongoDB 和 MongoDBSearch 资源颁发 TLS 证书。这些命令会执行以下操作：

  • 创建自签名 ClusterIssuer。

  • 生成 CA 证书。

  • 发布所有命名空间都可以使用的集群范围的 CA 颁发者。

  • 通过 ConfigMap 公开 CA 捆绑包，以便MongoDB资源可以使用它。

1# Bootstrap a self-signed ClusterIssuer that will mint the CA material consumed by
2# the MongoDBCommunity deployment.
3kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFEST
4apiVersion: cert-manager.io/v1
5kind: ClusterIssuer
6metadata:
7  name: ${MDB_TLS_SELF_SIGNED_ISSUER}
8spec:
9  selfSigned: {}
10EOF_MANIFEST
11
12kubectl --context "${K8S_CTX}" wait --for=condition=Ready clusterissuer "${MDB_TLS_SELF_SIGNED_ISSUER}"
13
14# Create the CA certificate and secret in the cert-manager namespace.
15kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFEST
16apiVersion: cert-manager.io/v1
17kind: Certificate
18metadata:
19  name: ${MDB_TLS_CA_CERT_NAME}
20  namespace: ${CERT_MANAGER_NAMESPACE}
21spec:
22  isCA: true
23  commonName: ${MDB_TLS_CA_CERT_NAME}
24  secretName: ${MDB_TLS_CA_SECRET_NAME}
25  privateKey:
26    algorithm: ECDSA
27    size: 256
28  issuerRef:
29    name: ${MDB_TLS_SELF_SIGNED_ISSUER}
30    kind: ClusterIssuer
31EOF_MANIFEST
32
33kubectl --context "${K8S_CTX}" wait --for=condition=Ready -n "${CERT_MANAGER_NAMESPACE}" certificate "${MDB_TLS_CA_CERT_NAME}"
34
35# Publish a cluster-scoped issuer that fronts the generated CA secret so all namespaces can reuse it.
36kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFEST
37apiVersion: cert-manager.io/v1
38kind: ClusterIssuer
39metadata:
40  name: ${MDB_TLS_CA_ISSUER}
41spec:
42  ca:
43    secretName: ${MDB_TLS_CA_SECRET_NAME}
44EOF_MANIFEST
45
46kubectl --context "${K8S_CTX}" wait --for=condition=Ready clusterissuer "${MDB_TLS_CA_ISSUER}"
47
48TMP_CA_CERT="$(mktemp)"
49
50kubectl --context "${K8S_CTX}" \
51  get secret "${MDB_TLS_CA_SECRET_NAME}" -n "${CERT_MANAGER_NAMESPACE}" \
52  -o jsonpath="{.data['ca\\.crt']}" | base64 --decode > "${TMP_CA_CERT}"
53
54# Expose the CA bundle through a ConfigMap for workloads and the MongoDBCommunity resource.
55kubectl --context "${K8S_CTX}" create configmap "${MDB_TLS_CA_CONFIGMAP}" -n "${MDB_NS}" \
56  --from-file=ca-pem="${TMP_CA_CERT}" --from-file=mms-ca.crt="${TMP_CA_CERT}" \
57  --from-file=ca.crt="${TMP_CA_CERT}" \
58  --dry-run=client -o yaml | kubectl --context "${K8S_CTX}" apply -f -
59
60echo "Cluster-wide CA issuer ${MDB_TLS_CA_ISSUER} is ready."
8

必需。颁发 TLS 证书。

为 MongoDB 服务器和 MongoDBSearch 服务颁发 TLS 证书。MongoDB 服务器证书包含了用于 pod 和服务通信的所有必要 DNS 名称。这两种证书都支持服务器和客户端身份验证。

1server_certificate="${MDB_RESOURCE_NAME}-server-tls"
2search_certificate="${MDB_RESOURCE_NAME}-search-tls"
3
4mongo_dns_names=()
5for ((member = 0; member < MDB_MEMBERS; member++)); do
6  mongo_dns_names+=("${MDB_RESOURCE_NAME}-${member}")
7  mongo_dns_names+=("${MDB_RESOURCE_NAME}-${member}.${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local")
8done
9mongo_dns_names+=(
10  "${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local"
11  "*.${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local"
12)
13
14search_dns_names=(
15  "${MDB_RESOURCE_NAME}-search-svc.${MDB_NS}.svc.cluster.local"
16)
17
18render_dns_list() {
19  local dns_list=("$@")
20  for dns in "${dns_list[@]}"; do
21    printf "      - \"%s\"\n" "${dns}"
22  done
23}
24
25kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF_MANIFEST
26apiVersion: cert-manager.io/v1
27kind: Certificate
28metadata:
29  name: ${server_certificate}
30  namespace: ${MDB_NS}
31spec:
32  secretName: ${MDB_TLS_SERVER_CERT_SECRET_NAME}
33  issuerRef:
34    name: ${MDB_TLS_CA_ISSUER}
35    kind: ClusterIssuer
36  duration: 240h0m0s
37  renewBefore: 120h0m0s
38  usages:
39    - digital signature
40    - key encipherment
41    - server auth
42    - client auth
43  dnsNames:
44$(render_dns_list "${mongo_dns_names[@]}")
45---
46apiVersion: cert-manager.io/v1
47kind: Certificate
48metadata:
49  name: ${search_certificate}
50  namespace: ${MDB_NS}
51spec:
52  secretName: ${MDB_SEARCH_TLS_SECRET_NAME}
53  issuerRef:
54    name: ${MDB_TLS_CA_ISSUER}
55    kind: ClusterIssuer
56  duration: 240h0m0s
57  renewBefore: 120h0m0s
58  usages:
59    - digital signature
60    - key encipherment
61    - server auth
62    - client auth
63  dnsNames:
64$(render_dns_list "${search_dns_names[@]}")
65EOF_MANIFEST
66
67kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=condition=Ready certificate "${server_certificate}" --timeout=300s
68kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=condition=Ready certificate "${search_certificate}" --timeout=300s
69
70echo "MongoDB TLS certificates have been issued."
9

有条件。创建和部署MongoDB Community资源。

如果您已经部署了MongoDB Community Edition，请跳过此步骤。否则，部署MongoDB Community Edition。

要部署MongoDB Community Edition，请完成以下步骤：

  1. 创建名为 mdb-rs 的 MongoDBCommunity 自定义资源。

    该资源定义了 mongod 和 mongodb-agent 容器的 CPU 和内存资源，并设置了以下三个用户：

    mdb-user

    可以恢复数据库和运行搜索查询的用户。该用户使用 mdb-user-password 密钥来执行这些操作。

    search-sync-source

    MongoDB 搜索用于连接到 MongoDB 数据库以管理和构建索引的用户。此用户使用Kubernetes 操作符创建的 searchCoordinator角色。这会使用 mdbc-rs-search-sync-source-password 密钥将 mongot 连接到 mongod。

    admin-user

    数据库管理员用户。

    Kubernetes 操作符使用此资源配置具有 3 个成员的 MongoDB 副本集。

    要创建密钥，请复制、粘贴并运行以下命令：

    1kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
    2apiVersion: mongodbcommunity.mongodb.com/v1
    3kind: MongoDBCommunity
    4metadata:
    5  name: ${MDB_RESOURCE_NAME}
    6spec:
    7  version: ${MDB_VERSION}
    8  type: ReplicaSet
    9  members: ${MDB_MEMBERS}
    10  security:
    11    tls:
    12      enabled: true
    13      certificateKeySecretRef:
    14        name: ${MDB_TLS_SERVER_CERT_SECRET_NAME}
    15      caConfigMapRef:
    16        name: ${MDB_TLS_CA_CONFIGMAP}
    17    authentication:
    18      ignoreUnknownUsers: true
    19      modes:
    20        - SCRAM
    21  agent:
    22    logLevel: DEBUG
    23  statefulSet:
    24    spec:
    25      template:
    26        spec:
    27          containers:
    28            - name: mongod
    29              resources:
    30                limits:
    31                  cpu: "2"
    32                  memory: 2Gi
    33                requests:
    34                  cpu: "1"
    35                  memory: 1Gi
    36            - name: mongodb-agent
    37              resources:
    38                limits:
    39                  cpu: "1"
    40                  memory: 2Gi
    41                requests:
    42                  cpu: "0.5"
    43                  memory: 1Gi
    44  users:
    45    # admin user with root role
    46    - name: mdb-admin
    47      db: admin
    48      # a reference to the secret containing user password
    49      passwordSecretRef:
    50        name: mdb-admin-user-password
    51      scramCredentialsSecretName: mdb-admin-user
    52      roles:
    53        - name: root
    54          db: admin
    55    # user performing search queries
    56    - name: mdb-user
    57      db: admin
    58      # a reference to the secret containing user password
    59      passwordSecretRef:
    60        name: mdb-user-password
    61      scramCredentialsSecretName: mdb-user-scram
    62      roles:
    63        - name: restore
    64          db: sample_mflix
    65        - name: readWrite
    66          db: sample_mflix
    67    # user used by MongoDB Search to connect to MongoDB database to
    68    # synchronize data from.
    69    # For MongoDB <8.2, the operator will be creating the
    70    # searchCoordinator custom role automatically.
    71    # From MongoDB 8.2, searchCoordinator role will be a
    72    # built-in role.
    73    - name: search-sync-source
    74      db: admin
    75      # a reference to the secret that will be used to generate the user's password
    76      passwordSecretRef:
    77        name: ${MDB_RESOURCE_NAME}-search-sync-source-password
    78      scramCredentialsSecretName: ${MDB_RESOURCE_NAME}-search-sync-source
    79      roles:
    80        - name: searchCoordinator
    81          db: admin
    82EOF

  2. 等待 MongoDBCommunity资源部署完成。

    当您应用MongoDBCommunity 自定义资源时， Kubernetes 操作符开始部署MongoDB节点 (Pod)。此步骤会暂停执行，直到 mdbc-rs 资源的状态阶段为 Running，这表示MongoDB Community副本集可操作。

    1echo "Waiting for MongoDBCommunity resource to reach Running phase..."
    2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait \
    3  --for=jsonpath='{.status.phase}'=Running mdbc/mdbc-rs --timeout=400s
    4echo; echo "MongoDBCommunity resource"
    5kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get mdbc/mdbc-rs
    6echo; echo "Pods running in cluster ${K8S_CTX}"
    7kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
10

必需。为MongoDB Search 和 Vector Search 创建并部署资源。

您可以部署一个搜索节点实例，而无需任何负载均衡。要部署，请完成以下步骤：

  1. 创建名为 mdbc-rs 的 MongoDBSearch 自定义资源。

    此资源指定搜索节点的 CPU 和内存资源要求。要学习；了解有关此自定义资源中设置的更多信息，请参阅MongoDB搜索和向量搜索设置。

    1kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
    2apiVersion: mongodb.com/v1
    3kind: MongoDBSearch
    4metadata:
    5  name: ${MDB_RESOURCE_NAME}
    6spec:
    7  security:
    8    tls:
    9      certificateKeySecretRef:
    10        name: ${MDB_SEARCH_TLS_SECRET_NAME}
    11  resourceRequirements:
    12    limits:
    13      cpu: "3"
    14      memory: 5Gi
    15    requests:
    16      cpu: "2"
    17      memory: 3Gi
    18EOF

  2. 等待 MongoDBSearch资源部署完成。

    当您应用MongoDBSearch 自定义资源时， Kubernetes 操作符开始部署搜索节点 (pod)。此步骤会暂停执行，直到 mdbc-rs MongoDB搜索 资源的状态阶段为 Running（表示MongoDB搜索 正在运行）。

    1echo "Waiting for MongoDBSearch resource to reach Running phase..."
    2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait \
    3  --for=jsonpath='{.status.phase}'=Running mdbs/"${MDB_RESOURCE_NAME}" --timeout=300s
11

可选。验证MongoDB Community资源状态。

确保使用 MongoDBSearch 的 MongoDBCommunity资源部署成功。

1echo "Waiting for MongoDBCommunity resource to reach Running phase..."
2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait \
3  --for=jsonpath='{.status.phase}'=Running mdbc/mdbc-rs --timeout=400s
4echo; echo "MongoDBCommunity resource"
5kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get mdbc/mdbc-rs
6echo; echo "Pods running in cluster ${K8S_CTX}"
7kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
12

可选。查看命名空间中所有运行的Pod。

查看MongoDB副本集成员、 Kubernetes Operator 的MongoDB控制器以及搜索节点的命名空间Pod 中运行的所有 Pod。

1echo; echo "MongoDBCommunity resource"
2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get mdbc/mdbc-rs
3echo; echo "MongoDBSearch resource"
4kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get mdbs/mdbc-rs
5echo; echo "Pods running in cluster ${K8S_CTX}"
6kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods

后续步骤

现在您已成功部署MongoDB 搜索和向量搜索以便与MongoDB Community Edition一起使用，接下来将数据添加到您的MongoDB 集群，创建MongoDB 搜索和向量搜索搜索索引，并根据您的数据运行查询。要学习；了解更多信息，请参阅使用MongoDB Search 和 Vector Search。

给本页内容打分

在此页面上