Menu Docs
Página inicial do Docs
/
Operador de Kubernetes empresarial
/
Arquiteturas de referência
/
Arquitetura de vários clusters

Ops Manager de vários clusters

O Ops Manager é responsável por facilitar volumes de trabalho, como backup de dados, monitorar o desempenho do banco de dados e muito mais. Para tornar o Ops Manager de vários clusters e o sistema de banco de dados de aplicativos resilientes a falhas de data center ou de zona inteiras, implemente o aplicativo Ops Manager e o sistema de banco de dados de aplicativos em vários clusters do Kubernetes.

Pré-requisitos

Antes de iniciar o procedimento a seguir, execute as seguintes ações:

  • Instale o kubectl.

  • Conclua o procedimento GKE Clusters ou equivalente.

  • Conclua o procedimento Certificados TLS ou equivalente.

  • Conclua o procedimento Istion Service Mesh ou equivalente.

  • Conclua o procedimento Implementar o operador MongoDB.

  • Configure as variáveis de ambiente necessárias da seguinte maneira:

# This script builds on top of the environment configured in the setup guides.
# It depends (uses) the following env variables defined there to work correctly.
# If you don't use the setup guide to bootstrap the environment, then define them here.
#  ${K8S_CLUSTER_0_CONTEXT_NAME}
#  ${K8S_CLUSTER_1_CONTEXT_NAME}
#  ${K8S_CLUSTER_2_CONTEXT_NAME}
#  ${OM_NAMESPACE}
export S3_OPLOG_BUCKET_NAME=s3-oplog-store
export S3_SNAPSHOT_BUCKET_NAME=s3-snapshot-store
# If you use your own S3 storage - set the values accordingly.
# By default we install Minio to handle S3 storage and here are set the default credentials.
export S3_ENDPOINT="minio.tenant-tiny.svc.cluster.local"
export S3_ACCESS_KEY="console"
export S3_SECRET_KEY="console123"
# (Optional) Change the following setting when using the external URL.
# This env variable is used in OpenSSL configuration to generate
# server certificates for Ops Manager Application.
export OPS_MANAGER_EXTERNAL_DOMAIN="om-svc.${OM_NAMESPACE}.svc.cluster.local"
export OPS_MANAGER_VERSION="8.0.4"
export APPDB_VERSION="8.0.5"

código fonte

Você pode encontrar todo o código-fonte incluído no repositório do MongoDB Kubernetes Operator.

Procedimento

1

Gerar certificados TLS.

kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" apply -f - <<EOF
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: om-cert
spec:
  dnsNames:
  - ${OPS_MANAGER_EXTERNAL_DOMAIN}
  - om-svc.${OM_NAMESPACE}.svc.cluster.local
  duration: 240h0m0s
  issuerRef:
    name: my-ca-issuer
    kind: ClusterIssuer
  renewBefore: 120h0m0s
  secretName: cert-prefix-om-cert
  usages:
  - server auth
  - client auth
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: om-db-cert
spec:
  dnsNames:
  - "*.${OM_NAMESPACE}.svc.cluster.local"
  - "*.om-db-svc.${OM_NAMESPACE}.svc.cluster.local"
  duration: 240h0m0s
  issuerRef:
    name: my-ca-issuer
    kind: ClusterIssuer
  renewBefore: 120h0m0s
  secretName: cert-prefix-om-db-cert
  usages:
  - server auth
  - client auth
EOF
2

Instale o Ops Manager.

