Implementar recursos de Ops Manager en varios clústeres de Kubernetes

Crea clústeres de Kubernetes.

Puedes omitir este paso si ya tienes instalados y configurados tus propios clústeres de Kubernetes con una malla de servicios.

1. Crea tres clústeres de GKE (Google Kubernetes Engine):

   1gcloud container clusters create "${K8S_CLUSTER_0}" \2      --zone="${K8S_CLUSTER_0_ZONE}" \3      --num-nodes="${K8S_CLUSTER_0_NUMBER_OF_NODES}" \4      --machine-type "${K8S_CLUSTER_0_MACHINE_TYPE}" \5      ${GKE_SPOT_INSTANCES_SWITCH:-""}

   1gcloud container clusters create "${K8S_CLUSTER_1}" \2      --zone="${K8S_CLUSTER_1_ZONE}" \3      --num-nodes="${K8S_CLUSTER_1_NUMBER_OF_NODES}" \4      --machine-type "${K8S_CLUSTER_1_MACHINE_TYPE}" \5      ${GKE_SPOT_INSTANCES_SWITCH:-""}

   1gcloud container clusters create "${K8S_CLUSTER_2}" \2      --zone="${K8S_CLUSTER_2_ZONE}" \3      --num-nodes="${K8S_CLUSTER_2_NUMBER_OF_NODES}" \4      --machine-type "${K8S_CLUSTER_2_MACHINE_TYPE}" \5      ${GKE_SPOT_INSTANCES_SWITCH:-""}

2. Establezca su proyecto gcloud por defecto:

   1gcloud config set project "${MDB_GKE_PROJECT}"

3. Obtén credenciales y guarda los contextos en el archivo kubeconfig actual. Por defecto, este archivo se encuentra en el directorio ~/.kube/config y es referenciado por el $KUBECONFIG variable de entorno.

   1gcloud container clusters get-credentials "${K8S_CLUSTER_0}" --zone="${K8S_CLUSTER_0_ZONE}"2gcloud container clusters get-credentials "${K8S_CLUSTER_1}" --zone="${K8S_CLUSTER_1_ZONE}"3gcloud container clusters get-credentials "${K8S_CLUSTER_2}" --zone="${K8S_CLUSTER_2_ZONE}"

   Todos los comandos de kubectl hacen referencia a estos contextos usando las siguientes variables:

   • $K8S_CLUSTER_0_CONTEXT_NAME

   • $K8S_CLUSTER_1_CONTEXT_NAME

   • $K8S_CLUSTER_2_CONTEXT_NAME

4. Verifica que kubectl tenga acceso a los clústeres de Kubernetes:

   1echo "Nodes in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" get nodes3echo; echo "Nodes in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"4kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" get nodes5echo; echo "Nodes in cluster ${K8S_CLUSTER_2_CONTEXT_NAME}"6kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" get nodes

   Ver resultado

5. Instale Istio la service mesh para permitir la resolución cruzada de DNS y la conectividad de red entre clústeres de Kubernetes:

   1CTX_CLUSTER1=${K8S_CLUSTER_0_CONTEXT_NAME} \2CTX_CLUSTER2=${K8S_CLUSTER_1_CONTEXT_NAME} \3CTX_CLUSTER3=${K8S_CLUSTER_2_CONTEXT_NAME} \4ISTIO_VERSION="1.20.2" \5../multi-cluster/install_istio_separate_network.sh

Crea namespace.

• Cree un namespace separado, mongodb-operator, referenciado por la $OPERATOR_NAMESPACE variable de entorno para la implementación del operador de Kubernetes.

• Cree el mismo $OPERATOR_NAMESPACE en cada clúster de nodo de Kubernetes. Esto es necesario para que el plugin kubectl MongoDB plugin pueda crear una cuenta de servicio para el operador de Kubernetes en cada clúster nodo. El Operador de Kubernetes utiliza estas cuentas de servicio en el clúster del operador para ejecutar operaciones en cada clúster nodo.

  1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" create namespace "${OPERATOR_NAMESPACE}"2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" label namespace "${OPERATOR_NAMESPACE}" istio-injection=enabled --overwrite3
  4kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" create namespace "${OPERATOR_NAMESPACE}"5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" label namespace "${OPERATOR_NAMESPACE}" istio-injection=enabled --overwrite6
  7kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" create namespace "${OPERATOR_NAMESPACE}"8kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" label namespace "${OPERATOR_NAMESPACE}" istio-injection=enabled --overwrite

