Docs Menu
Docs Home
/ /
Implementar búsqueda y búsqueda vectorial
Docs Home
/
Gestión
/
Controladores para el Operador de Kubernetes
/
Implementar búsqueda y búsqueda vectorial
Docs Home
/
Gestión
/
Controladores para el Operador de Kubernetes
/
Implementar búsqueda y búsqueda vectorial

Instalar y usar la búsqueda con MongoDB Enterprise Edition

Puede usar el operador de Kubernetes para implementar recursos de MongoDB Search y Vector Search para que se ejecuten con MongoDB Enterprise v8.0.10 o superior en un clúster de Kubernetes. Este procedimiento demuestra cómo implementar y configurar mongot proceso para ejecutar con un conjunto de réplicas nuevo o existente en su clúster de Kubernetes.

Importante

La compatibilidad con versiones de MongoDB anteriores a 8.2 ya no está disponible. Actualice a MongoDB v8.2 o posterior.

Requisitos previos

Para implementar MongoDB Search y Vector Search, debe tener lo siguiente:

  • Un clúster de Kubernetes en ejecución con kubeconfig disponible localmente.

  • Herramienta de línea de comandos de Kubernetes, kubectl, configurada para comunicarse con su clúster.

  • Helm, el administrador de paquetes de Kubernetes, para instalar el operador de Kubernetes.

  • Bash v5.1 o superior para ejecutar los comandos de este tutorial.

  • Proyecto MongoDB Ops Manager o MongoDB Cloud Manager y Credenciales de API.

Procedimiento

1

Obligatorio. Establezca las variables de entorno.

Para configurar las variables de entorno que se utilizarán en los pasos posteriores de este procedimiento, copie lo siguiente, configure los valores para las variables de entorno y luego cargue las variables de entorno:

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# name of the MongoDB Custom Resource.
8export MDB_RESOURCE_NAME="mdb-rs"
9
10# OM/CM's project name to be used to manage mongodb replica set
11export OPS_MANAGER_PROJECT_NAME="<arbitrary project name>"
12
13# URL to Cloud Manager or Ops Manager instance
14export OPS_MANAGER_API_URL="https://cloud-qa.mongodb.com"
15
16# The API key can be an Org Owner - the operator can create the project automatically then.
17# The API key can also be created in a particular project that was created manually with the Project Owner scope.
18export OPS_MANAGER_API_USER="<SET API USER>"
19export OPS_MANAGER_API_KEY="<SET API KEY>"
20export OPS_MANAGER_ORG_ID="<SET ORG ID>"
21
22# minimum required MongoDB version for running MongoDB Search is 8.2.0
23export MDB_VERSION="8.2.0-ent"
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
36export MDB_CONNECTION_STRING="mongodb://mdb-user:${MDB_USER_PASSWORD}@${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local:27017/?replicaSet=${MDB_RESOURCE_NAME}"
2

Condicional. Agregue el repositorio Helm de MongoDB.

Helm automatiza la implementación y la gestión de instancias de MongoDB en Kubernetes. Si ya agregó el repositorio de Helm que contiene el diagrama de Helm para instalar el operador de Kubernetes, omita este paso. De lo contrario, agregue el repositorio de Helm.

Para agregar, copiar, pegar y ejecutar el siguiente comando:

1helm repo add mongodb https://mongodb.github.io/helm-charts
2helm repo update mongodb
3helm search repo mongodb/mongodb-kubernetes
1"mongodb" has been added to your repositories
2Hang tight while we grab the latest from your chart repositories...
3...Successfully got an update from the "mongodb" chart repository
4Update Complete. ⎈Happy Helming!⎈
5NAME                      	CHART VERSION	APP VERSION	DESCRIPTION                                       
6mongodb/mongodb-kubernetes	1.5.0        	           	MongoDB Controllers for Kubernetes translate th...
3

Condicional. Instale los controladores de MongoDB para el Operador de Kubernetes.

El operador de Kubernetes supervisa los recursos personalizados MongoDB, MongoDBOpsManager y MongoDBSearch y gestiona el ciclo de vida de sus implementaciones de MongoDB. Si ya instaló los controladores de MongoDB para el operador de Kubernetes, omita este paso. De lo contrario, instálelos desde el repositorio de Helm que agregó en el paso anterior.

