Para agentes de IA: hay un índice de documentación disponible en https://www.mongodb.com/es/docs/llms.txt — versiones en markdown de todas las páginas están disponibles agregando .md a cualquier ruta URL.

Instala y usa Búsqueda con MongoDB Enterprise Edition

Puede utilizar el operador de Kubernetes para implementar recursos de MongoDB Search y búsqueda vectorial para ejecutarse con MongoDB Enterprise v8.2.0 o superior en un clúster de Kubernetes. Este procedimiento demuestra cómo implementar y configurar el proceso mongot para ejecutar con un set de réplicas nuevo o existente en su clúster de Kubernetes. La implementación utiliza certificados TLS para garantizar una comunicación segura entre los nodos de MongoDB y el proceso de búsqueda mongot.

Requisitos previos

Para implementar MongoDB Search y búsqueda vectorial, se debe contar con 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 gestor de paquetes para Kubernetes, para instalar el Operador de Kubernetes.

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

  • MongoDB Ops Manager o proyecto MongoDB Cloud Manager y credenciales API.

Procedimiento

1

Obligatorio. Configurar las variables de entorno.

Configura las variables de entorno para usarlas en los pasos siguientes de este procedimiento. Copia los siguientes comandos, actualiza los valores de tu entorno y ejecútalos para cargar las variables:

# set it to the context name of the k8s clusterexport K8S_CTX="<local cluster context>"
# the following namespace will be created if not existsexport MDB_NS="mongodb"
# name of the MongoDB Custom Resource.export MDB_RESOURCE_NAME="mdb-rs"
export MDB_MEMBERS=3# OM/CM's project name to be used to manage mongodb replica setexport OPS_MANAGER_PROJECT_NAME="<arbitrary project name>"
# URL to Cloud Manager or Ops Manager instanceexport OPS_MANAGER_API_URL="https://cloud-qa.mongodb.com"
# The API key can be an Org Owner - the operator can create the project automatically then.# The API key can also be created in a particular project that was created manually with the Project Owner scope.export OPS_MANAGER_API_USER="<SET API USER>"export OPS_MANAGER_API_KEY="<SET API KEY>"export OPS_MANAGER_ORG_ID="<SET ORG ID>"
# minimum required MongoDB version for running MongoDB Search is 8.2.0export MDB_VERSION="8.2.0-ent"
# root admin user for convenience, not used here at all in this guideexport MDB_ADMIN_USER_PASSWORD="admin-user-password-CHANGE-ME"# regular user performing restore and search queries on sample mflix databaseexport MDB_USER_PASSWORD="mdb-user-password-CHANGE-ME"# user for MongoDB Search to connect to the replica set to synchronise data fromexport MDB_SEARCH_SYNC_USER_PASSWORD="search-sync-user-password-CHANGE-ME"
export OPERATOR_HELM_CHART="mongodb/mongodb-kubernetes"# comma-separated key=value pairs for additional parameters passed to the helm-chart installing the operatorexport OPERATOR_ADDITIONAL_HELM_VALUES=""
export MDB_TLS_CERT_SECRET_PREFIX="certs"export MDB_TLS_CA_CONFIGMAP="${MDB_RESOURCE_NAME}-ca-configmap"
export CERT_MANAGER_NAMESPACE="cert-manager"export MDB_TLS_SELF_SIGNED_ISSUER="selfsigned-bootstrap-issuer"export MDB_TLS_CA_CERT_NAME="my-selfsigned-ca"export MDB_TLS_CA_SECRET_NAME="root-secret"export MDB_TLS_CA_ISSUER="my-ca-issuer"export MDB_TLS_SERVER_CERT_SECRET_NAME="${MDB_TLS_CERT_SECRET_PREFIX}-${MDB_RESOURCE_NAME}-cert"export MDB_SEARCH_TLS_SECRET_NAME="${MDB_RESOURCE_NAME}-search-tls"
export MDB_CONNECTION_STRING="mongodb://mdb-user:${MDB_USER_PASSWORD}@${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local:27017/?replicaSet=${MDB_RESOURCE_NAME}&tls=true&tlsCAFile=/tls/ca.crt"
2

Condicional. Agrega el repositorio Helm de MongoDB.

Helm automatiza la implementación y gestión de instancias de MongoDB en Kubernetes. Si ya agregaste el repositorio de Helm que contiene la gráfica de Helm para instalar el operador Kubernetes Operator, omite este paso. De lo contrario, añade el repositorio Helm.