• En cada clúster de nodo, incluido el clúster de nodo que sirve como clúster central, cree otro namespace independiente, mongodb. El operador de Kubernetes utiliza este namespace para los recursos y componentes de Ops Manager.

  1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" create namespace "${NAMESPACE}"2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" label namespace "${NAMESPACE}" istio-injection=enabled --overwrite3
  4kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" create namespace "${NAMESPACE}"5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" label namespace "${NAMESPACE}" istio-injection=enabled --overwrite6
  7kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" create namespace "${NAMESPACE}"8kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" label namespace "${NAMESPACE}" istio-injection=enabled --overwrite

opcional. Autorizar a los clústeres para extraer secretos de registros de imágenes privados.

Este paso es opcional si utilizas gráficas e imágenes oficiales de Helm provenientes del registro Quay.

1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" create secret generic "image-registries-secret" \2        --from-file=.dockerconfigjson="${HOME}/.docker/config.json" --type=kubernetes.io/dockerconfigjson3kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" create secret generic "image-registries-secret" \4        --from-file=.dockerconfigjson="${HOME}/.docker/config.json" --type=kubernetes.io/dockerconfigjson5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" create secret generic "image-registries-secret" \6        --from-file=.dockerconfigjson="${HOME}/.docker/config.json" --type=kubernetes.io/dockerconfigjson7kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" create secret generic "image-registries-secret" \8        --from-file=.dockerconfigjson="${HOME}/.docker/config.json" --type=kubernetes.io/dockerconfigjson

opcional. Verificar la conectividad del clúster.

Los siguientes scripts opcionales verifican si el service mesh está configurado correctamente para la resolución de DNS entre clústeres y la conectividad.

1. Ejecute este script en el clúster 0:

   1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2  apiVersion: apps/v13  kind: StatefulSet4  metadata:5    name: echoserver06  spec:7    replicas: 18    selector:9      matchLabels:10        app: echoserver011    template:12      metadata:13        labels:14          app: echoserver015      spec:16        containers:17          - image: k8s.gcr.io/echoserver:1.1018            imagePullPolicy: Always19            name: echoserver020            ports:21              - containerPort: 808022EOF

2. Ejecute este script en el clúster 1:

   1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2  apiVersion: apps/v13  kind: StatefulSet4  metadata:5    name: echoserver16  spec:7    replicas: 18    selector:9      matchLabels:10        app: echoserver111    template:12      metadata:13        labels:14          app: echoserver115      spec:16        containers:17          - image: k8s.gcr.io/echoserver:1.1018            imagePullPolicy: Always19            name: echoserver120            ports:21              - containerPort: 808022EOF

3. Ejecute este script en el clúster 2:

   1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2  apiVersion: apps/v13  kind: StatefulSet4  metadata:5    name: echoserver26  spec:7    replicas: 18    selector:9      matchLabels:10        app: echoserver211    template:12      metadata:13        labels:14          app: echoserver215      spec:16        containers:17          - image: k8s.gcr.io/echoserver:1.1018            imagePullPolicy: Always19            name: echoserver220            ports:21              - containerPort: 808022EOF

4. Ejecuta este script para esperar la creación de StatefulSets:

   1kubectl wait --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" --for=condition=ready pod -l statefulset.kubernetes.io/pod-name=echoserver0-0 --timeout=60s2kubectl wait --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" --for=condition=ready pod -l statefulset.kubernetes.io/pod-name=echoserver1-0 --timeout=60s3kubectl wait --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" --for=condition=ready pod -l statefulset.kubernetes.io/pod-name=echoserver2-0 --timeout=60s

5. Crea un servicio de Pods en el clúster 0:

   1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver0-06spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    statefulset.kubernetes.io/pod-name: "echoserver0-0"13EOF

6. Crea un servicio de Pods en el clúster 1:

   1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver1-06spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    statefulset.kubernetes.io/pod-name: "echoserver1-0"13EOF

7. Crea un servicio de Pods en el clúster 2:

   1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver2-06spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    statefulset.kubernetes.io/pod-name: "echoserver2-0"13EOF

8. Crear un servicio round robin en el clúster 0:

   1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver6spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    app: echoserver013EOF

9. Crear un servicio round robin en el clúster 1:

   1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver6spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    app: echoserver113EOF