Neste ponto, você preparou o ambiente e o Operador Kubernetes para implantar o recurso MongoDB Ops Manager .

  1. Crie as credenciais necessárias para o usuário administrador do MongoDB Ops Manager que o operador Kubernetes criará após implantar a instância do aplicativo MongoDB Ops Manager :

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" --namespace "${OM_NAMESPACE}" create secret generic om-admin-user-credentials \
    2  --from-literal=Username="admin" \
    3  --from-literal=Password="Passw0rd@" \
    4  --from-literal=FirstName="Jane" \
    5  --from-literal=LastName="Doe"

  2. Implemente o MongoDBOpsManager recurso personalizado do mais simples possível (com o TLS do habilitado) em um cluster de único membro, que também é conhecido como o cluster do operador.

    Essa implantação é quase igual à implantação do modo de cluster único, mas com spec.topology e spec.applicationDatabase.topology definidos como MultiCluster.

    A implantação dessa forma mostra que um único sistema de cluster Kubernetes é um caso especial de um sistema de cluster multi-Kubernetes em um único cluster de membro do Kubernetes. Você pode começar a implantar o Aplicativo MongoDB Ops Manager e o Banco de Dados de Aplicativos em quantos clusters Kubernetes necessários desde o início e não precisa começar com a implantação com apenas um cluster Kubernetes de nó único.

    Neste ponto, você preparou a implantação do MongoDB Ops Manager para abranger mais de um cluster Kubernetes , o que você fará mais tarde neste procedimento.

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" -f - <<EOF
    2apiVersion: mongodb.com/v1
    3kind: MongoDBOpsManager
    4metadata:
    5  name: om
    6spec:
    7  topology: MultiCluster
    8  version: "${OPS_MANAGER_VERSION}"
    9  adminCredentials: om-admin-user-credentials
    10  externalConnectivity:
    11    type: LoadBalancer
    12  security:
    13    certsSecretPrefix: cert-prefix
    14    tls:
    15      ca: ca-issuer
    16  clusterSpecList:
    17    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    18      members: 1
    19  applicationDatabase:
    20    version: "${APPDB_VERSION}"
    21    topology: MultiCluster
    22    security:
    23      certsSecretPrefix: cert-prefix
    24      tls:
    25        ca: ca-issuer
    26    clusterSpecList:
    27      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    28        members: 3
    29  backup:
    30    enabled: false
    31EOF

  3. Aguarde o operador Kubernetes pegar o trabalho e alcançar o estado status.applicationDatabase.phase=Pending . Aguarde a conclusão das implantações do banco de dados de aplicativos e do MongoDB Ops Manager .

    1echo "Waiting for Application Database to reach Pending phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Pending opsmanager/om --timeout=30s
    1Waiting for Application Database to reach Pending phase...
    2mongodbopsmanager.mongodb.com/om condition met

  4. Implemente MongoDB Ops Manager. O Operador Kubernetes implementa o MongoDB Ops Manager executando as etapas a seguir. Ele:

    • Distribui os nós do conjunto de réplicas do banco de dados de aplicativos e aguarda que os processos do MongoDB no conjunto de réplicas comecem a ser executados.

    • Implementa a instância do Aplicativo MongoDB Ops Manager com a connection string do Banco de Dados do Aplicativo e aguarda que ela fique pronta.

    • Adiciona os containers do MongoDB Agent de monitoramento ao Pod de cada banco de dados de aplicativos.

    • Aguarde que o aplicativo MongoDB Ops Manager e os pods do banco de dados de aplicativos comecem a ser executados.

    1echo "Waiting for Application Database to reach Running phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s
    3echo; echo "Waiting for Ops Manager to reach Running phase..."
    4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=900s
    5echo; echo "Waiting for Application Database to reach Pending phase (enabling monitoring)..."
    6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s
    7echo "Waiting for Application Database to reach Running phase..."
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s
    9echo; echo "Waiting for Ops Manager to reach Running phase..."
    10kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=900s
    11echo; echo "MongoDBOpsManager resource"
    12kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get opsmanager/om
    13echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    14kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    15echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    16kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    1Waiting for Application Database to reach Running phase...
    2mongodbopsmanager.mongodb.com/om condition met
    3
    4Waiting for Ops Manager to reach Running phase...
    5mongodbopsmanager.mongodb.com/om condition met
    6
    7Waiting for Application Database to reach Pending phase (enabling monitoring)...
    8mongodbopsmanager.mongodb.com/om condition met
    9Waiting for Application Database to reach Running phase...
    10mongodbopsmanager.mongodb.com/om condition met
    11
    12Waiting for Ops Manager to reach Running phase...
    13mongodbopsmanager.mongodb.com/om condition met
    14
    15MongoDBOpsManager resource
    16NAME   REPLICAS   VERSION   STATE (OPSMANAGER)   STATE (APPDB)   STATE (BACKUP)   AGE   WARNINGS
    17om                8.0.4     Running              Running         Disabled         11m   
    18
    19Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0-67d0389d75b70a0007e5894a
    20NAME        READY   STATUS    RESTARTS   AGE
    21om-0-0      2/2     Running   0          7m35s
    22om-db-0-0   4/4     Running   0          37s
    23om-db-0-1   4/4     Running   0          115s
    24om-db-0-2   4/4     Running   0          2m57s
    25
    26Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1-67d0389d75b70a0007e5894a

    Agora que você distribuiu um cluster de um único membro em um modo de vários clusters, é possível reconfigurar o sistema para abranger mais de um cluster do Kubernetes.

  5. No segundo cluster de membros, implemente dois membros adicionais do conjunto de réplicas do Banco de Dados de Aplicativo e uma instância adicional do Aplicativo MongoDB Ops Manager :

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" -f - <<EOF
    2apiVersion: mongodb.com/v1
    3kind: MongoDBOpsManager
    4metadata:
    5  name: om
    6spec:
    7  topology: MultiCluster
    8  version: "${OPS_MANAGER_VERSION}"
    9  adminCredentials: om-admin-user-credentials
    10  externalConnectivity:
    11    type: LoadBalancer
    12  security:
    13    certsSecretPrefix: cert-prefix
    14    tls:
    15      ca: ca-issuer
    16  clusterSpecList:
    17    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    18      members: 1
    19    - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    20      members: 1
    21  applicationDatabase:
    22    version: "${APPDB_VERSION}"
    23    topology: MultiCluster
    24    security:
    25      certsSecretPrefix: cert-prefix
    26      tls:
    27        ca: ca-issuer
    28    clusterSpecList:
    29      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    30        members: 3
    31      - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    32        members: 2
    33  backup:
    34    enabled: false
    35EOF

  6. Aguarde o Operador Kubernetes pegar o trabalho (fase pendente):

    1echo "Waiting for Application Database to reach Pending phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Pending opsmanager/om --timeout=30s
    1Waiting for Application Database to reach Pending phase...
    2mongodbopsmanager.mongodb.com/om condition met

  7. Aguarde o operador Kubernetes terminar de implantar todos os componentes:

    1echo "Waiting for Application Database to reach Running phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=600s
    3echo; echo "Waiting for Ops Manager to reach Running phase..."
    4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=600s
    5echo; echo "MongoDBOpsManager resource"
    6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get opsmanager/om
    7echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    9echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    10kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    1Waiting for Application Database to reach Running phase...
    2mongodbopsmanager.mongodb.com/om condition met
    3
    4Waiting for Ops Manager to reach Running phase...
    5mongodbopsmanager.mongodb.com/om condition met
    6
    7MongoDBOpsManager resource
    8NAME   REPLICAS   VERSION   STATE (OPSMANAGER)   STATE (APPDB)   STATE (BACKUP)   AGE   WARNINGS
    9om                8.0.4     Running              Running         Disabled         19m   
    10
    11Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0-67d0389d75b70a0007e5894a
    12NAME        READY   STATUS    RESTARTS   AGE
    13om-0-0      2/2     Running   0          2m35s
    14om-db-0-0   4/4     Running   0          8m35s
    15om-db-0-1   4/4     Running   0          9m53s
    16om-db-0-2   4/4     Running   0          10m
    17
    18Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1-67d0389d75b70a0007e5894a
    19NAME        READY   STATUS    RESTARTS   AGE
    20om-1-0      2/2     Running   0          3m5s
    21om-db-1-0   4/4     Running   0          7m49s
    22om-db-1-1   4/4     Running   0          5m54s