Para añadir, copiar, pegar y ejecutar el siguiente comando:

helm repo add mongodb https://mongodb.github.io/helm-chartshelm repo update mongodbhelm search repo mongodb/mongodb-kubernetes
3

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

El operador de Kubernetes observa MongoDB, MongoDBOpsManager y los recursos personalizados MongoDBSearch y gestiona el ciclo de vida de tus implementaciones de MongoDB. Si ya ha instalado los MongoDB Controllers para Kubernetes operador, omita este paso. De lo contrario, instala los Controladores de MongoDB para el Operador de Kubernetes desde el repositorio Helm que agregaste en el paso anterior.

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

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

Condicional. Instale el cert-manager.

El cert-manager es necesario para gestionar certificados TLS. Si ya tienes cert-manager instalado en tu clúster, omite este paso. O, de lo contrario, instala cert-manager usando Helm.

Para instalar cert-manager en el namespace cert-manager, ejecuta el siguiente comando en tu terminal:

helm upgrade --install \  cert-manager \  oci://quay.io/jetstack/charts/cert-manager \  --kube-context "${K8S_CTX}" \  --namespace "${CERT_MANAGER_NAMESPACE}" \  --create-namespace \  --set crds.enabled=true
for deployment in cert-manager cert-manager-cainjector cert-manager-webhook; do  kubectl --context "${K8S_CTX}" \    -n "${CERT_MANAGER_NAMESPACE}" \    wait --for=condition=Available "deployment/${deployment}" --timeout=300sdone
echo "cert-manager is ready in namespace ${CERT_MANAGER_NAMESPACE}."
5

Obligatorio. Prepara el emisor de certificados y la infraestructura de CA.

Cree la infraestructura de la autoridad de certificación que emitirá certificados TLS para los recursos MongoDB y MongoDBSearch. Los comandos realizan las siguientes acciones:

  • Crear un ClusterIssuer autofirmado.

  • Genera un certificado de CA.

  • Publica un emisor de CA para todo el clúster que todos los namespaces puedan utilizar.

  • Exponga el paquete de CA a través de un ConfigMap para que los recursos de MongoDB puedan usarlo.

# Bootstrap a self-signed ClusterIssuer to mint the CA secret consumed by application workloads.kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFESTapiVersion: cert-manager.io/v1kind: ClusterIssuermetadata:  name: ${MDB_TLS_SELF_SIGNED_ISSUER}spec:  selfSigned: {}EOF_MANIFEST
kubectl --context "${K8S_CTX}" wait --for=condition=Ready clusterissuer "${MDB_TLS_SELF_SIGNED_ISSUER}"
kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFESTapiVersion: cert-manager.io/v1kind: Certificatemetadata:  name: ${MDB_TLS_CA_CERT_NAME}  namespace: ${CERT_MANAGER_NAMESPACE}spec:  isCA: true  commonName: ${MDB_TLS_CA_CERT_NAME}  secretName: ${MDB_TLS_CA_SECRET_NAME}  privateKey:    algorithm: ECDSA    size: 256  issuerRef:    name: ${MDB_TLS_SELF_SIGNED_ISSUER}    kind: ClusterIssuerEOF_MANIFEST
kubectl --context "${K8S_CTX}" wait --for=condition=Ready -n "${CERT_MANAGER_NAMESPACE}" certificate "${MDB_TLS_CA_CERT_NAME}"
kubectl apply --context "${K8S_CTX}" -f - <<EOF_MANIFESTapiVersion: cert-manager.io/v1kind: ClusterIssuermetadata:  name: ${MDB_TLS_CA_ISSUER}spec:  ca:    secretName: ${MDB_TLS_CA_SECRET_NAME}EOF_MANIFEST
kubectl --context "${K8S_CTX}" wait --for=condition=Ready clusterissuer "${MDB_TLS_CA_ISSUER}"
TMP_CA_CERT="$(mktemp)"trap 'rm -f "${TMP_CA_CERT}"' EXIT
kubectl --context "${K8S_CTX}" get secret "${MDB_TLS_CA_SECRET_NAME}" -n "${CERT_MANAGER_NAMESPACE}" -o jsonpath="{.data['ca\\.crt']}" | base64 --decode > "${TMP_CA_CERT}"
kubectl --context "${K8S_CTX}" create configmap "${MDB_TLS_CA_CONFIGMAP}" -n "${MDB_NS}" \  --from-file=ca-pem="${TMP_CA_CERT}" --from-file=mms-ca.crt="${TMP_CA_CERT}" \  --from-file=ca.crt="${TMP_CA_CERT}" \  --dry-run=client -o yaml | kubectl --context "${K8S_CTX}" apply -f -
6