10. Crear un servicio round robin en el clúster 2:

    1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: v13kind: Service4metadata:5  name: echoserver6spec:7  ports:8    - port: 80809      targetPort: 808010      protocol: TCP11  selector:12    app: echoserver213EOF

11. Verifica el Pod 0 del clúster 1:

    1source_cluster=${K8S_CLUSTER_1_CONTEXT_NAME}2target_pod="echoserver0-0"3source_pod="echoserver1-0"4target_url="http://${target_pod}.${NAMESPACE}.svc.cluster.local:8080"5echo "Checking cross-cluster DNS resolution and connectivity from ${source_pod} in ${source_cluster} to ${target_pod}"6out=$(kubectl exec --context "${source_cluster}" -n "${NAMESPACE}" "${source_pod}" -- \7  /bin/bash -c "curl -v ${target_url}" 2>&1);8grep "Hostname: ${target_pod}" &>/dev/null <<< "${out}" && echo "SUCCESS" || (echo "ERROR: ${out}" && return 1)

    Ver resultado

12. Verifica el Pod 1 del clúster 0:

    1source_cluster=${K8S_CLUSTER_0_CONTEXT_NAME}2target_pod="echoserver1-0"3source_pod="echoserver0-0"4target_url="http://${target_pod}.${NAMESPACE}.svc.cluster.local:8080"5echo "Checking cross-cluster DNS resolution and connectivity from ${source_pod} in ${source_cluster} to ${target_pod}"6out=$(kubectl exec --context "${source_cluster}" -n "${NAMESPACE}" "${source_pod}" -- \7  /bin/bash -c "curl -v ${target_url}" 2>&1);8grep "Hostname: ${target_pod}" &>/dev/null <<< "${out}" && echo "SUCCESS" || (echo "ERROR: ${out}" && return 1)

    Ver resultado

13. Verifica el Pod 1 del clúster 2:

    1source_cluster=${K8S_CLUSTER_2_CONTEXT_NAME}2target_pod="echoserver1-0"3source_pod="echoserver2-0"4target_url="http://${target_pod}.${NAMESPACE}.svc.cluster.local:8080"5echo "Checking cross-cluster DNS resolution and connectivity from ${source_pod} in ${source_cluster} to ${target_pod}"6out=$(kubectl exec --context "${source_cluster}" -n "${NAMESPACE}" "${source_pod}" -- \7  /bin/bash -c "curl -v ${target_url}" 2>&1);8grep "Hostname: ${target_pod}" &>/dev/null <<< "${out}" && echo "SUCCESS" || (echo "ERROR: ${out}" && return 1)

    Ver resultado

15. Verifica el Pod 2 del clúster 0:

    1source_cluster=${K8S_CLUSTER_0_CONTEXT_NAME}2target_pod="echoserver2-0"3source_pod="echoserver0-0"4target_url="http://${target_pod}.${NAMESPACE}.svc.cluster.local:8080"5echo "Checking cross-cluster DNS resolution and connectivity from ${source_pod} in ${source_cluster} to ${target_pod}"6out=$(kubectl exec --context "${source_cluster}" -n "${NAMESPACE}" "${source_pod}" -- \7  /bin/bash -c "curl -v ${target_url}" 2>&1);8grep "Hostname: ${target_pod}" &>/dev/null <<< "${out}" && echo "SUCCESS" || (echo "ERROR: ${out}" && return 1)

    Ver resultado

16. Ejecute el script de limpieza:

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver02kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver13kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver24kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver6kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver7kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver0-08kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver1-09kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver2-0

Implementa una configuración multiclúster.

En este paso, utilizas el plugin kubectl mongodb para automatizar la configuración del clúster de Kubernetes, que es necesaria para que el operador de Kubernetes gestione cargas de trabajo en varios clústeres de Kubernetes.

Debido a que configuras los clústeres de Kubernetes antes de instalar el operador de Kubernetes, cuando implementas el operador de Kubernetes para la operación de clústeres múltiples de Kubernetes, toda la configuración necesaria para multi-clúster ya está en su lugar.

Como se indica en la Introducción, el Operador Kubernetes tiene la configuración para tres clústeres nodos que puedes usar para implementar bases de datos de MongoDB en Ops Manager. El primer clúster también se utiliza como clúster central, donde se instala el operador de Kubernetes y se implementan los recursos personalizados.

