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 Ops Manager
Página inicial do Docs
/
Gestão
/
Controladores para o Operador do Kubernetes
/
Implementar Ops Manager
Página inicial do Docs
/
Gestão
/
Controladores para o Operador do Kubernetes
/
Implementar Ops Manager

Implemente o Ops Manager com um banco de dados de aplicativos externos

Você pode implantar um recurso do Ops Manager que usa um aplicativo de banco de dados externo: um recurso personalizado do MongoDB com spec.role definido como AppDB, que uma segunda instância do Ops Manager gerencia como um projeto. Isso permite que o Ops Manager faça backup e restaure o banco de dados do aplicativo. Para saber mais, consulte Fazer backup do Ops Manager Application Database.

Este procedimento implanta uma nova instância do Ops Manager. Para converter uma instância existente do Ops Manager que usa um banco de dados de aplicativos gerenciado internamente, consulte Migrar um banco de dados de aplicativos para um sistema externo.

Este procedimento implementa os seguintes recursos:

  • Uma instância de gerenciamento do Ops Manager com seu próprio banco de dados de aplicativos gerenciado internamente. Esta instância gerencia o projeto que contém o Banco de Dados de Aplicativo externo.

  • Um banco de dados de aplicativo externo: uma réplica do MongoDB definida com spec.role definido como AppDB, chamada <primary-om-name>-db.

  • Uma instância principal do Ops Manager que omite spec.applicationDatabase e referencia o banco de dados de aplicativo externo com spec.externalApplicationDatabaseRef.

Pré-requisitos

Antes de começar, conclua as seguintes tarefas:

  • Implemente um cluster Kubernetes com um StorageClass padrão.

  • Instale kubectl e helm e configure-os para esse cluster.

  • Obtenha acesso ao gráfico Helm do Operador Kubernetes.

Considerações

Defina a versão do Ops Manager e a versão do aplicativo de banco de dados como um par consistente. A instância de gerenciamento do Ops Manager gerencia o banco de dados de aplicativos externo, portanto, a versão do banco de dados de aplicativos deve ser uma versão do MongoDB que a instância de gerenciamento do Ops Manager oferece em seu manifesto da versão. Por exemplo, uma instância do 8.0.x Ops Manager oferece 8.0.x versões MongoDB , mas uma instância do 7.0.x Ops Manager não.

Procedimento

1

Configure as variáveis de ambiente para o sistema.

export K8S_CTX="<your-kube-context>"
export MDB_NS="mongodb"
export OPERATOR_HELM_CHART="oci://quay.io/mongodb/helm-charts/mongodb-kubernetes"
export OM_VERSION="8.0.7"
export APPDB_VERSION="8.0.5-ent"
export MANAGEMENT_OM_NAME="management-om"
export PRIMARY_OM_NAME="primary-om"
export APPDB_NAME="${PRIMARY_OM_NAME}-db"
export MANAGEMENT_OM_URL="http://${MANAGEMENT_OM_NAME}-svc.${MDB_NS}.svc.cluster.local:8080"
export MANAGEMENT_OM_ADMIN_KEY_SECRET="${MDB_NS}-${MANAGEMENT_OM_NAME}-admin-key"
export APPDB_PROJECT_CONFIGMAP="${APPDB_NAME}-config"
export APPDB_PROJECT_NAME="external-appdb"
export APPDB_CONNECTION_STRING_SECRET="${APPDB_NAME}-connection-string"
export OM_ADMIN_EMAIL="admin@example.com"
export OM_ADMIN_PASSWORD="<your-password>"
export OM_ADMIN_FIRST_NAME="Admin"
export OM_ADMIN_LAST_NAME="User"

O Operador Kubernetes exige que o Banco de Dados de Aplicativo externo seja denominado <primary-om-name>-db, e é por isso que APPDB_NAME deriva de PRIMARY_OM_NAME.

2

Crie o namespace.

kubectl create namespace "${MDB_NS}" --context "${K8S_CTX}"
3

Instale o Operador Kubernetes.

helm upgrade --install --kube-context "${K8S_CTX}" \
  --namespace "${MDB_NS}" --create-namespace \
  mongodb-kubernetes "${OPERATOR_HELM_CHART}"
kubectl rollout status deployment/mongodb-kubernetes-operator \
  --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=300s
4

Crie o segredo de administração do Ops Manager.

Ambos os recursos do Ops Manager referenciam este segredo com spec.adminCredentials.