Obligatorio. Emitir certificados TLS.

Emitir certificados TLS tanto para el servidor MongoDB (${MDB_RESOURCE_NAME}-server-tls) como para el servicio MongoDBSearch (${MDB_RESOURCE_NAME}-search-tls). El certificado del servidor de MongoDB incluye todos los nombres DNS necesarios para la comunicación del pod y del servicio. Ambos certificados admiten la autenticación de servidor y cliente.

server_certificate="${MDB_RESOURCE_NAME}-server-tls"search_certificate="${MDB_RESOURCE_NAME}-search-tls"
mongo_dns_names=()for ((member = 0; member < MDB_MEMBERS; member++)); do  mongo_dns_names+=("${MDB_RESOURCE_NAME}-${member}")  mongo_dns_names+=("${MDB_RESOURCE_NAME}-${member}.${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local")donemongo_dns_names+=(  "${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local"  "*.${MDB_RESOURCE_NAME}-svc.${MDB_NS}.svc.cluster.local")
search_dns_names=(  "${MDB_RESOURCE_NAME}-search-svc.${MDB_NS}.svc.cluster.local")
render_dns_list() {  local dns_list=("$@")  for dns in "${dns_list[@]}"; do    printf "      - \"%s\"\n" "${dns}"  done}
kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF_MANIFESTapiVersion: cert-manager.io/v1kind: Certificatemetadata:  name: ${server_certificate}  namespace: ${MDB_NS}spec:  secretName: ${MDB_TLS_SERVER_CERT_SECRET_NAME}  issuerRef:    name: ${MDB_TLS_CA_ISSUER}    kind: ClusterIssuer  duration: 240h0m0s  renewBefore: 120h0m0s  usages:    - digital signature    - key encipherment    - server auth    - client auth  dnsNames:$(render_dns_list "${mongo_dns_names[@]}")---apiVersion: cert-manager.io/v1kind: Certificatemetadata:  name: ${search_certificate}  namespace: ${MDB_NS}spec:  secretName: ${MDB_SEARCH_TLS_SECRET_NAME}  issuerRef:    name: ${MDB_TLS_CA_ISSUER}    kind: ClusterIssuer  duration: 240h0m0s  renewBefore: 120h0m0s  usages:    - digital signature    - key encipherment    - server auth    - client auth  dnsNames:$(render_dns_list "${search_dns_names[@]}")EOF_MANIFEST
kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=condition=Ready certificate "${server_certificate}" --timeout=300skubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=condition=Ready certificate "${search_certificate}" --timeout=300s
7

Condicional. Crear e implementar el recurso MongoDB Enterprise.