3

Habilitar backup.

Em um sistema de cluster multi-Kubernetes do Aplicativo de Ops Manager, você pode configurar somente o armazenamento de backup baseado em S3. Este procedimento refere-se ao S3_* definido em env_variables.sh.

  1. Opcional. Instale o Operador MinIO.

    Este procedimento implementa armazenamento compatível com S para3 seus backups usando o Operador MinIO. Você pode pular esta etapa se tiver o Amazon Web Services S3 ou outros blocos compatíveis com S3disponíveis. Ajuste as variáveis S3_* adequadamente em env_variables.sh neste caso.

    1kubectl kustomize "github.com/minio/operator/resources/?timeout=120&ref=v5.0.12" | \
    2  kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" apply -f -
    3
    4kubectl kustomize "github.com/minio/operator/examples/kustomization/tenant-tiny?timeout=120&ref=v5.0.12" | \
    5  kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" apply -f -
    6
    7# add two buckets to the tenant config
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "tenant-tiny" patch tenant/myminio \
    9  --type='json' \
    10  -p="[{\"op\": \"add\", \"path\": \"/spec/buckets\", \"value\": [{\"name\": \"${S3_OPLOG_BUCKET_NAME}\"}, {\"name\": \"${S3_SNAPSHOT_BUCKET_NAME}\"}]}]"
    11
    12kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" label namespace "tenant-tiny" istio-injection=enabled --overwrite

  2. Antes de configurar e ativar o backup, crie segredos:

    • s3-access-secret - contém credenciais S3 .

    • s3-ca-cert - contém um certificado CA que emitiu o certificado do servidor do bucket. No caso da implantação do MinIO de amostra usada neste procedimento, o certificado padrão da Kubernetes Root CA é usado para assinar o certificado. Como não é um certificado de CA confiável publicamente, você deve fornecê-lo para que o MongoDB Ops Manager possa confiar na conexão.

    Se você utilizar certificados publicamente confiáveis, você poderá pular esta etapa e remover os valores das configurações do spec.backup.s3Stores.customCertificateSecretRefs e spec.backup.s3OpLogStores.customCertificateSecretRefs .

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" create secret generic s3-access-secret \
    2  --from-literal=accessKey="${S3_ACCESS_KEY}" \
    3  --from-literal=secretKey="${S3_SECRET_KEY}"
    4
    5# minio TLS secrets are signed with the default k8s root CA
    6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" create secret generic s3-ca-cert \
    7  --from-literal=ca.crt="$(kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n kube-system get configmap kube-root-ca.crt -o jsonpath="{.data.ca\.crt}")"
