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.
Menu Docs
Página inicial do Docs
/ /
Implementar pesquisa e Vector Search
Página inicial do Docs
/
Gestão
/
Controladores para o Operador do Kubernetes
/
Implementar pesquisa e Vector Search
Página inicial do Docs
/
Gestão
/
Controladores para o Operador do Kubernetes
/
Implementar pesquisa e Vector Search

Instalação e uso Com o MongoDB Community Edition

Você pode usar o Kubernetes Operator e distribuir os recursos de processo mongot para serem executados com o MongoDB Community Edition v8.3 ou posterior em um cluster Kubernetes. O processo mongot oferece suporte ao MongoDB Search e ao Vector Search. Opcionalmente, você pode ativar e configurar o Vector Search para gerar automaticamente incorporações vetoriais para dados de texto em suas coleções e queries usando um modelo de incorporação Voyage AI compatível.

Importante

A incorporação automática está em visualização. O recurso e a documentação correspondente podem mudar a qualquer momento durante o período de pré-visualização. Para **aprender** mais, consulte Visualizar recursos.

The following procedure demonstrates how to deploy and configure MongoDB Search and Vector Search to run with a new or existing replica set in your Kubernetes cluster. The deployment uses TLS certificates to ensure secure communication between MongoDB nodes and the mongot search process.

Pré-requisitos

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

  • Um cluster Kubernetes em execução.

  • 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.

  • cert-manager ou uma solução alternativa de gerenciamento de certificados para o provisionamento de certificados TLS.

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

Opcionalmente, para configurar a pesquisa vetorial para gerar automaticamente incorporações vetoriais para dados de texto em suas coleções e queries, você deve criar chaves de API para o serviço de incorporação. Recomendamos criar duas chaves, uma para gerar incorporações em tempo de índice para dados de texto em sua coleção e outra para gerar incorporações em tempo de query para seu texto de query. Se você não tiver as chaves, poderá criar as chaves a partir da IU do Atlas.

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:

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
22export MDB_VERSION="8.3.4"
23
24# root admin user for convenience, not used here at all in this guide
25export MDB_ADMIN_USER_PASSWORD="admin-user-password-CHANGE-ME"
26# regular user performing restore and search queries on sample mflix database
27export MDB_USER_PASSWORD="mdb-user-password-CHANGE-ME"
28# user for MongoDB Search to connect to the replica set to synchronise data from
29export MDB_SEARCH_SYNC_USER_PASSWORD="search-sync-user-password-CHANGE-ME"
30
31export OPERATOR_HELM_CHART="mongodb/mongodb-kubernetes"
32# comma-separated key=value pairs for additional parameters passed to the helm-chart installing the operator
33export OPERATOR_ADDITIONAL_HELM_VALUES=""
34
35# TLS is mandatory; connection string must include tls=true
36export 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"
37
38export CERT_MANAGER_NAMESPACE="cert-manager"
39
40# Vector Search auto embedding related configurations
41export AUTO_EMBEDDING_API_KEY_SECRET_NAME="voyage-api-keys"
42export AUTO_EMBEDDING_API_QUERY_KEY="<embedding-model-query-key>"
43export AUTO_EMBEDDING_API_INDEXING_KEY="<embedding-model-indexing-key>"
44export PROVIDER_ENDPOINT="https://ai.mongodb.com/v1/embeddings"
45export EMBEDDING_MODEL="voyage-4"

Observação

Se você tiver as chaves de API para permitir que a pesquisa vetorial gere automaticamente incorporações, substitua os seguintes valores de espaço reservado nas variáveis de ambiente:

AUTO_EMBEDDING_API_QUERY_KEY

Chave API para gerar incorporações para o texto da query.

AUTO_EMBEDDING_API_INDEXING_KEY

Chave de API para gerar incorporações para dados de texto em sua coleção no momento do índice.

PROVIDER_ENDPOINT

Incorporando ponto de extremidade do provedor do modelo. O valor padrão é https://ai.mongodb.com/v1/embeddings para chaves criadas a partir da IU do Atlas. Substitua por https://api.voyageai.com/v1/embeddings se você criou as chaves API diretamente da Voyage IA.

Opcional

Valide que as variáveis de ambiente foram definidas.

Para verificar se todas as variáveis de ambiente necessárias estão definidas, execute o seguinte código no seu terminal:

