Docs Menu
Docs Home
/
MongoDB Enterprise Kubernetes 演算子
/
MongoDB Ops ManagerMongoDB Ops Manager

複数のMongoDB Ops Manager Kubernetesクラスターでの リソースの配置

項目一覧

  • Overview
  • 前提条件
  • 手順

マルチクラスターMongoDB Ops Managerとアプリケーション データベースの配置を、データセンター全体またはゾーン全体の障害に対して回復性のあるものにするには、 MongoDB Ops Managerアプリケーションとアプリケーション データベースを複数のKubernetesクラスターに配置します。

MongoDB Ops Managerリソースのマルチ Kubernetes クラスター配置のアーキテクチャ、ネットワーク、制限、パフォーマンスの詳細については、以下を参照してください。

Overview

このセクションの手順を使用してMongoDB Ops Managerアプリケーションとアプリケーション データベースを配置する場合は、次の操作を行います。

  1. Kubernetes クラスターのマルチ配置のデモンストレーションに役立つツールとして、 GKE（Google Kubernetes Engine） と Istio サービス キャッシュを使用します。

  2. Kubernetes Operator を、 演算子クラスターと呼ばれるノード Kubernetes クラスターの 1 つにインストールします。 演算子クラスターは、複数の Kubernetes クラスターでの配置を管理するために Kubernetes Operator が使用する「Hub and Spark」パターンのハブとして機能します。

  3. $OPERATOR_NAMESPACEに演算子クラスターを配置し、このクラスターを$NAMESPACEで監視し、すべてのノード Kubernetes クラスターを管理するように構成します。

  4. アプリケーションデータベースとMongoDB Ops Managerアプリケーションを単一ノードのKubernetesクラスターに配置して、マルチクラスター配置と単一クラスター配置の類似性を示します。 spec.topologyとspec.applicationDatabase.topologyがMultiClusterに設定されている単一クラスターの配置は、さらに Kubernetes クラスターを追加するための配置を準備します。

  5. アプリケーション データベースの回復力を改善するために、追加のアプリケーション データベース レプリカセットを 2 つ目のメンバー Kubernetes クラスターに配置します。 また、2MongoDB Ops Manager Kubernetes番目のノードである クラスターに追加の アプリケーション インスタンスを配置します。

  6. TLS 暗号化の有効な証明書を作成し、 アプリケーションとの間、およびアプリケーション MongoDB Ops Managerデータベースのレプリカセット ノード間で TLS 暗号化された接続を確立します。HTTPS 経由で実行する場合、 MongoDB Ops Managerはデフォルトでポート 8443 で実行されます。

  7. S 3互換ストレージを使用してバックアップを有効にし、3 つ目のメンバー Kubernetes クラスターにバックアップデーモン を配置します。 S3 互換ストレージ バケットの設定を簡素化するには、 MinIO 演算子 を 。バックアップデーモンは、配置内の 1 つのノード クラスターでのみ有効にします。 ただし、バックアップデーモン リソースをホストするように他のノード クラスターも構成できます。 のマルチクラスター配置では S3 バックアップのみがサポートされています。MongoDB Ops Manager

前提条件

ツールのインストール

配置を開始する前に、次の必要なツールをインストールしてください。

gcloud CLI への認可

gcloud CLI のインストール が、その条件に認可されます。

gcloud auth login

プラグインをインストールkubectl mongodb

kubetl MongoDBプラグインは、 Kubernetesクラスターの構成を自動化します。 これにより、 Kubernetes Operator は、これらのクラスター上のMongoDB Ops Managerアプリケーション、アプリケーションデータベース、およびMongoDBリソースのリソース、必要なロール、サービスを配置できます。

kubectl mongodbプラグインをインストールするには次の手順に従います。

1

ご希望の Kubernetes Operator パッケージ バージョンをダウンロードします。

リポジトリのリリースMongoDBEnterprise Kubernetes Operator ページKubernetes から、ご希望の Operator パッケージ バージョンをダウンロードします。

パッケージの名前には次のパターンが使用されます: kubectl-mongodb_{{ .Version }}_{{ .Os }}_{{ .Arch }}.tar.gz 。

次のいずれかのパッケージを使用します。

  • kubectl-mongodb_{{ .Version }}_darwin_amd64.tar.gz

  • kubectl-mongodb_{{ .Version }}_darwin_arm64.tar.gz

  • kubectl-mongodb_{{ .Version }}_linux_amd64.tar.gz

  • kubectl-mongodb_{{ .Version }}_linux_arm64.tar.gz

2

Kubernetes Operator パッケージを解凍します。

次の例のように、 パッケージを解凍します。

tar -zxvf kubectl-mongodb_<version>_darwin_amd64.tar.gz
3

kubectl mongodbプラグインバイナリを見つけて、目的の宛先にコピーします。

解凍された ディレクトリでkubectl-mongodbバイナリを見つけ、次の例に示すように、Kubernetes Operator ユーザーの PATH 内にある目的の宛先に移動します。

mv kubectl-mongodb /usr/local/bin/kubectl-mongodb

これで、次のコマンドを使用してkubectl mongodbプラグインを実行できるようになります。

kubectl mongodb multicluster setup
kubectl mongodb multicluster recover

サポートされているフラグの詳細については、 MongoDB kubernetes プラグイン リファレンス を参照してください。

MongoDB Enterprise Kubernetes Operatorリポジトリのクローン

MongoDB Enterprise Kubernetes Operator リポジトリ のクローン作成 mongodb-enterprise-kubernetes、 ディレクトリに変更し、現在のバージョンを確認します。