kubectl create secret generic ops-manager-admin-secret \
  --context "${K8S_CTX}" -n "${MDB_NS}" \
  --from-literal=Username="${OM_ADMIN_EMAIL}" \
  --from-literal=Password="${OM_ADMIN_PASSWORD}" \
  --from-literal=FirstName="${OM_ADMIN_FIRST_NAME}" \
  --from-literal=LastName="${OM_ADMIN_LAST_NAME}"
5

Implemente a instância de gerenciamento do Ops Manager.

kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
apiVersion: mongodb.com/v1
kind: MongoDBOpsManager
metadata:
  name: ${MANAGEMENT_OM_NAME}
spec:
  replicas: 1
  version: ${OM_VERSION}
  adminCredentials: ops-manager-admin-secret
  applicationDatabase:
    members: 3
    version: ${APPDB_VERSION}
  backup:
    enabled: false
  configuration:
    automation.versions.source: mongodb
    mms.ignoreInitialUiSetup: "true"
    mms.adminEmailAddr: admin@example.com
    mms.fromEmailAddr: admin@example.com
    mms.replyToEmailAddr: admin@example.com
    mms.mail.hostname: email-smtp.us-east-1.amazonaws.com
    mms.mail.port: "465"
    mms.mail.ssl: "true"
    mms.mail.transport: smtp
    mms.minimumTLSVersion: TLSv1.2
EOF

As configurações de e-mail mms.* são obrigatórias. Quando mms.ignoreInitialUiSetup é true, a verificação pré-voo do Ops Manager não inicia o Ops Manager, a menos que mms.fromEmailAddr e as configurações de e-mail relacionadas estejam presentes.

6

Aguarde até que a instância de gerenciamento do Ops Manager fique pronta.

  1. Aguarde o banco de dados de aplicativos gerenciado internamente e o recurso Ops Manager:

    kubectl wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running \
      om/"${MANAGEMENT_OM_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=1200s
    kubectl wait --for=jsonpath='{.status.opsManager.phase}'=Running \
      om/"${MANAGEMENT_OM_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=1800s

  2. Confirme se a API pública do Ops Manager responde às solicitações. Um opsManager.phase de Running significa que o pod do Ops Manager está ativo, mas a API que o Kubernetes Operator usa para criar o projeto do aplicativo de banco de dados pode atrasar alguns segundos. Uma resposta 401 é a resposta não autenticada esperada e significa que a API está pronta:

    om_pod="${MANAGEMENT_OM_NAME}-0"
    until [ "$(kubectl exec "${om_pod}" -c mongodb-ops-manager --context "${K8S_CTX}" -n "${MDB_NS}" -- \
      curl -s -o /dev/null -w '%{http_code}' \
      "http://$(kubectl get pod "${om_pod}" --context "${K8S_CTX}" -n "${MDB_NS}" \
        -o jsonpath='{.status.podIP}'):8080/api/public/v1.0" 2>/dev/null)" = "401" ]; do
      echo "waiting for management Ops Manager public API..."; sleep 10
    done

  3. Confirme que o Operador do Kubernetes criou o segredo da chave API programática para a instância de gerenciamento do Ops Manager:

    kubectl get secret "${MANAGEMENT_OM_ADMIN_KEY_SECRET}" \
      --context "${K8S_CTX}" -n "${MDB_NS}"
7

Crie o projeto ConfigMap para o banco de dados de aplicativo externo.

kubectl create configmap "${APPDB_PROJECT_CONFIGMAP}" \
  --context "${K8S_CTX}" -n "${MDB_NS}" \
  --from-literal=baseUrl="${MANAGEMENT_OM_URL}" \
  --from-literal=projectName="${APPDB_PROJECT_NAME}" \
  --from-literal=orgId=""
8

Crie o banco de dados do aplicativo externo.

kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
apiVersion: mongodb.com/v1
kind: MongoDB
metadata:
  name: ${APPDB_NAME}
spec:
  members: 3
  version: ${APPDB_VERSION}
  type: ReplicaSet
  role: AppDB
  opsManager:
    configMapRef:
      name: ${APPDB_PROJECT_CONFIGMAP}
  credentials: ${MANAGEMENT_OM_ADMIN_KEY_SECRET}
  persistent: true
EOF
kubectl wait --for=jsonpath='{.status.phase}'=Running \
  mdb/"${APPDB_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=1200s

Quando você define spec.role como AppDB, o Operador Kubernetes configura a autenticação SCRAM para o recurso. Para saber mais, consulte spec.role.

9

Implemente a instância primária do Ops Manager.

Este recurso omite spec.applicationDatabase e, em vez disso, faz referência ao banco de dados de aplicativo externo.