Si ya ha implementado MongoDB Enterprise, pase 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 de 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:

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

  2. Crear un recurso personalizado MongoDB denominado mdb-rs.

    El recurso define los recursos de CPU y memoria para los contenedores mongod y mongodb-agent e instruye al Operador de Kubernetes para configurar un set de réplicas de MongoDB con 3 miembros:

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

    kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOFapiVersion: mongodb.com/v1kind: MongoDBmetadata:  name: ${MDB_RESOURCE_NAME}spec:  members: ${MDB_MEMBERS}  version: ${MDB_VERSION}  type: ReplicaSet  opsManager:    configMapRef:      name: om-project  credentials: om-credentials  security:    authentication:      enabled: true      ignoreUnknownUsers: true      modes:      - SCRAM    certsSecretPrefix: ${MDB_TLS_CERT_SECRET_PREFIX}    tls:      enabled: true      ca: ${MDB_TLS_CA_CONFIGMAP}  agent:    logLevel: INFO  podSpec:    podTemplate:      spec:        containers:        - name: mongodb-enterprise-database          resources:            limits:              cpu: "2"              memory: 2Gi            requests:              cpu: "1"              memory: 1GiEOF

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

    Cuando se aplica el recurso personalizado MongoDB, el operador de Kubernetes comienza a implementar los nodos de MongoDB (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 MongoDB Community está operativo.

    echo "Waiting for MongoDB resource to reach Running phase..."kubectl --context "${K8S_CTX}" -n "${MDB_NS}" wait --for=jsonpath='{.status.phase}'=Running "mdb/${MDB_RESOURCE_NAME}" --timeout=400secho; echo "MongoDB resource"kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdb/${MDB_RESOURCE_NAME}"echo; echo "Pods running in cluster ${K8S_CTX}"kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods
8

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 para el usuario autorizado a realizar consultas de búsqueda.

  • mdbc-rs-search-sync-source-password: Credenciales para un usuario de búsqueda dedicado usado 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, copia, pega y ejecuta lo siguiente en el namespace donde implementaste MongoDB Server y planeas implementar MongoDB Search y búsqueda vectorial:

# admin user with root rolekubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \  create secret generic mdb-admin-user-password \  --from-literal=password="${MDB_ADMIN_USER_PASSWORD}"
kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOFapiVersion: mongodb.com/v1kind: MongoDBUsermetadata:  name: mdb-adminspec:  username: mdb-admin  db: admin  mongodbResourceRef:    name: ${MDB_RESOURCE_NAME}  passwordSecretKeyRef:    name: mdb-admin-user-password    key: password  roles:  - name: root    db: adminEOF
# user used by MongoDB Search to connect to MongoDB database to synchronize data from# For MongoDB <8.2, the operator will be creating the searchCoordinator custom role automatically# From MongoDB 8.2, searchCoordinator role will be a built-in role.kubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \  create secret generic "${MDB_RESOURCE_NAME}-search-sync-source-password" \  --from-literal=password="${MDB_SEARCH_SYNC_USER_PASSWORD}"kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOFapiVersion: mongodb.com/v1kind: MongoDBUsermetadata:  name: search-sync-source-userspec:  username: search-sync-source  db: admin  mongodbResourceRef:    name: ${MDB_RESOURCE_NAME}  passwordSecretKeyRef:    name: ${MDB_RESOURCE_NAME}-search-sync-source-password    key: password  roles:  - name: searchCoordinator    db: adminEOF
# user performing search querieskubectl --context "${K8S_CTX}" --namespace "${MDB_NS}" \  create secret generic mdb-user-password \  --from-literal=password="${MDB_USER_PASSWORD}"kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOFapiVersion: mongodb.com/v1kind: MongoDBUsermetadata:  name: mdb-userspec:  username: mdb-user  db: admin  mongodbResourceRef:    name: ${MDB_RESOURCE_NAME}  passwordSecretKeyRef:    name: mdb-user-password    key: password  roles:  - name: readWrite    db: sample_mflixEOF
9

Requerido. Crea y implementa el recurso para MongoDB Search y la búsqueda vectorial.

Puedes implementar una instancia del nodo de búsqueda sin balanceo de carga. Para implementar, completa los siguientes pasos:

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

    Este recurso especifica los requisitos de recursos 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 MongoDB Search y búsqueda vectorial.

    kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOFapiVersion: mongodb.com/v1kind: MongoDBSearchmetadata:  name: ${MDB_RESOURCE_NAME}spec:  # no need to specify source.mongodbResourceRef if MongoDBSearch CR has the same name as MongoDB CR  # the operator infer it automatically  security:    tls:      certificateKeySecretRef:        name: ${MDB_SEARCH_TLS_SECRET_NAME}  resourceRequirements:    limits:      cpu: "3"      memory: 5Gi    requests:      cpu: "2"      memory: 3GiEOF

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

    Cuando implemente el recurso personalizado MongoDBSearch, el operador de Kubernetes comenzará 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 set de réplicas de MongoDB Community está operativo.

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

opcional. Verifica el estado del recurso MongoDB Enterprise.

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

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

opcional. Consulta todos los pods en ejecución en tu namespace.

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.

echo; echo "MongoDB resource"kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdb/${MDB_RESOURCE_NAME}"echo; echo "MongoDBSearch resource"kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get "mdbs/${MDB_RESOURCE_NAME}"echo; echo "Pods running in cluster ${K8S_CTX}"kubectl --context "${K8S_CTX}" -n "${MDB_NS}" get pods

Próximos pasos

Ahora que has implementado con éxito MongoDB Search y búsqueda vectorial para su uso con MongoDB Enterprise Edition, puedes agregar datos en tu clúster de MongoDB, crear índices de MongoDB Search y búsqueda vectorial, y ejecutar queries en tus datos. Para obtener más información, consulta Configuración de MongoDB Search y búsqueda vectorial.

Califique esta página

En esta página