git clone https://github.com/mongodb/mongodb-enterprise-kubernetes.git
cd mongodb-enterprise-kubernetes
git checkout 1.26
cd public/samples/ops-manager-multi-cluster

重要

このガイドの一部の手順は、 public/samples/ops-manager-multi-clusterディレクトリから実行した場合にのみ機能します。

環境変数を設定する

このガイドのすべての手順は、 env_variables.shで定義された環境変数を参照します。

1export MDB_GKE_PROJECT="### Set your GKE project name here ###"
2
3export NAMESPACE="mongodb"
4export OPERATOR_NAMESPACE="mongodb-operator"
5
6# comma-separated key=value pairs
7# export OPERATOR_ADDITIONAL_HELM_VALUES=""
8
9# Adjust the values for each Kubernetes cluster in your deployment.
10# The deployment script references the following variables to get values for each cluster.
11export K8S_CLUSTER_0="k8s-mdb-0"
12export K8S_CLUSTER_0_ZONE="europe-central2-a"
13export K8S_CLUSTER_0_NUMBER_OF_NODES=3
14export K8S_CLUSTER_0_MACHINE_TYPE="e2-standard-4"
15export K8S_CLUSTER_0_CONTEXT_NAME="gke_${MDB_GKE_PROJECT}_${K8S_CLUSTER_0_ZONE}_${K8S_CLUSTER_0}"
16
17export K8S_CLUSTER_1="k8s-mdb-1"
18export K8S_CLUSTER_1_ZONE="europe-central2-b"
19export K8S_CLUSTER_1_NUMBER_OF_NODES=3
20export K8S_CLUSTER_1_MACHINE_TYPE="e2-standard-4"
21export K8S_CLUSTER_1_CONTEXT_NAME="gke_${MDB_GKE_PROJECT}_${K8S_CLUSTER_1_ZONE}_${K8S_CLUSTER_1}"
22
23export K8S_CLUSTER_2="k8s-mdb-2"
24export K8S_CLUSTER_2_ZONE="europe-central2-c"
25export K8S_CLUSTER_2_NUMBER_OF_NODES=1
26export K8S_CLUSTER_2_MACHINE_TYPE="e2-standard-4"
27export K8S_CLUSTER_2_CONTEXT_NAME="gke_${MDB_GKE_PROJECT}_${K8S_CLUSTER_2_ZONE}_${K8S_CLUSTER_2}"
28
29# Comment out the following line so that the script does not create preemptible nodes.
30# DO NOT USE preemptible nodes in production.
31export GKE_SPOT_INSTANCES_SWITCH="--preemptible"
32
33export S3_OPLOG_BUCKET_NAME=s3-oplog-store
34export S3_SNAPSHOT_BUCKET_NAME=s3-snapshot-store
35
36# minio defaults
37export S3_ENDPOINT="minio.tenant-tiny.svc.cluster.local"
38export S3_ACCESS_KEY="console"
39export S3_SECRET_KEY="console123"
40
41export OPERATOR_HELM_CHART="mongodb/enterprise-operator"
42
43# (Optional) Change the following setting when using the external URL.
44# This env variable is used in OpenSSL configuration to generate
45# server certificates for Ops Manager Application.
46export OPS_MANAGER_EXTERNAL_DOMAIN="om-svc.${NAMESPACE}.svc.cluster.local"
47
48export OPS_MANAGER_VERSION="7.0.4"
49export APPDB_VERSION="7.0.9-ubi8"

コメントで指示されているように、前の例の設定をニーズに合わせて調整し、次のように shell に入力します。

source env_variables.sh

重要

env_variables.shを更新するたびに、 source env_variables.shを実行して、このセクションのスクリプトが更新された変数を使用することを確認します。

手順

この手順は、複数のMongoDB Ops Manager Kubernetesクラスターに インスタンスを配置する場合に適用されます。

1

Kubernetes クラスターを作成します。

サービス メトリクスを使用して独自の Kubernetes クラスターをすでにインストールして構成している場合は、この手順を省略できます。

  1. 3 つの 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. 認証情報を取得し、コンテキストを現在のkubeconfigファイルに保存します。 デフォルトでは、このファイルは~/.kube/configディレクトリにあり、 $KUBECONFIG環境変数によって参照されます。

    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}"

    すべてのkubectlコマンドは、次の変数を使用してこれらのコンテキストを参照します。

    • $K8S_CLUSTER_0_CONTEXT_NAME

    • $K8S_CLUSTER_1_CONTEXT_NAME

    • $K8S_CLUSTER_2_CONTEXT_NAME

  3. kubectlが Kubernetes クラスターにアクセスできることを確認します。

    1echo "Nodes in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" get nodes
    3echo; echo "Nodes in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    4kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" get nodes
    5echo; echo "Nodes in cluster ${K8S_CLUSTER_2_CONTEXT_NAME}"
    6kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" get nodes
    1Nodes in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    2NAME                                       STATUS   ROLES    AGE   VERSION
    3gke-k8s-mdb-0-default-pool-d0f98a43-dtlc   Ready    <none>   65s   v1.28.7-gke.1026000
    4gke-k8s-mdb-0-default-pool-d0f98a43-q9sf   Ready    <none>   65s   v1.28.7-gke.1026000
    5gke-k8s-mdb-0-default-pool-d0f98a43-zn8x   Ready    <none>   64s   v1.28.7-gke.1026000
    6
    7Nodes in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    8NAME                                       STATUS   ROLES    AGE    VERSION
    9gke-k8s-mdb-1-default-pool-37ea602a-0qgw   Ready    <none>   111s   v1.28.7-gke.1026000
    10gke-k8s-mdb-1-default-pool-37ea602a-k4qk   Ready    <none>   114s   v1.28.7-gke.1026000
    11gke-k8s-mdb-1-default-pool-37ea602a-p2g7   Ready    <none>   113s   v1.28.7-gke.1026000
    12
    13Nodes in cluster gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
    14NAME                                       STATUS   ROLES    AGE   VERSION
    15gke-k8s-mdb-2-default-pool-4b459a09-t1v9   Ready    <none>   29s   v1.28.7-gke.1026000

  4. Istio の インストール サービス メトリクスを使用して、クラスター間の DNS 解決と 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