1kubectl mongodb multicluster setup \2  --central-cluster="${K8S_CLUSTER_0_CONTEXT_NAME}" \3  --member-clusters="${K8S_CLUSTER_0_CONTEXT_NAME},${K8S_CLUSTER_1_CONTEXT_NAME},${K8S_CLUSTER_2_CONTEXT_NAME}" \4  --member-cluster-namespace="${NAMESPACE}" \5  --central-cluster-namespace="${OPERATOR_NAMESPACE}" \6  --create-service-account-secrets \7  --install-database-roles=true \8  --image-pull-secrets=image-registries-secret

1Ensured namespaces exist in all clusters.2creating operator cluster roles in cluster: gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-03creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-14creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-25Ensured ServiceAccounts and Roles.6Creating KubeConfig secret mongodb-operator/mongodb-enterprise-operator-multi-cluster-kubeconfig in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-07Ensured database Roles in member clusters.8Creating Member list Configmap mongodb-operator/mongodb-kubernetes-operator-member-list in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0

Instale el Kubernetes operador usando la chart de Helm.

1. Añade y actualiza el repositorio Helm de MongoDB. Verifica que la caché local de Helm haga referencia a la versión correcta del operador de Kubernetes:

   1helm repo add mongodb https://mongodb.github.io/helm-charts2helm repo update mongodb3helm search repo "${OFFICIAL_OPERATOR_HELM_CHART}"

   Ver resultado

2. Instale el Operador de Kubernetes en el $OPERATOR_NAMESPACE, configurado para supervisar $NAMESPACE y gestionar tres clústeres de Kubernetes nodos. En este punto del procedimiento, ServiceAccounts y roles ya están implementados por el kubectl mongodb plugin. Por lo tanto, los siguientes scripts omiten configurarlos y establecen operator.createOperatorServiceAccount=false y operator.createResourcesServiceAccountsAndRoles=false. Los scripts especifican la configuración multiCluster.clusters para indicar que la gráfica de Helm debe implementar el Operador de Kubernetes en modo multi-cluster.

   1helm upgrade --install \2  --debug \3  --kube-context "${K8S_CLUSTER_0_CONTEXT_NAME}" \4  mongodb-kubernetes-operator-multi-cluster \5  "${OPERATOR_HELM_CHART}" \6  --namespace="${OPERATOR_NAMESPACE}" \7  --set namespace="${OPERATOR_NAMESPACE}" \8  --set operator.namespace="${OPERATOR_NAMESPACE}" \9  --set operator.watchNamespace="${NAMESPACE}" \10  --set operator.name=mongodb-kubernetes-operator-multi-cluster \11  --set operator.createOperatorServiceAccount=false \12  --set operator.createResourcesServiceAccountsAndRoles=false \13  --set "multiCluster.clusters={${K8S_CLUSTER_0_CONTEXT_NAME},${K8S_CLUSTER_1_CONTEXT_NAME},${K8S_CLUSTER_2_CONTEXT_NAME}}" \14  --set "${OPERATOR_ADDITIONAL_HELM_VALUES:-"dummy=value"}"

   Ver resultado

3. Verifica la implementación de Kubernetes Operator:

   1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" rollout status deployment/mongodb-kubernetes-operator-multi-cluster2echo "Operator deployment in ${OPERATOR_NAMESPACE} namespace"3kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" get deployments4echo; echo "Operator pod in ${OPERATOR_NAMESPACE} namespace"5kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" get pods

   Ver resultado

Preparar los certificados TLS.

En este paso, habilita TLS para la base de datos de la aplicación y la aplicación MongoDB Ops Manager. Si no desea utilizar TLS, remueva los siguientes campos de los recursos MongoDBOpsManager:

• spec.security.certsSecretPrefix

• spec.security.tls.ca

• spec.applicationDatabase.security.certsSecretPrefix

• spec.applicationDatabase.security.tls.ca