Para instalar el operador de controladores MongoDB para Kubernetes en el espacio de nombres mongodb, copie, pegue y ejecute lo siguiente:

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}"
1Release "mongodb-kubernetes" does not exist. Installing it now.
2NAME: mongodb-kubernetes
3LAST DEPLOYED: Wed Oct 15 09:35:18 2025
4NAMESPACE: mongodb
5STATUS: deployed
6REVISION: 1
7TEST SUITE: None
8USER-SUPPLIED VALUES:
9{}
10
11COMPUTED VALUES:
12agent:
13  name: mongodb-agent
14  version: 108.0.12.8846-1
15community:
16  agent:
17    name: mongodb-agent
18    version: 108.0.2.8729-1
19  mongodb:
20    imageType: ubi8
21    name: mongodb-community-server
22    repo: quay.io/mongodb
23  registry:
24    agent: quay.io/mongodb
25  resource:
26    members: 3
27    name: mongodb-replica-set
28    tls:
29      caCertificateSecretRef: tls-ca-key-pair
30      certManager:
31        certDuration: 8760h
32        renewCertBefore: 720h
33      certificateKeySecretRef: tls-certificate
34      enabled: false
35      sampleX509User: false
36      useCertManager: true
37      useX509: false
38    version: 4.4.0
39database:
40  name: mongodb-kubernetes-database
41  version: 1.5.0
42initAppDb:
43  name: mongodb-kubernetes-init-appdb
44  version: 1.5.0
45initDatabase:
46  name: mongodb-kubernetes-init-database
47  version: 1.5.0
48initOpsManager:
49  name: mongodb-kubernetes-init-ops-manager
50  version: 1.5.0
51managedSecurityContext: false
52mongodb:
53  appdbAssumeOldFormat: false
54  imageType: ubi8
55  name: mongodb-enterprise-server
56  repo: quay.io/mongodb
57multiCluster:
58  clusterClientTimeout: 10
59  clusters: []
60  kubeConfigSecretName: mongodb-enterprise-operator-multi-cluster-kubeconfig
61  performFailOver: true
62operator:
63  additionalArguments: []
64  affinity: {}
65  baseName: mongodb-kubernetes
66  createOperatorServiceAccount: true
67  createResourcesServiceAccountsAndRoles: true
68  deployment_name: mongodb-kubernetes-operator
69  enableClusterMongoDBRoles: true
70  enablePVCResize: true
71  env: prod
72  maxConcurrentReconciles: 1
73  mdbDefaultArchitecture: non-static
74  name: mongodb-kubernetes-operator
75  nodeSelector: {}
76  operator_image_name: mongodb-kubernetes
77  replicas: 1
78  resources:
79    limits:
80      cpu: 1100m
81      memory: 1Gi
82    requests:
83      cpu: 500m
84      memory: 200Mi
85  telemetry:
86    collection:
87      clusters: {}
88      deployments: {}
89      frequency: 1h
90      operators: {}
91    send:
92      frequency: 168h
93  tolerations: []
94  vaultSecretBackend:
95    enabled: false
96    tlsSecretRef: ""
97  version: 1.5.0
98  watchedResources:
99  - mongodb
100  - opsmanagers
101  - mongodbusers
102  - mongodbcommunity
103  - mongodbsearch
104  webhook:
105    installClusterRole: true
106    registerConfiguration: true
107opsManager:
108  name: mongodb-enterprise-ops-manager-ubi
109readinessProbe:
110  name: mongodb-kubernetes-readinessprobe
111  version: 1.0.23
112registry:
113  agent: quay.io/mongodb
114  database: quay.io/mongodb
115  imagePullSecrets: null
116  initAppDb: quay.io/mongodb
117  initDatabase: quay.io/mongodb
118  initOpsManager: quay.io/mongodb
119  operator: quay.io/mongodb
120  opsManager: quay.io/mongodb
121  pullPolicy: Always
122  readinessProbe: quay.io/mongodb
123  versionUpgradeHook: quay.io/mongodb
124search:
125  name: mongodb-search
126  repo: quay.io/mongodb
127  version: 0.53.1
128versionUpgradeHook:
129  name: mongodb-kubernetes-operator-version-upgrade-post-start-hook
130  version: 1.0.10
131
132HOOKS:
133MANIFEST:
134---
135# Source: mongodb-kubernetes/templates/database-roles.yaml
136apiVersion: v1
137kind: ServiceAccount
138metadata:
139  name: mongodb-kubernetes-appdb
140  namespace: mongodb
141---
142# Source: mongodb-kubernetes/templates/database-roles.yaml
143apiVersion: v1
144kind: ServiceAccount
145metadata:
146  name: mongodb-kubernetes-database-pods
147  namespace: mongodb
148---
149# Source: mongodb-kubernetes/templates/database-roles.yaml
150apiVersion: v1
151kind: ServiceAccount
152metadata:
153  name: mongodb-kubernetes-ops-manager
154  namespace: mongodb
155---
156# Source: mongodb-kubernetes/templates/operator-sa.yaml
157apiVersion: v1
158kind: ServiceAccount
159metadata:
160  name: mongodb-kubernetes-operator
161  namespace: mongodb
162---
163# Source: mongodb-kubernetes/templates/operator-roles-clustermongodbroles.yaml
164kind: ClusterRole
165apiVersion: rbac.authorization.k8s.io/v1
166metadata:
167  name: mongodb-kubernetes-operator-mongodb-cluster-mongodb-role
168rules:
169  - apiGroups:
170      - mongodb.com
171    verbs:
172      - '*'
173    resources:
174      - clustermongodbroles
175---
176# Source: mongodb-kubernetes/templates/operator-roles-telemetry.yaml
177# Additional ClusterRole for clusterVersionDetection
178kind: ClusterRole
179apiVersion: rbac.authorization.k8s.io/v1
180metadata:
181  name: mongodb-kubernetes-operator-cluster-telemetry
182rules:
183  # Non-resource URL permissions
184  - nonResourceURLs:
185      - "/version"
186    verbs:
187      - get
188  # Cluster-scoped resource permissions
189  - apiGroups:
190      - ''
191    resources:
192      - namespaces
193    resourceNames:
194      - kube-system
195    verbs:
196      - get
197  - apiGroups:
198      - ''
199    resources:
200      - nodes
201    verbs:
202      - list
203---
204# Source: mongodb-kubernetes/templates/operator-roles-webhook.yaml
205kind: ClusterRole
206apiVersion: rbac.authorization.k8s.io/v1
207metadata:
208  name: mongodb-kubernetes-operator-mongodb-webhook-cr
209rules:
210  - apiGroups:
211      - "admissionregistration.k8s.io"
212    resources:
213      - validatingwebhookconfigurations
214    verbs:
215      - get
216      - create
217      - update
218      - delete
219  - apiGroups:
220      - ""
221    resources:
222      - services
223    verbs:
224      - get
225      - list
226      - watch
227      - create
228      - update
229      - delete
230---
231# Source: mongodb-kubernetes/templates/operator-roles-clustermongodbroles.yaml
232kind: ClusterRoleBinding
233apiVersion: rbac.authorization.k8s.io/v1
234metadata:
235  name: mongodb-kubernetes-operator-mongodb-cluster-mongodb-role-binding
236roleRef:
237  apiGroup: rbac.authorization.k8s.io
238  kind: ClusterRole
239  name: mongodb-kubernetes-operator-mongodb-cluster-mongodb-role
240subjects:
241  - kind: ServiceAccount
242    name: mongodb-kubernetes-operator
243    namespace: mongodb
244---
245# Source: mongodb-kubernetes/templates/operator-roles-telemetry.yaml
246# ClusterRoleBinding for clusterVersionDetection
247kind: ClusterRoleBinding
248apiVersion: rbac.authorization.k8s.io/v1
249metadata:
250  name: mongodb-kubernetes-operator-mongodb-cluster-telemetry-binding
251roleRef:
252  apiGroup: rbac.authorization.k8s.io
253  kind: ClusterRole
254  name: mongodb-kubernetes-operator-cluster-telemetry
255subjects:
256  - kind: ServiceAccount
257    name: mongodb-kubernetes-operator
258    namespace: mongodb
259---
260# Source: mongodb-kubernetes/templates/operator-roles-webhook.yaml
261kind: ClusterRoleBinding
262apiVersion: rbac.authorization.k8s.io/v1
263metadata:
264  name: mongodb-kubernetes-operator-mongodb-webhook-crb
265roleRef:
266  apiGroup: rbac.authorization.k8s.io
267  kind: ClusterRole
268  name: mongodb-kubernetes-operator-mongodb-webhook-cr
269subjects:
270  - kind: ServiceAccount
271    name: mongodb-kubernetes-operator
272    namespace: mongodb
273---
274# Source: mongodb-kubernetes/templates/database-roles.yaml
275kind: Role
276apiVersion: rbac.authorization.k8s.io/v1
277metadata:
278  name: mongodb-kubernetes-appdb
279  namespace: mongodb
280rules:
281  - apiGroups:
282      - ''
283    resources:
284      - secrets
285    verbs:
286      - get
287  - apiGroups:
288      - ''
289    resources:
290      - pods
291    verbs:
292      - patch
293      - delete
294      - get
295---
296# Source: mongodb-kubernetes/templates/operator-roles-base.yaml
297kind: Role
298apiVersion: rbac.authorization.k8s.io/v1
299metadata:
300  name: mongodb-kubernetes-operator
301  namespace: mongodb
302rules:
303  - apiGroups:
304      - ''
305    resources:
306      - services
307    verbs:
308      - get
309      - list
310      - watch
311      - create
312      - update
313      - delete
314  - apiGroups:
315      - ''
316    resources:
317      - secrets
318      - configmaps
319    verbs:
320      - get
321      - list
322      - create
323      - update
324      - delete
325      - watch
326  - apiGroups:
327      - apps
328    resources:
329      - statefulsets
330    verbs:
331      - create
332      - get
333      - list
334      - watch
335      - delete
336      - update
337  - apiGroups:
338      - ''
339    resources:
340      - pods
341    verbs:
342      - get
343      - list
344      - watch
345      - delete
346      - deletecollection
347  - apiGroups:
348      - mongodbcommunity.mongodb.com
349    resources:
350      - mongodbcommunity
351      - mongodbcommunity/status
352      - mongodbcommunity/spec
353      - mongodbcommunity/finalizers
354    verbs:
355      - '*'
356  - apiGroups:
357      - mongodb.com
358    verbs:
359      - '*'
360    resources:
361      - mongodb
362      - mongodb/finalizers
363      - mongodbusers
364      - mongodbusers/finalizers
365      - opsmanagers
366      - opsmanagers/finalizers
367      - mongodbmulticluster
368      - mongodbmulticluster/finalizers
369      - mongodbsearch
370      - mongodbsearch/finalizers
371      - mongodb/status
372      - mongodbusers/status
373      - opsmanagers/status
374      - mongodbmulticluster/status
375      - mongodbsearch/status
376---
377# Source: mongodb-kubernetes/templates/operator-roles-pvc-resize.yaml
378kind: Role
379apiVersion: rbac.authorization.k8s.io/v1
380metadata:
381  name: mongodb-kubernetes-operator-pvc-resize
382  namespace: mongodb
383rules:
384  - apiGroups:
385      - ''
386    resources:
387      - persistentvolumeclaims
388    verbs:
389      - get
390      - delete
391      - list
392      - watch
393      - patch
394      - update
395---
396# Source: mongodb-kubernetes/templates/database-roles.yaml
397kind: RoleBinding
398apiVersion: rbac.authorization.k8s.io/v1
399metadata:
400  name: mongodb-kubernetes-appdb
401  namespace: mongodb
402roleRef:
403  apiGroup: rbac.authorization.k8s.io
404  kind: Role
405  name: mongodb-kubernetes-appdb
406subjects:
407  - kind: ServiceAccount
408    name: mongodb-kubernetes-appdb
409    namespace: mongodb
410---
411# Source: mongodb-kubernetes/templates/operator-roles-base.yaml
412kind: RoleBinding
413apiVersion: rbac.authorization.k8s.io/v1
414metadata:
415  name: mongodb-kubernetes-operator
416  namespace: mongodb
417roleRef:
418  apiGroup: rbac.authorization.k8s.io
419  kind: Role
420  name: mongodb-kubernetes-operator
421subjects:
422  - kind: ServiceAccount
423    name: mongodb-kubernetes-operator
424    namespace: mongodb
425---
426# Source: mongodb-kubernetes/templates/operator-roles-pvc-resize.yaml
427kind: RoleBinding
428apiVersion: rbac.authorization.k8s.io/v1
429metadata:
430  name: mongodb-kubernetes-operator-pvc-resize-binding
431  namespace: mongodb
432roleRef:
433  apiGroup: rbac.authorization.k8s.io
434  kind: Role
435  name: mongodb-kubernetes-operator-pvc-resize
436subjects:
437  - kind: ServiceAccount
438    name: mongodb-kubernetes-operator
439    namespace: mongodb
440---
441# Source: mongodb-kubernetes/templates/operator.yaml
442apiVersion: apps/v1
443kind: Deployment
444metadata:
445  name: mongodb-kubernetes-operator
446  namespace: mongodb
447spec:
448  replicas: 1
449  selector:
450    matchLabels:
451      app.kubernetes.io/component: controller
452      app.kubernetes.io/name: mongodb-kubernetes-operator
453      app.kubernetes.io/instance: mongodb-kubernetes-operator
454  template:
455    metadata:
456      labels:
457        app.kubernetes.io/component: controller
458        app.kubernetes.io/name: mongodb-kubernetes-operator
459        app.kubernetes.io/instance: mongodb-kubernetes-operator
460    spec:
461      serviceAccountName: mongodb-kubernetes-operator
462      securityContext:
463        runAsNonRoot: true
464        runAsUser: 2000
465      containers:
466        - name: mongodb-kubernetes-operator
467          image: "quay.io/mongodb/mongodb-kubernetes:1.5.0"
468          imagePullPolicy: Always
469          args:
470            - -watch-resource=mongodb
471            - -watch-resource=opsmanagers
472            - -watch-resource=mongodbusers
473            - -watch-resource=mongodbcommunity
474            - -watch-resource=mongodbsearch
475            - -watch-resource=clustermongodbroles
476          command:
477            - /usr/local/bin/mongodb-kubernetes-operator
478          resources:
479            limits:
480              cpu: 1100m
481              memory: 1Gi
482            requests:
483              cpu: 500m
484              memory: 200Mi
485          env:
486            - name: OPERATOR_ENV
487              value: prod
488            - name: MDB_DEFAULT_ARCHITECTURE
489              value: non-static
490            - name: NAMESPACE
491              valueFrom:
492                fieldRef:
493                  fieldPath: metadata.namespace
494            - name: WATCH_NAMESPACE
495              valueFrom:
496                fieldRef:
497                  fieldPath: metadata.namespace
498            - name: MDB_OPERATOR_TELEMETRY_COLLECTION_FREQUENCY
499              value: "1h"
500            - name: MDB_OPERATOR_TELEMETRY_SEND_FREQUENCY
501              value: "168h"
502            - name: CLUSTER_CLIENT_TIMEOUT
503              value: "10"
504            - name: IMAGE_PULL_POLICY
505              value: Always
506            # Database
507            - name: MONGODB_ENTERPRISE_DATABASE_IMAGE
508              value: quay.io/mongodb/mongodb-kubernetes-database
509            - name: INIT_DATABASE_IMAGE_REPOSITORY
510              value: quay.io/mongodb/mongodb-kubernetes-init-database
511            - name: INIT_DATABASE_VERSION
512              value: 1.5.0
513            - name: DATABASE_VERSION
514              value: 1.5.0
515            # Ops Manager
516            - name: OPS_MANAGER_IMAGE_REPOSITORY
517              value: quay.io/mongodb/mongodb-enterprise-ops-manager-ubi
518            - name: INIT_OPS_MANAGER_IMAGE_REPOSITORY
519              value: quay.io/mongodb/mongodb-kubernetes-init-ops-manager
520            - name: INIT_OPS_MANAGER_VERSION
521              value: 1.5.0
522            # AppDB
523            - name: INIT_APPDB_IMAGE_REPOSITORY
524              value: quay.io/mongodb/mongodb-kubernetes-init-appdb
525            - name: INIT_APPDB_VERSION
526              value: 1.5.0
527            - name: OPS_MANAGER_IMAGE_PULL_POLICY
528              value: Always
529            - name: AGENT_IMAGE
530              value: "quay.io/mongodb/mongodb-agent:108.0.12.8846-1"
531            - name: MDB_AGENT_IMAGE_REPOSITORY
532              value: "quay.io/mongodb/mongodb-agent"
533            - name: MONGODB_IMAGE
534              value: mongodb-enterprise-server
535            - name: MONGODB_REPO_URL
536              value: quay.io/mongodb
537            - name: MDB_IMAGE_TYPE
538              value: ubi8
539            - name: PERFORM_FAILOVER
540              value: 'true'
541            - name: MDB_MAX_CONCURRENT_RECONCILES
542              value: "1"
543            - name: POD_NAME
544              valueFrom:
545                fieldRef:
546                  fieldPath: metadata.name
547            - name: OPERATOR_NAME
548              value: mongodb-kubernetes-operator
549            # Community Env Vars Start
550            - name: MDB_COMMUNITY_AGENT_IMAGE
551              value: "quay.io/mongodb/mongodb-agent:108.0.2.8729-1"
552            - name: VERSION_UPGRADE_HOOK_IMAGE
553              value: "quay.io/mongodb/mongodb-kubernetes-operator-version-upgrade-post-start-hook:1.0.10"
554            - name: READINESS_PROBE_IMAGE
555              value: "quay.io/mongodb/mongodb-kubernetes-readinessprobe:1.0.23"
556            - name: MDB_COMMUNITY_IMAGE
557              value: "mongodb-community-server"
558            - name: MDB_COMMUNITY_REPO_URL
559              value: "quay.io/mongodb"
560            - name: MDB_COMMUNITY_IMAGE_TYPE
561              value: "ubi8"
562            # Community Env Vars End
563            - name: MDB_SEARCH_REPO_URL
564              value: "quay.io/mongodb"
565            - name: MDB_SEARCH_NAME
566              value: "mongodb-search"
567            - name: MDB_SEARCH_VERSION
568              value: "0.53.1"
4