2

名前空間 を作成します。

注意

サイドカーインジェクション を有効にするには Istio では、次のコマンドを使用して、各ノードクラスターのistio-injection=enabled $OPERATOR_NAMESPACEとmongodb 名前空間に ラベルが追加されます。別のサービス キャッシュを使用する場合は、作成された名前空間内のネットワーク トラフィックを処理するように構成します。

  • Kubernetes Operator 配置用の$OPERATOR_NAMESPACE環境変数で参照される別の名前空間mongodb-operatorを作成します。

  • 各ノードの Kubernetes クラスターに同じ$OPERATOR_NAMESPACEを作成します。 これは、 kubernetl MongoDBプラグインが各ノード クラスターでKubernetes Operator のサービス アカウントを作成するために必要です。 Kubernetes Operator は、オペレーター クラスターでこれらのサービス アカウントを使用して、各ノード クラスターで操作を実行します。

    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 --overwrite
    3
    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 --overwrite
    6
    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

  • 演算子クラスターとして機能するノードクラスターを含む各ノードクラスターに、別の個別の名前空間、 mongodbを作成します。 Kubernetes Operator は、 MongoDB 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 --overwrite
    3
    4kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" create namespace "${NAMESPACE}"
    5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" label namespace "${NAMESPACE}" istio-injection=enabled --overwrite
    6
    7kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" create namespace "${NAMESPACE}"
    8kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" label namespace "${NAMESPACE}" istio-injection=enabled --overwrite
3

任意。 クラスターにプライベート イメージ レジストリからシークレットをプルする権限を与えます。

この手順は、次のコマンドから公式の Helm チャートとイメージを使用する場合は任意です: レジストリ。

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/dockerconfigjson
3kubectl --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/dockerconfigjson
5kubectl --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/dockerconfigjson
7kubectl --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
4

任意。 クラスターの接続を確認します。

次のオプションのスクリプトは、サービス メトリクスがクロスクラスター DNS の解決と接続を正しく構成されているかどうかを確認します。

  1. 次のスクリプトをクラスター0で実行します。

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2  apiVersion: apps/v1
    3  kind: StatefulSet
    4  metadata:
    5    name: echoserver0
    6  spec:
    7    replicas: 1
    8    selector:
    9      matchLabels:
    10        app: echoserver0
    11    template:
    12      metadata:
    13        labels:
    14          app: echoserver0
    15      spec:
    16        containers:
    17          - image: k8s.gcr.io/echoserver:1.10
    18            imagePullPolicy: Always
    19            name: echoserver0
    20            ports:
    21              - containerPort: 8080
    22EOF

  2. 次のスクリプトをクラスター1で実行します。

    1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2  apiVersion: apps/v1
    3  kind: StatefulSet
    4  metadata:
    5    name: echoserver1
    6  spec:
    7    replicas: 1
    8    selector:
    9      matchLabels:
    10        app: echoserver1
    11    template:
    12      metadata:
    13        labels:
    14          app: echoserver1
    15      spec:
    16        containers:
    17          - image: k8s.gcr.io/echoserver:1.10
    18            imagePullPolicy: Always
    19            name: echoserver1
    20            ports:
    21              - containerPort: 8080
    22EOF

  3. 次のスクリプトをクラスター2で実行します。

    1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2  apiVersion: apps/v1
    3  kind: StatefulSet
    4  metadata:
    5    name: echoserver2
    6  spec:
    7    replicas: 1
    8    selector:
    9      matchLabels:
    10        app: echoserver2
    11    template:
    12      metadata:
    13        labels:
    14          app: echoserver2
    15      spec:
    16        containers:
    17          - image: k8s.gcr.io/echoserver:1.10
    18            imagePullPolicy: Always
    19            name: echoserver2
    20            ports:
    21              - containerPort: 8080
    22EOF

  4. Atlas の作成を待つには、次のスクリプトを実行します。

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

  5. クラスター0に ポッド サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver0-0
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    statefulset.kubernetes.io/pod-name: "echoserver0-0"
    13EOF

  6. クラスター1に ポッド サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver1-0
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    statefulset.kubernetes.io/pod-name: "echoserver1-0"
    13EOF

  7. クラスター2に ポッド サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver2-0
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    statefulset.kubernetes.io/pod-name: "echoserver2-0"
    13EOF

  8. クラスター0にラウンド ロギング サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    app: echoserver0
    13EOF

  9. クラスター1にラウンド ロギング サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    app: echoserver1
    13EOF

  10. クラスター2にラウンド ロギング サービスを作成します。

    1kubectl apply --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" -f - <<EOF
    2apiVersion: v1
    3kind: Service
    4metadata:
    5  name: echoserver
    6spec:
    7  ports:
    8    - port: 8080
    9      targetPort: 8080
    10      protocol: TCP
    11  selector:
    12    app: echoserver2
    13EOF

  11. クラスター1から ポッド0を確認します。

    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)
    1Checking cross-cluster DNS resolution and connectivity from echoserver1-0 in gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1 to echoserver0-0
    2SUCCESS

  12. クラスター0から ポッド1を確認します。

    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)
    1Checking cross-cluster DNS resolution and connectivity from echoserver0-0 in gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0 to echoserver1-0
    2SUCCESS

  13. クラスター2から ポッド1を確認します。

    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)
    1Checking cross-cluster DNS resolution and connectivity from echoserver2-0 in gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2 to echoserver1-0
    2SUCCESS

  1. クラスター0から ポッド2を確認します。

    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)
    1Checking cross-cluster DNS resolution and connectivity from echoserver0-0 in gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0 to echoserver2-0
    2SUCCESS

  2. クリーンアップ スクリプトを実行します。

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver0
    2kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver1
    3kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete statefulset echoserver2
    4kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver
    5kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver
    6kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver
    7kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver0-0
    8kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver1-0
    9kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${NAMESPACE}" delete service echoserver2-0