1. opcional. Generar claves y certificados:

   Utiliza la herramienta de línea de comandos openssl para generar ACs y certificados autofirmados con fines de prueba.

   1mkdir certs || true2
   3cat <<EOF >certs/ca.cnf4[ req ]5default_bits       = 20486prompt             = no7default_md         = sha2568distinguished_name = dn9x509_extensions    = v3_ca10
   11[ dn ]12C=US13ST=New York14L=New York15O=Example Company16OU=IT Department17CN=exampleCA18
   19[ v3_ca ]20basicConstraints = CA:TRUE21keyUsage = critical, keyCertSign, cRLSign22subjectKeyIdentifier = hash23authorityKeyIdentifier = keyid:always,issuer24EOF25
   26cat <<EOF >certs/om.cnf27[ req ]28default_bits       = 204829prompt             = no30default_md         = sha25631distinguished_name = dn32req_extensions     = req_ext33
   34[ dn ]35C=US36ST=New York37L=New York38O=Example Company39OU=IT Department40CN=${OPS_MANAGER_EXTERNAL_DOMAIN}41
   42[ req_ext ]43subjectAltName = @alt_names44keyUsage = critical, digitalSignature, keyEncipherment45extendedKeyUsage = serverAuth, clientAuth46
   47[ alt_names ]48DNS.1 = ${OPS_MANAGER_EXTERNAL_DOMAIN}49DNS.2 = om-svc.${NAMESPACE}.svc.cluster.local50EOF51
   52cat <<EOF >certs/appdb.cnf53[ req ]54default_bits       = 204855prompt             = no56default_md         = sha25657distinguished_name = dn58req_extensions     = req_ext59
   60[ dn ]61C=US62ST=New York63L=New York64O=Example Company65OU=IT Department66CN=AppDB67
   68[ req_ext ]69subjectAltName = @alt_names70keyUsage = critical, digitalSignature, keyEncipherment71extendedKeyUsage = serverAuth, clientAuth72
   73[ alt_names ]74# multi-cluster mongod hostnames from service for each pod75DNS.1 = *.${NAMESPACE}.svc.cluster.local76# single-cluster mongod hostnames from headless service77DNS.2 = *.om-db-svc.${NAMESPACE}.svc.cluster.local78EOF79
   80# generate CA keypair and certificate81openssl genrsa -out certs/ca.key 204882openssl req -x509 -new -nodes -key certs/ca.key -days 1024 -out certs/ca.crt -config certs/ca.cnf83
   84# generate OpsManager's keypair and certificate85openssl genrsa -out certs/om.key 204886openssl req -new -key certs/om.key -out certs/om.csr -config certs/om.cnf87
   88# generate AppDB's keypair and certificate89openssl genrsa -out certs/appdb.key 204890openssl req -new -key certs/appdb.key -out certs/appdb.csr -config certs/appdb.cnf91
   92# generate certificates signed by CA for OpsManager and AppDB93openssl x509 -req -in certs/om.csr -CA certs/ca.crt -CAkey certs/ca.key -CAcreateserial -out certs/om.crt -days 365 -sha256 -extfile certs/om.cnf -extensions req_ext94openssl x509 -req -in certs/appdb.csr -CA certs/ca.crt -CAkey certs/ca.key -CAcreateserial -out certs/appdb.crt -days 365 -sha256 -extfile certs/appdb.cnf -extensions req_ext

2. Crea secretos con claves TLS:

   Si prefieres usar tus propias claves y certificados, omite el paso anterior de generación y coloca las claves y certificados en los siguientes archivos:

   • certs/ca.crt - Certificados CA. estos no son necesarios al utilizar certificados de confianza.

   • certs/appdb.key - llave privada para la base de datos de la aplicación.

   • certs/appdb.crt - Certificado para la base de datos de la aplicación.

   • certs/om.key - clave privada para Ops Manager.

   • certs/om.crt - certificado para Ops Manager.

   1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" create secret tls cert-prefix-om-cert \2  --cert=certs/om.crt \3  --key=certs/om.key4
   5kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" create secret tls cert-prefix-om-db-cert \6  --cert=certs/appdb.crt \7  --key=certs/appdb.key8
   9kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" create configmap om-cert-ca --from-file="mms-ca.crt=certs/ca.crt"10kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" create configmap appdb-cert-ca --from-file="ca-pem=certs/ca.crt"

Instale Ops Manager.

En este punto, se ha preparado el entorno y el operador de Kubernetes para implementar el recurso Ops Manager.

