Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.

Instalar e usar a pesquisa com o MongoDB Enterprise Edition

Você pode usar o operador Kubernetes para implantar recursos do MongoDB Search e da pesquisa vetorial para executar com o MongoDB Enterprise v8.2.0 ou superior em um cluster Kubernetes. Este procedimento demonstra como implantar e configurar o processo mongot para executar com um conjunto de réplicas novo ou existente no seu cluster Kubernetes. A implantação usa certificados TLS para garantir a comunicação segura entre os nós do MongoDB e o processo de pesquisa mongot.

Pré-requisitos

Para implantar o MongoDB Search e o Vector Search, você deve ter o seguinte:

  • Um cluster Kubernetes em execução com kubeconfig disponível localmente.

  • A ferramenta de linha de comando do Kubernetes, kubectl, configurada para se comunicar com seu cluster.

  • Helm, o gerenciador de pacote do Kubernetes, para instalar o Operador Kubernetes.

  • Bash v5.1 ou superior para executar os comandos neste tutorial.

  • projeto MongoDB Ops Manager ou MongoDB Cloud Manager e credenciais de API.

Procedimento

1

Obrigatório. Defina as variáveis de ambiente.

Defina as variáveis de ambiente para uso nas etapas subsequentes deste procedimento. Copie os seguintes comandos, atualize os valores do seu ambiente e execute-os para carregar as variáveis:

# 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. Adicione o repositório do MongoDB Helm.

O Helm automatiza a implantação e o gerenciamento de instâncias do MongoDB no Kubernetes. Se você já adicionou o repositório Helm que contém o gráfico Helm para instalar o operador Kubernetes Operator, pule esta etapa. Caso contrário, adicione o repositório Helm.

Para adicionar, copie, cole e execute o seguinte comando:

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

Condicional. Instale os drivers do MongoDB para o Kubernetes Operator.

O Operador Kubernetes observa MongoDB, MongoDBOpsManager e MongoDBSearch recursos personalizados e gerencia o ciclo de vida de suas implantações do MongoDB. Se você já instalou os Controladores MongoDB para operador Kubernetes, pule esta etapa. Caso contrário, instale os Controladores MongoDB para Kubernetes operador a partir do repositório Helm que você adicionou na etapa anterior.

Para instalar os Controladores MongoDB para o Operador Kubernetes no namespace do mongodb, copie, cole e execute o seguinte:

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 o cert-manager.

O cert-manager é necessário para gerenciar certificados TLS. Se você já tiver o cert-manager instalado em seu cluster, pule esta etapa. Caso contrário, instale o cert-manager usando o Helm.

Para instalar o cert-manager no namespace cert-manager, execute o seguinte comando em seu 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

Obrigatório. Prepare o emissor do certificado e a infraestrutura da CA.

Criar a infraestrutura da autoridade de certificação que emitirá certificados TLS para os recursos MongoDB e MongoDBSearch. Os comandos executam as seguintes ações:

  • Crie um ClusterIssuer autoassinado.

  • Gere um certificado CA.

  • Publique um emissor de CA em todo o cluster que todos os namespaces possam usar.

  • Exponha o pacote CA por meio de um ConfigMap para que os recursos do MongoDB possam usá-lo.

# 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

Obrigatório. Emita certificados TLS.

Emitir certificados TLS para o servidor MongoDB (${MDB_RESOURCE_NAME}-server-tls) e para o serviço MongoDBSearch (${MDB_RESOURCE_NAME}-search-tls). O certificado do servidor MongoDB inclui todos os nomes DNS necessários para a comunicação do pod e do serviço. Ambos os certificados suportam autenticação de servidor e 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. Crie e implemente o recurso MongoDB Enterprise .

Se você já implementou o MongoDB Enterprise, pule para a próxima etapa. Caso contrário, implemente o recurso MongoDB Enterprise .

Para implementar o MongoDB Enterprise, complete as seguintes etapas:

  1. Crie o ConfigMap e o segredo para o projeto MongoDB Ops Manager se estiver usando o MongoDB Ops Manager.

    Para armazenar a configuração e as credenciais para integração com o MongoDB Ops Manager, copie, cole e execute os seguintes 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. Crie um recurso personalizado do MongoDB denominado mdb-rs.

    O recurso define os recursos de memória e CPU para os containers mongod e mongodb-agent e instrui o Operador Kubernetes a configurar um conjunto de réplicas do MongoDB com membros 3:

    Para implantar o MongoDB Enterprise, copie, cole e execute o seguinte no 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. Aguarde a conclusão do sistema de recursos MongoDB.

    Quando você aplica o recurso personalizado do MongoDB, o operador Kubernetes começa a distribuir os nós MongoDB (Pods). Essa etapa pausa a execução até que a fase de status do recurso mdbc-rs seja Running, o que indica que o conjunto de réplicas da MongoDB Community está operacional.

    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

Obrigatório. Crie e carregue os segredos de usuário MongoDB .

O MongoDB requer autenticação para acesso seguro. Nesta etapa, você cria três segredos do Kubernetes:

  • mdb-admin-user-password: Credenciais do administrador do MongoDB .

  • mdb-user-password: Credenciais do usuário autorizado a realizar queries de pesquisa.

  • mdbc-rs-search-sync-source-password: Credenciais para um usuário de pesquisa dedicado utilizado internamente pelo processo do mongot para sincronizar dados e gerenciar índices.

O Kubernetes Operator monta esses segredos nos pods do MongoDB .

Para criar os segredos, copie, cole e execute o seguinte no namespace onde você distribuiu o MongoDB Server e planeja implantar a Pesquisa MongoDB e a Vector Search:

# 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

Obrigatório. Crie e implemente o recurso para MongoDB Search e Vector Search.

Você pode implementar uma instância do nó de pesquisa sem nenhum balanceamento de carga. Para implantar, conclua as seguintes etapas:

  1. Crie um recurso personalizado do MongoDBSearch denominado mdbc-rs.

    Este recurso especifica os requisitos de recursos de CPU e memória para os nós de pesquisa. Para saber mais sobre as configurações neste recurso personalizado, consulte Configurações de pesquisa do MongoDB e Vector Search.

    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. Aguarde a conclusão da implantação do recurso MongoDBSearch.

    Quando você aplica o recurso personalizado MongoDBSearch, o operador Kubernetes começa a implantar os nós de pesquisa (pods). Essa etapa pausa a execução até que a fase de status do recurso mdbc-rs seja Running, o que indica que o conjunto de réplicas da MongoDB Community está operacional.

    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. Verifique o status do recurso MongoDB Enterprise .

Certifique-se de que a implantação do recurso MongoDB com o MongoDBSearch tenha sido bem-sucedida.

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. Visualize todos os pods em execução em seu namespace.

Visualize todos os pods em execução nos pods do seu namespace para os nós do conjunto de réplicas do MongoDB , o operador do MongoDB Controladores for Kubernetes e os nós de pesquisa.

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 passos

Agora que implementou com sucesso o MongoDB Search e o Vector Search para usar com o MongoDB Enterprise Edition, você pode adicionar dados em seu cluster do MongoDB , criar índices do MongoDB Search e Vector Search e executar queries em seus dados. Para saber mais, consulte Configurações do MongoDB Search e Vector Search.

Avalie esta página

Nesta página