5

マルチクラスター構成を配置します。

このステップでは、 kubectl mongodbプラグインを使用して、Kubernetes Operator が複数の Kubernetes クラスターのワークロードを管理するために必要な Kubernetes クラスター構成を自動化します。

Kubernetes Operator をインストールする前に Kubernetes クラスターを構成するため、マルチ Kubernetes クラスター操作に Kubernetes Operator を配置すると、必要なマルチクラスター構成はすべてすでに配置されています。

概要に記載されているように、 Kubernetes Operator には、 MongoDB Ops Manager MongoDBデータベースの配置に使用できる 3 つのノード クラスターの構成があります。 最初のクラスターは演算子クラスターとしても使用され、Kubernetes Operator をインストールし、カスタム リソースを配置します。

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
1Build: 1f23ae48c41d208f14c860356e483ba386a3aab8, 2024-04-26T12:19:36Z
2Ensured namespaces exist in all clusters.
3creating central cluster roles in cluster: gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
4creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
5creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
6Ensured ServiceAccounts and Roles.
7Creating KubeConfig secret mongodb-operator/mongodb-enterprise-operator-multi-cluster-kubeconfig in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
8Ensured database Roles in member clusters.
9Creating Member list Configmap mongodb-operator/mongodb-enterprise-operator-member-list in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
6