1. Crea las credenciales necesarias para el usuario administrador de Ops Manager que creará el operador de Kubernetes después de implementar la instancia de Ops Manager aplicación:

   1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" --namespace "${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 el recurso personalizado más simple de MongoDBOpsManager posible (con TLS activado) en un clúster de un solo nodo, que también se conoce como el clúster central.

   Esta implementación es casi igual que para el modo de un solo clúster, pero con spec.topology y spec.applicationDatabase.topology configurados en MultiCluster.

   Implementar de esta manera muestra que la implementación de un solo clúster de Kubernetes es un caso especial de implementación de clústeres multi-Kubernetes en un solo clúster nodo de Kubernetes. Puedes iniciar la implementación de la aplicación de Ops Manager y la base de datos de la aplicación en tantos clústeres de Kubernetes como sea necesario desde el principio, y no es necesario que comiences la implementación con un único clúster nodo de Kubernetes.

   En este punto, ya deberías haber preparado la implementación de Ops Manager para expandirse a más de un clúster de Kubernetes, lo cual harás más adelante en este procedimiento.

   1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: mongodb.com/v13kind: MongoDBOpsManager4metadata:5  name: om6spec:7  topology: MultiCluster8  version: "${OPS_MANAGER_VERSION}"9  adminCredentials: om-admin-user-credentials10  security:11    certsSecretPrefix: cert-prefix12    tls:13      ca: om-cert-ca14  clusterSpecList:15    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"16      members: 117  applicationDatabase:18    version: "${APPDB_VERSION}"19    topology: MultiCluster20    security:21      certsSecretPrefix: cert-prefix22      tls:23        ca: appdb-cert-ca24    clusterSpecList:25      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"26        members: 327  backup:28    enabled: false29EOF

3. Espera a que el operador de Kubernetes recoja el trabajo y alcance el estado status.applicationDatabase.phase=Pending. Espera a que se completen tanto la base de datos de la aplicación como las implementaciones de Ops Manager.

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

   Ver resultado

4. Implementa Ops Manager. El Operador de Kubernetes implementa Ops Manager realizando los siguientes pasos. It:

   • Implementa los nodos del set de réplicas de la Base de datos de la aplicación y espera que los procesos de MongoDB en el set de réplicas comiencen a ejecutarse.

   • Implementa la instancia de la aplicación Ops Manager con la cadena de conexión de la base de datos de la aplicación y espera que esté lista.

   • Agrega los contenedores de supervisión de MongoDB Agent a cada pod de la base de datos de la aplicación.

   • Espera que tanto la aplicación Ops Manager como los pods de la base de datos de la aplicación comiencen a ejecutarse.

   1echo "Waiting for Application Database to reach Running phase..."2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s3echo; echo "Waiting for Ops Manager to reach Running phase..."4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=900s5echo; echo "Waiting for Application Database to reach Pending phase (enabling monitoring)..."6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s7echo "Waiting for Application Database to reach Running phase..."8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=900s9echo; echo "Waiting for Ops Manager to reach Running phase..."10kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=900s11echo; echo "MongoDBOpsManager resource"12kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get opsmanager/om13echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"14kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get pods15echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"16kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" get pods

   Ver resultado

   Ahora que ha desplegado un clúster de un solo nodo en un modo multiclúster, puede volver a configurar esta implementación para abarcar más de un clúster de Kubernetes.

5. En el segundo clúster de miembros, implemente dos miembros adicionales del set de réplicas de la base de datos de la aplicación y una instancia adicional de la aplicación de Ops Manager:

   1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF2apiVersion: mongodb.com/v13kind: MongoDBOpsManager4metadata:5  name: om6spec:7  topology: MultiCluster8  version: "${OPS_MANAGER_VERSION}"9  adminCredentials: om-admin-user-credentials10  security:11    certsSecretPrefix: cert-prefix12    tls:13      ca: om-cert-ca14  clusterSpecList:15    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"16      members: 117    - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"18      members: 119  applicationDatabase:20    version: "${APPDB_VERSION}"21    topology: MultiCluster22    security:23      certsSecretPrefix: cert-prefix24      tls:25        ca: appdb-cert-ca26    clusterSpecList:27      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"28        members: 329      - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"30        members: 231  backup:32    enabled: false33EOF

6. Espera a que el Operador de Kubernetes recoja el trabajo (fase pendiente):

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

   Ver resultado

7. Espera a que Kubernetes operador termine de implementar todos los componentes:

   1echo "Waiting for Application Database to reach Running phase..."2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.applicationDatabase.phase}'=Running opsmanager/om --timeout=600s3echo; echo "Waiting for Ops Manager to reach Running phase..."4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=600s5echo; echo "MongoDBOpsManager resource"6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get opsmanager/om7echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get pods9echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"10kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" get pods

   Ver resultado