1required=(
2  K8S_CTX
3  MDB_NS
4  MDB_RESOURCE_NAME
5  MDB_VERSION
6  MDB_MEMBERS
7  CERT_MANAGER_NAMESPACE
8  MDB_TLS_CA_SECRET_NAME
9  MDB_TLS_SERVER_CERT_SECRET_NAME
10  MDB_SEARCH_TLS_SECRET_NAME
11  MDB_ADMIN_USER_PASSWORD
12  MDB_SEARCH_SYNC_USER_PASSWORD
13  MDB_USER_PASSWORD
14  OPERATOR_HELM_CHART
15)
16
17missing_req=()
18for v in "${required[@]}"; do [[ -n "${!v:-}" ]] || missing_req+=("${v}"); done
19
20if (( ${#missing_req[@]} )); then
21  echo "ERROR: Missing required environment variables:" >&2
22  for m in "${missing_req[@]}"; do echo "  - ${m}" >&2; done
23else
24  echo "All required environment variables present."
25fi
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á tiver o repositório Helm que contém o gráfico Helm para instalar o operador Kubernetes, ou pule esta etapa. Caso contrário, adicione o repositório Helm.

Para adicionar o repositório Helm, copie, cole e execute o seguinte:

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

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

O Operador Kubernetes observa MongoDBCommunity e os recursos personalizados do MongoDBSearch e gerencia o ciclo de vida de suas implantações do MongoDB. Se você já instalou os Controladores MongoDB para Kubernetes operador, 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 mongodb, copie, cole e execute os seguintes comandos:

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

Opcional. Aguarde a implantação do operador.

Certifique-se de que o operador Kubernetes esteja totalmente operacional antes de prosseguir com a implantação do MongoDB pesquisa e pesquisa vetorial. Execute o comando a seguir para verificar se todos os componentes do operador estão em execução e disponíveis.

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

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 operador usa senhas desses segredos para criar automaticamente os usuários no banco de dados MongoDB.

Para criar os segredos, copie, cole e execute o seguinte comando:

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

Conditional. Install the cert-manager.

The cert-manager is required for managing TLS certificates. If you already have cert-manager installed in your cluster, skip this step. Otherwise, install cert-manager using Helm.

Para instalar o cert-manager no namespace cert-manager, execute o seguinte comando em seu terminal:

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

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

Create the certificate authority infrastructure that will issue TLS certificates for MongoDB and MongoDBSearch resources. The commands perform the following actions:

  • 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.

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

Obrigatório. Emita certificados TLS.

Issue TLS certificates for both the MongoDB server and the MongoDBSearch service. The MongoDB server certificate includes all necessary DNS names for the pod and service communication. Both certificates support server and client authentication.

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-0-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

Condicional. Crie e implante o recurso MongoDB Community.

Se você já tiver implantado a MongoDB Community Edition, pule esta etapa. Caso contrário, implante o MongoDB Community Edition.

Para implantar a MongoDB Community Edition, complete as seguintes etapas:

  1. Crie um recurso personalizado do MongoDBCommunity denominado mdb-rs.

    O recurso define os recursos de memória e CPU para os contêineres mongod e mongodb-agent e configura os três usuários a seguir:

    mdb-user

    Usuário que pode restaurar banco de dados e executar query de pesquisa. Este usuário utiliza o segredo mdb-user-password para executar estas operações.

    search-sync-source

    Usuário que o MongoDB Pesquisa usa para se conectar ao banco de dados MongoDB para gerenciar e construir índices. Este usuário usa a função searchCoordinator que o operador Kubernetes cria. Isso usa o segredo mdbc-rs-search-sync-source-password para conectar mongot a mongod.

    admin-user

    Usuário administrador do banco de dados.

    O operador Kubernetes utiliza este recurso para configurar um conjunto de réplicas MongoDB com 3 membros.

    Para criar os segredos, copie, cole e execute os seguintes comandos:

    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. Aguarde a conclusão do sistema de recursos MongoDBCommunity.

    Quando você aplica o recurso personalizado do MongoDBCommunity, 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.

    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

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

Você pode implantar 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.

    1# create a Kubernetes secret that would have embedding model's API Keys
    2kubectl create secret generic "${AUTO_EMBEDDING_API_KEY_SECRET_NAME}" \
    3  --from-literal=query-key="${AUTO_EMBEDDING_API_QUERY_KEY}" \
    4  --from-literal=indexing-key="${AUTO_EMBEDDING_API_INDEXING_KEY}" --context "${K8S_CTX}" -n "${MDB_NS}"
    5
    6# create MongoDBSearch resource, enabling the auto embedding using the API Keys provided above
    7kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
    8apiVersion: mongodb.com/v1
    9kind: MongoDBSearch
    10metadata:
    11  name: ${MDB_RESOURCE_NAME}
    12spec:
    13  security:
    14    tls:
    15      certificateKeySecretRef:
    16        name: ${MDB_SEARCH_TLS_SECRET_NAME}
    17  autoEmbedding:
    18    providerEndpoint: ${PROVIDER_ENDPOINT}
    19    embeddingModelAPIKeySecret:
    20      name: ${AUTO_EMBEDDING_API_KEY_SECRET_NAME}
    21  clusters:
    22    - resourceRequirements:
    23        limits:
    24          cpu: "3"
    25          memory: 5Gi
    26        requests:
    27          cpu: "2"
    28          memory: 3Gi
    29EOF

    Observação

    Como o operador Kubernetes implanta apenas uma única instância do MongoDB Search, essa instância é configurada automaticamente como o gravador de visualizações materializadas de incorporação.

    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  clusters:
    12    - resourceRequirements:
    13        limits:
    14          cpu: "3"
    15          memory: 5Gi
    16        requests:
    17          cpu: "2"
    18          memory: 3Gi
    19EOF

  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 MongoDBSearch seja Running, o que indica que a pesquisa do MongoDB está operacional.

    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

Opcional. Verifique o status do recurso MongoDB Community .

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

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

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.

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

Verificar a implantação

Após a conclusão do procedimento, confirme se a implantação está saudável antes de executar as queries.

checkpoint
Etapa de verificação

MongoDB Community recurso em execução

Execute kubectl get mongodbcommunity -n <your-namespace> e confirme se o recurso MongoDBCommunity mostra a fase Running.

Recurso do MongoDB Search em execução

Execute kubectl get mongodbsearch -n <your-namespace> e confirme se o recurso MongoDBSearch mostra a fase Running.

Todos os pods estão saudáveis

Execute kubectl get pods -n <your-namespace> e confirme se todos os pods de nós do conjunto de réplicas e os pods de pesquisa mostram um status Running com todos os contêineres prontos.

query de pesquisa bem-sucedida

Conecte-se ao conjunto de réplicas e execute uma query de pesquisa do MongoDB ou uma query de pesquisa vetorial para confirmar se o índice de pesquisa está acessível.

Próximos passos

Depois de implantar o MongoDB Search e a pesquisa vetorial com o MongoDB Community Edition, você pode:

Avalie esta página

Nesta página