Helm チャートを使用して Kubernetes Operator をインストールします。

  1. Kubernetes Operator を$OPERATOR_NAMESPACEにインストールします。このクエリは、 $NAMESPACEを監視し、3 つのノードからなる Kubernetes クラスターを管理するように構成されています。 手順のこの時点で、 ServiceAccounts と のkubectl mongodb ロール は、 プラグインによってすでに配置されています。そのため、次のスクリプトでは構成をスキップし、 operator.createOperatorServiceAccount=falseとoperator.createResourcesServiceAccountsAndRoles=falseを設定します。 スクリプトはmultiCluster.clusters設定を指定して、Kubernetes Operator をマルチクラスター モードで配置するよう Helm チャートに指示します。

    1helm upgrade --install \
    2  --debug \
    3  --kube-context "${K8S_CLUSTER_0_CONTEXT_NAME}" \
    4  mongodb-enterprise-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-enterprise-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"}"
    1Release "mongodb-enterprise-operator-multi-cluster" does not exist. Installing it now.
    2NAME: mongodb-enterprise-operator-multi-cluster
    3LAST DEPLOYED: Tue Apr 30 19:40:26 2024
    4NAMESPACE: mongodb-operator
    5STATUS: deployed
    6REVISION: 1
    7TEST SUITE: None
    8USER-SUPPLIED VALUES:
    9dummy: value
    10multiCluster:
    11  clusters:
    12  - gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    13  - gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    14  - gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
    15namespace: mongodb-operator
    16operator:
    17  createOperatorServiceAccount: false
    18  createResourcesServiceAccountsAndRoles: false
    19  name: mongodb-enterprise-operator-multi-cluster
    20  namespace: mongodb-operator
    21  watchNamespace: mongodb
    22
    23COMPUTED VALUES:
    24agent:
    25  name: mongodb-agent-ubi
    26  version: 107.0.0.8502-1
    27database:
    28  name: mongodb-enterprise-database-ubi
    29  version: 1.25.0
    30dummy: value
    31initAppDb:
    32  name: mongodb-enterprise-init-appdb-ubi
    33  version: 1.25.0
    34initDatabase:
    35  name: mongodb-enterprise-init-database-ubi
    36  version: 1.25.0
    37initOpsManager:
    38  name: mongodb-enterprise-init-ops-manager-ubi
    39  version: 1.25.0
    40managedSecurityContext: false
    41mongodb:
    42  appdbAssumeOldFormat: false
    43  imageType: ubi8
    44  name: mongodb-enterprise-server
    45  repo: quay.io/mongodb
    46mongodbLegacyAppDb:
    47  name: mongodb-enterprise-appdb-database-ubi
    48  repo: quay.io/mongodb
    49multiCluster:
    50  clusterClientTimeout: 10
    51  clusters:
    52  - gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    53  - gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    54  - gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
    55  kubeConfigSecretName: mongodb-enterprise-operator-multi-cluster-kubeconfig
    56  performFailOver: true
    57namespace: mongodb-operator
    58operator:
    59  additionalArguments: []
    60  affinity: {}
    61  createOperatorServiceAccount: false
    62  createResourcesServiceAccountsAndRoles: false
    63  deployment_name: mongodb-enterprise-operator
    64  env: prod
    65  mdbDefaultArchitecture: non-static
    66  name: mongodb-enterprise-operator-multi-cluster
    67  namespace: mongodb-operator
    68  nodeSelector: {}
    69  operator_image_name: mongodb-enterprise-operator-ubi
    70  replicas: 1
    71  resources:
    72    limits:
    73      cpu: 1100m
    74      memory: 1Gi
    75    requests:
    76      cpu: 500m
    77      memory: 200Mi
    78  tolerations: []
    79  vaultSecretBackend:
    80    enabled: false
    81    tlsSecretRef: ""
    82  version: 1.25.0
    83  watchNamespace: mongodb
    84  watchedResources:
    85  - mongodb
    86  - opsmanagers
    87  - mongodbusers
    88  webhook:
    89    registerConfiguration: true
    90opsManager:
    91  name: mongodb-enterprise-ops-manager-ubi
    92registry:
    93  agent: quay.io/mongodb
    94  appDb: quay.io/mongodb
    95  database: quay.io/mongodb
    96  imagePullSecrets: null
    97  initAppDb: quay.io/mongodb
    98  initDatabase: quay.io/mongodb
    99  initOpsManager: quay.io/mongodb
    100  operator: quay.io/mongodb
    101  opsManager: quay.io/mongodb
    102  pullPolicy: Always
    103subresourceEnabled: true
    104
    105HOOKS:
    106MANIFEST:
    107---
    108# Source: enterprise-operator/templates/operator-roles.yaml
    109kind: ClusterRole
    110apiVersion: rbac.authorization.k8s.io/v1
    111metadata:
    112  name: mongodb-enterprise-operator-mongodb-webhook
    113rules:
    114  - apiGroups:
    115      - "admissionregistration.k8s.io"
    116    resources:
    117      - validatingwebhookconfigurations
    118    verbs:
    119      - get
    120      - create
    121      - update
    122      - delete
    123  - apiGroups:
    124      - ""
    125    resources:
    126      - services
    127    verbs:
    128      - get
    129      - list
    130      - watch
    131      - create
    132      - update
    133      - delete
    134---
    135# Source: enterprise-operator/templates/operator-roles.yaml
    136kind: ClusterRoleBinding
    137apiVersion: rbac.authorization.k8s.io/v1
    138metadata:
    139  name: mongodb-enterprise-operator-multi-cluster-mongodb-operator-webhook-binding
    140roleRef:
    141  apiGroup: rbac.authorization.k8s.io
    142  kind: ClusterRole
    143  name: mongodb-enterprise-operator-mongodb-webhook
    144subjects:
    145  - kind: ServiceAccount
    146    name: mongodb-enterprise-operator-multi-cluster
    147    namespace: mongodb-operator
    148---
    149# Source: enterprise-operator/templates/operator.yaml
    150apiVersion: apps/v1
    151kind: Deployment
    152metadata:
    153  name: mongodb-enterprise-operator-multi-cluster
    154  namespace: mongodb-operator
    155spec:
    156  replicas: 1
    157  selector:
    158    matchLabels:
    159      app.kubernetes.io/component: controller
    160      app.kubernetes.io/name: mongodb-enterprise-operator-multi-cluster
    161      app.kubernetes.io/instance: mongodb-enterprise-operator-multi-cluster
    162  template:
    163    metadata:
    164      labels:
    165        app.kubernetes.io/component: controller
    166        app.kubernetes.io/name: mongodb-enterprise-operator-multi-cluster
    167        app.kubernetes.io/instance: mongodb-enterprise-operator-multi-cluster
    168    spec:
    169      serviceAccountName: mongodb-enterprise-operator-multi-cluster
    170      securityContext:
    171        runAsNonRoot: true
    172        runAsUser: 2000
    173      containers:
    174        - name: mongodb-enterprise-operator-multi-cluster
    175          image: "quay.io/mongodb/mongodb-enterprise-operator-ubi:1.25.0"
    176          imagePullPolicy: Always
    177          args:
    178            - -watch-resource=mongodb
    179            - -watch-resource=opsmanagers
    180            - -watch-resource=mongodbusers
    181            - -watch-resource=mongodbmulticluster
    182          command:
    183            - /usr/local/bin/mongodb-enterprise-operator
    184          volumeMounts:
    185            - mountPath: /etc/config/kubeconfig
    186              name: kube-config-volume
    187          resources:
    188            limits:
    189              cpu: 1100m
    190              memory: 1Gi
    191            requests:
    192              cpu: 500m
    193              memory: 200Mi
    194          env:
    195            - name: OPERATOR_ENV
    196              value: prod
    197            - name: MDB_DEFAULT_ARCHITECTURE
    198              value: non-static
    199            - name: WATCH_NAMESPACE
    200              value: "mongodb"
    201            - name: NAMESPACE
    202              valueFrom:
    203                fieldRef:
    204                  fieldPath: metadata.namespace
    205            - name: CLUSTER_CLIENT_TIMEOUT
    206              value: "10"
    207            - name: IMAGE_PULL_POLICY
    208              value: Always
    209            # Database
    210            - name: MONGODB_ENTERPRISE_DATABASE_IMAGE
    211              value: quay.io/mongodb/mongodb-enterprise-database-ubi
    212            - name: INIT_DATABASE_IMAGE_REPOSITORY
    213              value: quay.io/mongodb/mongodb-enterprise-init-database-ubi
    214            - name: INIT_DATABASE_VERSION
    215              value: 1.25.0
    216            - name: DATABASE_VERSION
    217              value: 1.25.0
    218            # Ops Manager
    219            - name: OPS_MANAGER_IMAGE_REPOSITORY
    220              value: quay.io/mongodb/mongodb-enterprise-ops-manager-ubi
    221            - name: INIT_OPS_MANAGER_IMAGE_REPOSITORY
    222              value: quay.io/mongodb/mongodb-enterprise-init-ops-manager-ubi
    223            - name: INIT_OPS_MANAGER_VERSION
    224              value: 1.25.0
    225            # AppDB
    226            - name: INIT_APPDB_IMAGE_REPOSITORY
    227              value: quay.io/mongodb/mongodb-enterprise-init-appdb-ubi
    228            - name: INIT_APPDB_VERSION
    229              value: 1.25.0
    230            - name: OPS_MANAGER_IMAGE_PULL_POLICY
    231              value: Always
    232            - name: AGENT_IMAGE
    233              value: "quay.io/mongodb/mongodb-agent-ubi:107.0.0.8502-1"
    234            - name: MDB_AGENT_IMAGE_REPOSITORY
    235              value: "quay.io/mongodb/mongodb-agent-ubi"
    236            - name: MONGODB_IMAGE
    237              value: mongodb-enterprise-server
    238            - name: MONGODB_REPO_URL
    239              value: quay.io/mongodb
    240            - name: MDB_IMAGE_TYPE
    241              value: ubi8
    242            - name: PERFORM_FAILOVER
    243              value: 'true'
    244      volumes:
    245        - name: kube-config-volume
    246          secret:
    247            defaultMode: 420
    248            secretName: mongodb-enterprise-operator-multi-cluster-kubeconfig

  2. Kubernetes Operator の配置を確認します。

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" rollout status deployment/mongodb-enterprise-operator-multi-cluster
    2echo "Operator deployment in ${OPERATOR_NAMESPACE} namespace"
    3kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" get deployments
    4echo; echo "Operator pod in ${OPERATOR_NAMESPACE} namespace"
    5kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${OPERATOR_NAMESPACE}" get pods
    1Waiting for deployment "mongodb-enterprise-operator-multi-cluster" rollout to finish: 0 of 1 updated replicas are available...
    2deployment "mongodb-enterprise-operator-multi-cluster" successfully rolled out
    3Operator deployment in mongodb-operator namespace
    4NAME                                        READY   UP-TO-DATE   AVAILABLE   AGE
    5mongodb-enterprise-operator-multi-cluster   1/1     1            1           12s
    6
    7Operator pod in mongodb-operator namespace
    8NAME                                                         READY   STATUS    RESTARTS     AGE
    9mongodb-enterprise-operator-multi-cluster-78cc97547d-nlgds   2/2     Running   1 (3s ago)   12s