Condicional. Crear e implementar el recurso MongoDB Enterprise.

Si ya implementó MongoDB Enterprise, vaya al siguiente paso. De lo contrario, implemente el recurso MongoDB Enterprise.

Para implementar MongoDB Enterprise, complete los siguientes pasos:

  1. Cree el ConfigMap y el secreto para el proyecto MongoDB Ops Manager si está utilizando MongoDB Ops Manager.

    Para almacenar la configuración y las credenciales para la integración con MongoDB Ops Manager, copie, pegue y ejecute los siguientes comandos:

    1kubectl --context "${K8S_CTX}" -n "${MDB_NS}" create configmap om-project \
    2  --from-literal=projectName="${OPS_MANAGER_PROJECT_NAME}" --from-literal=baseUrl="${OPS_MANAGER_API_URL}" \
    3  --from-literal=orgId="${OPS_MANAGER_ORG_ID:-}"
    4
    5kubectl --context "${K8S_CTX}" -n "${MDB_NS}" create secret generic om-credentials \
    6  --from-literal=publicKey="${OPS_MANAGER_API_USER}" \
    7  --from-literal=privateKey="${OPS_MANAGER_API_KEY}"

  2. Crea un recurso personalizado MongoDB llamado mdb-rs.

    El recurso define recursos de CPU y memoria para los contenedores mongod y mongodb-agent e indica al operador de Kubernetes que configure un conjunto de réplicas de MongoDB con 3 miembros:

    Para implementar MongoDB Enterprise, copia, pega y ejecuta lo siguiente en el namespace:

    1kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
    2apiVersion: mongodb.com/v1
    3kind: MongoDB
    4metadata:
    5  name: ${MDB_RESOURCE_NAME}
    6spec:
    7  members: 3
    8  version: ${MDB_VERSION}
    9  type: ReplicaSet
    10  opsManager:
    11    configMapRef:
    12      name: om-project
    13  credentials: om-credentials
    14  security:
    15    authentication:
    16      enabled: true
    17      ignoreUnknownUsers: true
    18      modes:
    19      - SCRAM
    20  agent:
    21    logLevel: INFO
    22  podSpec:
    23    podTemplate:
    24      spec:
    25        containers:
    26        - name: mongodb-enterprise-database
    27          resources:
    28            limits:
    29              cpu: "2"
    30              memory: 2Gi
    31            requests:
    32              cpu: "1"
    33              memory: 1Gi
    34EOF

  3. Espere a que se complete la implementación del recurso MongoDB.

    Al aplicar el recurso personalizado MongoDB, el operador de Kubernetes comienza a implementar los nodos (pods) de MongoDB. Este paso pausa la ejecución hasta que la fase de estado del recurso mdbc-rs sea Running, lo que indica que el conjunto de réplicas de MongoDB Community está operativo.

    1echo "Waiting for MongoDB resource to reach Running phase..."
    2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=jsonpath='{.status.phase}'=Running "mdb/${MDB_RESOURCE_NAME}" --timeout=400s
    3echo; echo "MongoDB resource"
    4kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdb/${MDB_RESOURCE_NAME}"
    5echo; echo "Pods running in cluster ${K8S_CTX}"
    6kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
    1Waiting for MongoDB resource to reach Running phase...
    2mongodb.mongodb.mongodb.com/mdbc-rs condition met
    3
    4MongoDB resource
    5NAME      PHASE     VERSION
    6mdbc-rs   Running   8.0.10
    7
    8Pods running in cluster minikube
    9NAME                                           READY   STATUS    RESTARTS   AGE
    10mdbc-rs-0                                      2/2     Running   0          2m30s
    11mdbc-rs-1                                      2/2     Running   0          82s
    12mdbc-rs-2                                      2/2     Running   0          38s
    13mongodb-kubernetes-operator-5776c8b4df-cppnf   1/1     Running   0          7m37s