4

Redistribua o MongoDB Ops Manager com o backup ativado.

  1. O Kubernetes Operator pode configurar e distribuir todos os componentes, o aplicativo MongoDB Ops Manager , as instâncias do Backup Daemon e os nós do conjunto de réplicas do aplicativo de banco de dados em qualquer combinação em qualquer cluster de membros para os quais você configure o Kubernetes Operator.

    Para ilustrar a flexibilidade da configuração de implantação de cluster multi-Kubernetes, implemente apenas uma instância do Backup Daemon no cluster do terceiro membro e especifique zero membros do Backup Daemon para o primeiro e o segundo cluster.

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" -f - <<EOF
    2apiVersion: mongodb.com/v1
    3kind: MongoDBOpsManager
    4metadata:
    5  name: om
    6spec:
    7  topology: MultiCluster
    8  version: "${OPS_MANAGER_VERSION}"
    9  adminCredentials: om-admin-user-credentials
    10  externalConnectivity:
    11    type: LoadBalancer
    12  security:
    13    certsSecretPrefix: cert-prefix
    14    tls:
    15      ca: ca-issuer
    16  clusterSpecList:
    17    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    18      members: 1
    19      backup:
    20        members: 0
    21    - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    22      members: 1
    23      backup:
    24        members: 0
    25    - clusterName: "${K8S_CLUSTER_2_CONTEXT_NAME}"
    26      members: 0
    27      backup:
    28        members: 1
    29  configuration: # to avoid configuration wizard on first login
    30      mms.adminEmailAddr: email@example.com
    31      mms.fromEmailAddr: email@example.com
    32      mms.ignoreInitialUiSetup: "true"
    33      mms.mail.hostname: smtp@example.com
    34      mms.mail.port: "465"
    35      mms.mail.ssl: "true"
    36      mms.mail.transport: smtp
    37      mms.minimumTLSVersion: TLSv1.2
    38      mms.replyToEmailAddr: email@example.com
    39  applicationDatabase:
    40    version: "${APPDB_VERSION}"
    41    topology: MultiCluster
    42    security:
    43      certsSecretPrefix: cert-prefix
    44      tls:
    45        ca: ca-issuer
    46    clusterSpecList:
    47      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    48        members: 3
    49      - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    50        members: 2
    51  backup:
    52    enabled: true
    53    s3Stores:
    54      - name: my-s3-block-store
    55        s3SecretRef:
    56          name: "s3-access-secret"
    57        pathStyleAccessEnabled: true
    58        s3BucketEndpoint: "${S3_ENDPOINT}"
    59        s3BucketName: "${S3_SNAPSHOT_BUCKET_NAME}"
    60        customCertificateSecretRefs:
    61          - name: s3-ca-cert
    62            key: ca.crt
    63    s3OpLogStores:
    64      - name: my-s3-oplog-store
    65        s3SecretRef:
    66          name: "s3-access-secret"
    67        s3BucketEndpoint: "${S3_ENDPOINT}"
    68        s3BucketName: "${S3_OPLOG_BUCKET_NAME}"
    69        pathStyleAccessEnabled: true
    70        customCertificateSecretRefs:
    71          - name: s3-ca-cert
    72            key: ca.crt
    73EOF

  2. Aguarde até que o operador Kubernetes termine sua configuração:

    1echo; echo "Waiting for Backup to reach Running phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.backup.phase}'=Running opsmanager/om --timeout=1200s
    3echo "Waiting for Application Database to reach Running phase..."
    4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=600s
    5echo; echo "Waiting for Ops Manager to reach Running phase..."
    6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=600s
    7echo; echo "MongoDBOpsManager resource"
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get opsmanager/om
    9echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    10kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    11echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    12kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    13echo; echo "Pods running in cluster ${K8S_CLUSTER_2_CONTEXT_NAME}"
    14kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${OM_NAMESPACE}" get pods
    1Waiting for Backup to reach Running phase...
    2mongodbopsmanager.mongodb.com/om condition met
    3Waiting for Application Database to reach Running phase...
    4mongodbopsmanager.mongodb.com/om condition met
    5
    6Waiting for Ops Manager to reach Running phase...
    7mongodbopsmanager.mongodb.com/om condition met
    8
    9MongoDBOpsManager resource
    10NAME   REPLICAS   VERSION   STATE (OPSMANAGER)   STATE (APPDB)   STATE (BACKUP)   AGE   WARNINGS
    11om                8.0.4     Running              Running         Running          24m   
    12
    13Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0-67d0389d75b70a0007e5894a
    14NAME        READY   STATUS    RESTARTS   AGE
    15om-0-0      2/2     Running   0          3m56s
    16om-db-0-0   4/4     Running   0          13m
    17om-db-0-1   4/4     Running   0          14m
    18om-db-0-2   4/4     Running   0          15m
    19
    20Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1-67d0389d75b70a0007e5894a
    21NAME        READY   STATUS    RESTARTS   AGE
    22om-1-0      2/2     Running   0          3m55s
    23om-db-1-0   4/4     Running   0          12m
    24om-db-1-1   4/4     Running   0          10m
    25
    26Pods running in cluster gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2-67d0389d75b70a0007e5894a
    27NAME                   READY   STATUS    RESTARTS   AGE
    28om-2-backup-daemon-0   2/2     Running   0          113s
5

Criar credenciais para o Operador Kubernetes.

Para configurar as credenciais, você deve criar uma organização do Ops Manager, gerar chaves de API programáticas na interface do usuário do Ops Manager e criar um segredo com o IP do Load Balancer. Consulte Criar Credenciais para o Operador Kubernetes para saber mais.

Nesta página