7

TLS 証明書を準備します。

この手順では、アプリケーション データベースと アプリケーションに対して TLSMongoDB Ops Manager を有効にします。TLS を使用しない場合は、 MongoDBOpsManagerリソースから次のフィールドを削除します。

  1. 任意。 キーと証明書を生成します。

    opensslコマンドライン ツールを使用して、テスト目的の自己署名 CA と証明書を生成します。

    1mkdir certs || true
    2
    3cat <<EOF >certs/ca.cnf
    4[ req ]
    5default_bits       = 2048
    6prompt             = no
    7default_md         = sha256
    8distinguished_name = dn
    9
    10[ dn ]
    11C=US
    12ST=New York
    13L=New York
    14O=Example Company
    15OU=IT Department
    16CN=exampleCA
    17EOF
    18
    19cat <<EOF >certs/om.cnf
    20[ req ]
    21default_bits       = 2048
    22prompt             = no
    23default_md         = sha256
    24distinguished_name = dn
    25req_extensions     = req_ext
    26
    27[ dn ]
    28C=US
    29ST=New York
    30L=New York
    31O=Example Company
    32OU=IT Department
    33CN=${OPS_MANAGER_EXTERNAL_DOMAIN}
    34
    35[ req_ext ]
    36subjectAltName = @alt_names
    37keyUsage = critical, digitalSignature, keyEncipherment
    38extendedKeyUsage = serverAuth, clientAuth
    39
    40[ alt_names ]
    41DNS.1 = ${OPS_MANAGER_EXTERNAL_DOMAIN}
    42DNS.2 = om-svc.${NAMESPACE}.svc.cluster.local
    43EOF
    44
    45cat <<EOF >certs/appdb.cnf
    46[ req ]
    47default_bits       = 2048
    48prompt             = no
    49default_md         = sha256
    50distinguished_name = dn
    51req_extensions     = req_ext
    52
    53[ dn ]
    54C=US
    55ST=New York
    56L=New York
    57O=Example Company
    58OU=IT Department
    59CN=AppDB
    60
    61[ req_ext ]
    62subjectAltName = @alt_names
    63keyUsage = critical, digitalSignature, keyEncipherment
    64extendedKeyUsage = serverAuth, clientAuth
    65
    66[ alt_names ]
    67# multi-cluster mongod hostnames from service for each pod
    68DNS.1 = *.${NAMESPACE}.svc.cluster.local
    69# single-cluster mongod hostnames from headless service
    70DNS.2 = *.om-db-svc.${NAMESPACE}.svc.cluster.local
    71EOF
    72
    73# generate CA keypair and certificate
    74openssl genrsa -out certs/ca.key 2048
    75openssl req -x509 -new -nodes -key certs/ca.key -days 1024 -out certs/ca.crt -config certs/ca.cnf
    76
    77# generate OpsManager's keypair and certificate
    78openssl genrsa -out certs/om.key 2048
    79openssl req -new -key certs/om.key -out certs/om.csr -config certs/om.cnf
    80
    81# generate AppDB's keypair and certificate
    82openssl genrsa -out certs/appdb.key 2048
    83openssl req -new -key certs/appdb.key -out certs/appdb.csr -config certs/appdb.cnf
    84
    85# generate certificates signed by CA for OpsManager and AppDB
    86openssl 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_ext
    87openssl 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. TLS キーを使用してシークレットを作成する

    独自のキーと証明書を使用する場合は、前の生成ステップをスキップし、キーと証明書を次のファイルに配置します。

    • certs/ca.crt - CA証明書。 信頼できる証明書を使用する場合は、これらは必要ありません。

    • certs/appdb.key - アプリケーション データベースの秘密キー。

    • certs/appdb.crt アプリケーション データベースの - 証明書。

    • certs/om.key - MongoDB Ops Manager の秘密キー。

    • certs/om.crt MongoDB 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.key
    4
    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.key
    8
    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"