5

Obligatorio. Crear y cargar los secretos de usuario de MongoDB.

MongoDB requiere autenticación para un acceso seguro. En este paso, se crean tres secretos de Kubernetes:

  • mdb-admin-user-password:Credenciales para el administrador de MongoDB.

  • mdb-user-password:Credenciales del usuario autorizado para realizar consultas de búsqueda.

  • mdbc-rs-search-sync-source-password:Credenciales para un usuario de búsqueda dedicado utilizado internamente por el proceso mongot para sincronizar datos y administrar índices.

El operador de Kubernetes monta estos secretos en los pods de MongoDB.

Para crear los secretos, copie, pegue y ejecute lo siguiente en el espacio de nombres donde implementó MongoDB Server y planea implementar MongoDB Search y Vector Search:

1# admin user with root role
2kubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \
3  create secret generic mdb-admin-user-password \
4  --from-literal=password="${MDB_ADMIN_USER_PASSWORD}"
5
6kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
7apiVersion: mongodb.com/v1
8kind: MongoDBUser
9metadata:
10  name: mdb-admin
11spec:
12  username: mdb-admin
13  db: admin
14  mongodbResourceRef:
15    name: ${MDB_RESOURCE_NAME}
16  passwordSecretKeyRef:
17    name: mdb-admin-user-password
18    key: password
19  roles:
20  - name: root
21    db: admin
22EOF
23
24# user used by MongoDB Search to connect to MongoDB database to synchronize data from
25# For MongoDB <8.2, the operator will be creating the searchCoordinator custom role automatically
26# From MongoDB 8.2, searchCoordinator role will be a built-in role.
27kubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \
28  create secret generic "${MDB_RESOURCE_NAME}-search-sync-source-password" \
29  --from-literal=password="${MDB_SEARCH_SYNC_USER_PASSWORD}"
30kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
31apiVersion: mongodb.com/v1
32kind: MongoDBUser
33metadata:
34  name: search-sync-source-user
35spec:
36  username: search-sync-source
37  db: admin
38  mongodbResourceRef:
39    name: ${MDB_RESOURCE_NAME}
40  passwordSecretKeyRef:
41    name: ${MDB_RESOURCE_NAME}-search-sync-source-password
42    key: password
43  roles:
44  - name: searchCoordinator
45    db: admin
46EOF
47
48# user performing search queries
49kubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \
50  create secret generic mdb-user-password \
51  --from-literal=password="${MDB_USER_PASSWORD}"
52kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
53apiVersion: mongodb.com/v1
54kind: MongoDBUser
55metadata:
56  name: mdb-user
57spec:
58  username: mdb-user
59  db: admin
60  mongodbResourceRef:
61    name: ${MDB_RESOURCE_NAME}
62  passwordSecretKeyRef:
63    name: mdb-user-password
64    key: password
65  roles:
66  - name: readWrite
67    db: sample_mflix
68EOF
1secret/mdb-admin-user-password created
2secret/mdbc-rs-search-sync-source-password created
3secret/mdb-user-password created
6