kubectl apply --context "${K8S_CTX}" -n "${MDB_NS}" -f - <<EOF
apiVersion: mongodb.com/v1
kind: MongoDBOpsManager
metadata:
  name: ${PRIMARY_OM_NAME}
spec:
  replicas: 1
  version: ${OM_VERSION}
  adminCredentials: ops-manager-admin-secret
  externalApplicationDatabaseRef:
    name: ${APPDB_NAME}
    kind: MongoDB
  backup:
    enabled: false
  configuration:
    automation.versions.source: mongodb
    mms.ignoreInitialUiSetup: "true"
    mms.adminEmailAddr: admin@example.com
    mms.fromEmailAddr: admin@example.com
    mms.replyToEmailAddr: admin@example.com
    mms.mail.hostname: email-smtp.us-east-1.amazonaws.com
    mms.mail.port: "465"
    mms.mail.ssl: "true"
    mms.mail.transport: smtp
    mms.minimumTLSVersion: TLSv1.2
EOF

Para habilitar o backup para seus sistemas do MongoDB , defina spec.backup.enabled como true nesse recurso e configure o armazenamento de snapshot. Para saber mais, consulte Configurar o armazenamento de backup do sistema de arquivos com o Kubernetes Operator.

10

Aguarde até que a instância primária do Ops Manager fique pronta.

kubectl wait --for=jsonpath='{.status.opsManager.phase}'=Running \
  om/"${PRIMARY_OM_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=1800s
kubectl wait --for=jsonpath='{.status.applicationDatabase.phase}'=Disabled \
  om/"${PRIMARY_OM_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" --timeout=600s

O Kubernetes Operator não gerencia um aplicativo de banco de dados interno para um recurso do Ops Manager que usa um aplicativo de banco de dados externo, portanto, status.applicationDatabase.phase reporta Disabled. Isso é esperado e não é um erro.

11

Verifique a implantação.

  1. Confirme se os pods do Ops Manager de gerenciamento, os pods do banco de dados de aplicativos externos e os pods principais do Ops Manager estão em execução:

    kubectl get pods --context "${K8S_CTX}" -n "${MDB_NS}"

  2. Confirme que o recurso MongoDB possui o banco de dados do aplicativo StatefulSet e que o recurso principal do Ops Manager não:

    kubectl get statefulset "${APPDB_NAME}" --context "${K8S_CTX}" -n "${MDB_NS}" \
      -o jsonpath='{range .metadata.ownerReferences[*]}{.kind}/{.name}{"\n"}{end}'

    The command returns MongoDB/${APPDB_NAME}.

  3. Confirme que o operador Kubernetes criou o segredo da string de conexão para a instância primary do Ops Manager:

    kubectl get secret "${APPDB_CONNECTION_STRING_SECRET}" \
      --context "${K8S_CTX}" -n "${MDB_NS}"

Problemas comuns do banco de dados de aplicativos externos

O recurso MongoDB relata um erro de versão

Se o banco de dados de aplicativos externo relatar Failed com uma mensagem de que a versão do MongoDB não está disponível, defina spec.version como uma versão que a instância do Ops Manager de gerenciamento ofereça. Mantenha a versão do Ops Manager e a versão do banco de dados de aplicativos na mesma versão principal. O próprio banco de dados de aplicativos gerenciado internamente da instância de gerenciamento do Ops Manager não é afetado, pois ele baixa binários diretamente quando você define automation.versions.source como mongodb.

O banco de dados do aplicativo externo permanece pendente

Se o aplicativo de banco de dados externo permanecer na fase Pending e o MongoDB Agent nunca receber uma configuração de automação, você poderá ter criado o recurso MongoDB antes que a API pública do Ops Manager de gerenciamento estivesse atendendo solicitações. O operador Kubernetes não conseguiu criar o projeto. Confirme que a verificação de prontidão da API retorna 401 e, em seguida, reconciliar o recurso novamente.

O operador rejeita a referência do banco de dados do aplicativo externo

O valor de spec.externalApplicationDatabaseRef.name deve ser exatamente <primary-om-name>-db, e o recurso MongoDB deve estar no mesmo namespace que o recurso Ops Manager.

Próximos passos

To back up the external Application Database, enable backup on the MongoDB resource in the project that the management Ops Manager instance manages. To learn more, see Configure MongoDB Database Backups.

Voltar
Faça backup do banco de dados do aplicativo
Próximo
Migrar para um banco de dados de aplicativos externo
Avalie esta página

Nesta página