8

MongoDB Ops Managerをインストールします。

この時点で、 リソースを配置するための環境とKubernetes OperatorMongoDB Ops Manager を準備しました。

  1. MongoDB Ops Manager管理ユーザーに必要な認証情報を作成します。この認証情報はKubernetes MongoDB Ops Managerアプリケーション インスタンスの配置後に作成されます。

    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. 可能な場合は最も単純なMongoDBOpsManagerカスタム リソース（ TLSが有効）を単一ノード クラスターに配置します。これは演算子クラスターとも呼ばれます。

    この配置は単一クラスター モードとほぼ同じですが、 spec.topologyとspec.applicationDatabase.topologyがMultiClusterに設定されています。

    この方法で配置すると、単一の Kubernetes クラスターの配置が、単一の Kubernetes ノード クラスターへの複数の Kubernetes クラスター配置の特殊なケースであることがわかります。 MongoDB Ops Managerアプリケーションとアプリケーション データベースは、最初から必要な数のKubernetesクラスターに最初から配置を開始できますKubernetesクラスターが 1 つだけの配置で開始する必要はありません。

    この時点で、複数のMongoDB Ops Manager Kubernetesクラスターにまたがるように の配置を準備しました。これはこの手順の後半で行います。

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${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  security:
    11    certsSecretPrefix: cert-prefix
    12    tls:
    13      ca: om-cert-ca
    14  clusterSpecList:
    15    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    16      members: 1
    17  applicationDatabase:
    18    version: "${APPDB_VERSION}"
    19    topology: MultiCluster
    20    security:
    21      certsSecretPrefix: cert-prefix
    22      tls:
    23        ca: appdb-cert-ca
    24    clusterSpecList:
    25      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    26        members: 3
    27  backup:
    28    enabled: false
    29EOF

  3. Kubernetes Operator が作業を選択し、 status.applicationDatabase.phase=Pending状態に達するまで待ちます。 アプリケーション データベースとMongoDB 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
    1Waiting for Application Database to reach Pending phase...
    2mongodbopsmanager.mongodb.com/om condition met

  4. MongoDB Ops Managerを配置します。 Kubernetes Operator は、次の手順を実行してMongoDB Ops Managerを配置します。 以下の条件に一致するもの。

    • アプリケーション データベースのレプリカセット ノードを配置し、レプリカセット内の MongoDB プロセスが実行を開始するのを待ちます。

    • アプリケーションMongoDB Ops Manager データベースの接続 を使用して アプリケーションstring インスタンスを配置し、それが準備されるのを待ちます。

    • 監視 MongoDB Agent コンテナを各アプリケーション データベースの ポッドに追加します。

    • MongoDB Ops Managerアプリケーションとアプリケーション データベース ポッドの両方が実行を開始するのを待ちます。

    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=900s
    3echo; 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=900s
    5echo; 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=900s
    7echo "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=900s
    9echo; 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=900s
    11echo; echo "MongoDBOpsManager resource"
    12kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get opsmanager/om
    13echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    14kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get pods
    15echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    16kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${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                7.0.4     Running              Running         Disabled         11m   
    18
    19Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    20NAME        READY   STATUS    RESTARTS   AGE
    21om-0-0      2/2     Running   0          8m39s
    22om-db-0-0   4/4     Running   0          44s
    23om-db-0-1   4/4     Running   0          2m6s
    24om-db-0-2   4/4     Running   0          3m19s
    25
    26Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1

    単一ノード クラスターをマルチクラスター モードで配置したので、この配置を複数の Kubernetes クラスターにまたがるように再構成できます。

  5. 2 番目のノード クラスターで、2 つの追加のアプリケーション データベース レプリカセット ノードと 1 つの MongoDB Ops Manager アプリケーションの追加のインスタンスを配置します。

    1kubectl apply --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${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  security:
    11    certsSecretPrefix: cert-prefix
    12    tls:
    13      ca: om-cert-ca
    14  clusterSpecList:
    15    - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    16      members: 1
    17    - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    18      members: 1
    19  applicationDatabase:
    20    version: "${APPDB_VERSION}"
    21    topology: MultiCluster
    22    security:
    23      certsSecretPrefix: cert-prefix
    24      tls:
    25        ca: appdb-cert-ca
    26    clusterSpecList:
    27      - clusterName: "${K8S_CLUSTER_0_CONTEXT_NAME}"
    28        members: 3
    29      - clusterName: "${K8S_CLUSTER_1_CONTEXT_NAME}"
    30        members: 2
    31  backup:
    32    enabled: false
    33EOF

  6. Kubernetes Operator が作業を選択するまで待ちます（保留中フェーズ）。

    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
    1Waiting for Application Database to reach Pending phase...
    2mongodbopsmanager.mongodb.com/om condition met

  7. Kubernetes Operator がすべてのコンポーネントの配置を完了するまで待ちます。

    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=600s
    3echo; 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=600s
    5echo; echo "MongoDBOpsManager resource"
    6kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get opsmanager/om
    7echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get pods
    9echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    10kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${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                7.0.4     Pending              Running         Disabled         14m   
    10
    11Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    12NAME        READY   STATUS        RESTARTS   AGE
    13om-0-0      2/2     Terminating   0          12m
    14om-db-0-0   4/4     Running       0          4m12s
    15om-db-0-1   4/4     Running       0          5m34s
    16om-db-0-2   4/4     Running       0          6m47s
    17
    18Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    19NAME        READY   STATUS     RESTARTS   AGE
    20om-1-0      0/2     Init:0/2   0          0s
    21om-db-1-0   4/4     Running    0          3m24s
    22om-db-1-1   4/4     Running    0          104s
9

バックアップを有効にします。

MongoDB Ops Managerアプリケーションのマルチ Kubernetes クラスター配置では、 S3ベースのバックアップ ストレージのみを構成できます。 この手順では、 env_variables.shで定義されているS3_*を参照します。

  1. 任意。 MinIO 演算子 をインストールする 。

    この手順では、 最小値演算子 を使用してバックアップ用の S3 互換ストレージを配置します。 。Amazon Web Services S3またはその他のS3互換バケットが使用可能な場合は、この手順をスキップできます。 この場合は、 env_variables.shで必要に応じてS3_*変数を調整します。

    1kustomize build "github.com/minio/operator/resources/?timeout=120&ref=v5.0.12" | \
    2  kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" apply -f -
    3
    4kustomize build "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}\"}]}]"

  2. バックアップを構成して有効にする前に、 シークレット を作成します。

    • s3-access-secret - にはS 3認証情報が含まれています。

    • s3-ca-cert - バケットのサーバー証明書を発行したCA証明書が含まれています。 この手順で使用されているサンプル MongoDB Ops 配置の場合、デフォルトの Kubernetes ルートCA証明書が証明書の署名に使用されます。 パブリックに信頼されているCA証明書ではないため、 MongoDB Ops Managerが接続を信頼できるようにするために、これを提供する必要があります。

    一般に信頼されている証明書を使用している場合は、この手順をスキップして、 spec.backup.s3Stores.customCertificateSecretRefsとspec.backup.s3OpLogStores.customCertificateSecretRefsの設定から値を削除できます。

    1kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${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 "${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}")"
10

バックアップが有効になっているMongoDB Ops Managerを再配置します。

  1. Kubernetes Operator は、すべてのコンポーネント、 MongoDB Ops Managerアプリケーション、バックアップデーモン インスタンス、およびアプリケーションデータベースのレプリカセット ノードを、 Kubernetes Operator を構成する任意のノードクラスター上の任意の組み合わせで構成して配置できます。

    マルチ Kubernetes クラスターの配置構成の柔軟性を示すには、3 番目のノード クラスターに 1 つのバックアップデーモン インスタンスのみを配置し、1 番目と 2 番目のクラスターに対して 0 個のバックアップデーモン ノードを指定します。

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

  2. Kubernetes Operator が構成を完了するまで待ちます。

    1echo; echo "Waiting for Backup to reach Running phase..."
    2kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${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 "${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 "${NAMESPACE}" wait --for=jsonpath='{.status.opsManager.phase}'=Running opsmanager/om --timeout=600s
    7echo; echo "MongoDBOpsManager resource"
    8kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get opsmanager/om
    9echo; echo "Pods running in cluster ${K8S_CLUSTER_0_CONTEXT_NAME}"
    10kubectl --context "${K8S_CLUSTER_0_CONTEXT_NAME}" -n "${NAMESPACE}" get pods
    11echo; echo "Pods running in cluster ${K8S_CLUSTER_1_CONTEXT_NAME}"
    12kubectl --context "${K8S_CLUSTER_1_CONTEXT_NAME}" -n "${NAMESPACE}" get pods
    13echo; echo "Pods running in cluster ${K8S_CLUSTER_2_CONTEXT_NAME}"
    14kubectl --context "${K8S_CLUSTER_2_CONTEXT_NAME}" -n "${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                7.0.4     Running              Running         Running          22m   
    12
    13Pods running in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
    14NAME        READY   STATUS    RESTARTS   AGE
    15om-0-0      2/2     Running   0          7m10s
    16om-db-0-0   4/4     Running   0          11m
    17om-db-0-1   4/4     Running   0          13m
    18om-db-0-2   4/4     Running   0          14m
    19
    20Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    21NAME        READY   STATUS    RESTARTS   AGE
    22om-1-0      2/2     Running   0          4m8s
    23om-db-1-0   4/4     Running   0          11m
    24om-db-1-1   4/4     Running   0          9m25s
    25
    26Pods running in cluster gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
    27NAME                   READY   STATUS    RESTARTS   AGE
    28om-2-backup-daemon-0   2/2     Running   0          2m5s
11

任意。 GKE（Google Kubernetes Engine）クラスターとそれに関連するすべてのリソース（VM）を削除します。

次のスクリプトを実行して、GKE クラスターを削除し、環境をクリーンアップします。

重要

次のコマンドは、元に戻すことができません。 env_variables.shで参照されているすべてのクラスターを削除します。 この手順の一部として GKE クラスターを作成しなかった場合など、GKE クラスターを保持する場合は、これらのコマンドを実行しないでください。

1yes | gcloud container clusters delete "${K8S_CLUSTER_0}" --zone="${K8S_CLUSTER_0_ZONE}" &
2yes | gcloud container clusters delete "${K8S_CLUSTER_1}" --zone="${K8S_CLUSTER_1_ZONE}" &
3yes | gcloud container clusters delete "${K8S_CLUSTER_2}" --zone="${K8S_CLUSTER_2_ZONE}" &
4wait