Obligatorio. Cree e implemente el recurso para MongoDB Search y Vector Search.

Puede implementar una instancia del nodo de búsqueda sin balanceo de carga. Para implementarlo, siga estos pasos:

  1. Crea un recurso personalizado MongoDBSearch llamado mdbc-rs.

    Este recurso especifica los requisitos de CPU y memoria para los nodos de búsqueda. Para obtener más información sobre la configuración de este recurso personalizado, consulte Configuración de búsqueda vectorial y de búsqueda de 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  # no need to specify source.mongodbResourceRef if MongoDBSearch CR has the same name as MongoDB CR
    8  # the operator infer it automatically
    9  resourceRequirements:
    10    limits:
    11      cpu: "3"
    12      memory: 5Gi
    13    requests:
    14      cpu: "2"
    15      memory: 3Gi
    16EOF

  2. Espere a que se complete la implementación del recurso MongoDBSearch.

    Al aplicar el recurso personalizado MongoDBSearch, el operador de Kubernetes comienza a implementar los nodos de búsqueda (pods). Este paso pausa la ejecución hasta que la fase de estado del recurso mdbc-rs sea Running, lo que indica que el conjunto de réplicas de MongoDB Community está operativo.

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

Opcional. Verifique el estado del recurso MongoDB Enterprise.

Asegúrese de que la implementación del recurso MongoDB con MongoDBSearch haya sido exitosa.

1echo "Waiting for MongoDB resource to reach Running phase..."
2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=jsonpath='{.status.phase}'=Running "mdb/${MDB_RESOURCE_NAME}" --timeout=400s
8

Opcional. Ver todos los pods en ejecución en tu espacio de nombres.

Visualiza todos los pods en ejecución en los pods de tu namespace para los miembros del set de réplicas MongoDB, los Controladores MongoDB para Kubernetes operador y los nodos de búsqueda.

1echo; echo "MongoDB resource"
2kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdb/${MDB_RESOURCE_NAME}"
3echo; echo "MongoDBSearch resource"
4kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdbs/${MDB_RESOURCE_NAME}"
5echo; echo "Pods running in cluster ${K8S_CTX}"
6kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
1MongoDB resource
2NAME     PHASE     VERSION     TYPE         AGE
3mdb-rs   Running   8.2.0-ent   ReplicaSet   5m7s
4
5MongoDBSearch resource
6NAME     PHASE     AGE
7mdb-rs   Running   3m9s
8
9Pods running in cluster kind-kind
10NAME                                           READY   STATUS    RESTARTS       AGE
11mdb-rs-0                                       1/1     Running   0              5m4s
12mdb-rs-1                                       1/1     Running   0              4m40s
13mdb-rs-2                                       1/1     Running   0              4m15s
14mdb-rs-search-0                                1/1     Running   3 (112s ago)   2m29s
15mongodb-kubernetes-operator-57c6f46b47-gdwbc   1/1     Running   0              5m9s

Próximos pasos

Ahora que ha implementado correctamente MongoDB Search y Vector Search para usar con MongoDB Enterprise Edition, puede agregar datos a su clúster de MongoDB, crear índices de MongoDB Search y Vector Search, y ejecutar consultas en sus datos. Para obtener más información, consulte Configuración de MongoDB Search y Vector Search.

En esta página