Docs Menu
Docs Home
/
MongoDB Enterprise Kubernetes 演算子
/

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

項目一覧

  • Overview
  • 前提条件
  • 手順

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

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

このセクションの手順を使用して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.topologyspec.applicationDatabase.topologyMultiClusterに設定されている単一クラスターの配置は、さらに 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 auth login

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

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

1

リポジトリのリリース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

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

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

解凍された ディレクトリで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、 ディレクトリに変更し、現在のバージョンを確認します。

git clone https://github.com/mongodb/mongodb-enterprise-kubernetes.git
cd mongodb-enterprise-kubernetes
git checkout master
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 OFFICIAL_OPERATOR_HELM_CHART="mongodb/enterprise-operator"
42export OPERATOR_HELM_CHART="${OFFICIAL_OPERATOR_HELM_CHART}"
43
44# (Optional) Change the following setting when using the external URL.
45# This env variable is used in OpenSSL configuration to generate
46# server certificates for Ops Manager Application.
47export OPS_MANAGER_EXTERNAL_DOMAIN="om-svc.${NAMESPACE}.svc.cluster.local"
48
49export OPS_MANAGER_VERSION="7.0.4"
50export APPDB_VERSION="7.0.9-ubi8"

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

source env_variables.sh

重要

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

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

1

サービス メトリクスを使用して独自の 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. デフォルトの gcloud プロジェクトを設定します。

    1gcloud config set project "${MDB_GKE_PROJECT}"
  3. 認証情報を取得し、コンテキストを現在の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

  4. 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-267f1e8f-d0dg Ready <none> 38m v1.29.7-gke.1104000
    4gke-k8s-mdb-0-default-pool-267f1e8f-pmgh Ready <none> 38m v1.29.7-gke.1104000
    5gke-k8s-mdb-0-default-pool-267f1e8f-vgj9 Ready <none> 38m v1.29.7-gke.1104000
    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-263d341f-3tbp Ready <none> 38m v1.29.7-gke.1104000
    10gke-k8s-mdb-1-default-pool-263d341f-4f26 Ready <none> 38m v1.29.7-gke.1104000
    11gke-k8s-mdb-1-default-pool-263d341f-z751 Ready <none> 38m v1.29.7-gke.1104000
    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-d0da5fd1-chm1 Ready <none> 38m v1.29.7-gke.1104000
  5. 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_NAMESPACEmongodb 名前空間に ラベルが追加されます。別のサービス キャッシュを使用する場合は、作成された名前空間内のネットワーク トラフィックを処理するように構成します。

  • 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
1Ensured namespaces exist in all clusters.
2creating central cluster roles in cluster: gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
3creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
4creating member roles in cluster: gke_scratch-kubernetes-team_europe-central2-c_k8s-mdb-2
5Ensured 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-0
7Ensured database Roles in member clusters.
8Creating Member list Configmap mongodb-operator/mongodb-enterprise-operator-member-list in cluster gke_scratch-kubernetes-team_europe-central2-a_k8s-mdb-0
6
  1. MongoDB Helm リポジトリを追加および更新します。 ローカル Helm キャッシュが正しい Kubernetes Operator バージョンを参照していることを確認します。

    1helm repo add mongodb https://mongodb.github.io/helm-charts
    2helm repo update mongodb
    3helm search repo "${OFFICIAL_OPERATOR_HELM_CHART}"
    1"mongodb" already exists with the same configuration, skipping
    2Hang tight while we grab the latest from your chart repositories...
    3...Successfully got an update from the "mongodb" chart repository
    4Update Complete. ⎈Happy Helming!⎈
    5NAME CHART VERSION APP VERSION DESCRIPTION
    6mongodb/enterprise-operator 1.27.0 MongoDB Kubernetes Enterprise Operator
  2. Kubernetes Operator を$OPERATOR_NAMESPACEにインストールします。このクエリは、 $NAMESPACEを監視し、3 つのノードからなる Kubernetes クラスターを管理するように構成されています。 手順のこの時点で、 ServiceAccounts kubectl mongodb ロール は、 プラグインによってすでに配置されています。そのため、次のスクリプトでは構成をスキップし、 operator.createOperatorServiceAccount=falseoperator.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: Mon Aug 26 10:55:49 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.27.0
    30dummy: value
    31initAppDb:
    32 name: mongodb-enterprise-init-appdb-ubi
    33 version: 1.27.0
    34initDatabase:
    35 name: mongodb-enterprise-init-database-ubi
    36 version: 1.27.0
    37initOpsManager:
    38 name: mongodb-enterprise-init-ops-manager-ubi
    39 version: 1.27.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 maxConcurrentReconciles: 1
    66 mdbDefaultArchitecture: non-static
    67 name: mongodb-enterprise-operator-multi-cluster
    68 namespace: mongodb-operator
    69 nodeSelector: {}
    70 operator_image_name: mongodb-enterprise-operator-ubi
    71 replicas: 1
    72 resources:
    73 limits:
    74 cpu: 1100m
    75 memory: 1Gi
    76 requests:
    77 cpu: 500m
    78 memory: 200Mi
    79 tolerations: []
    80 vaultSecretBackend:
    81 enabled: false
    82 tlsSecretRef: ""
    83 version: 1.27.0
    84 watchNamespace: mongodb
    85 watchedResources:
    86 - mongodb
    87 - opsmanagers
    88 - mongodbusers
    89 webhook:
    90 installClusterRole: true
    91 registerConfiguration: true
    92opsManager:
    93 name: mongodb-enterprise-ops-manager-ubi
    94registry:
    95 agent: quay.io/mongodb
    96 appDb: quay.io/mongodb
    97 database: quay.io/mongodb
    98 imagePullSecrets: null
    99 initAppDb: quay.io/mongodb
    100 initDatabase: quay.io/mongodb
    101 initOpsManager: quay.io/mongodb
    102 operator: quay.io/mongodb
    103 opsManager: quay.io/mongodb
    104 pullPolicy: Always
    105subresourceEnabled: true
    106
    107HOOKS:
    108MANIFEST:
    109---
    110# Source: enterprise-operator/templates/operator-roles.yaml
    111kind: ClusterRole
    112apiVersion: rbac.authorization.k8s.io/v1
    113metadata:
    114 name: mongodb-enterprise-operator-mongodb-webhook
    115rules:
    116 - apiGroups:
    117 - "admissionregistration.k8s.io"
    118 resources:
    119 - validatingwebhookconfigurations
    120 verbs:
    121 - get
    122 - create
    123 - update
    124 - delete
    125 - apiGroups:
    126 - ""
    127 resources:
    128 - services
    129 verbs:
    130 - get
    131 - list
    132 - watch
    133 - create
    134 - update
    135 - delete
    136---
    137# Source: enterprise-operator/templates/operator-roles.yaml
    138kind: ClusterRoleBinding
    139apiVersion: rbac.authorization.k8s.io/v1
    140metadata:
    141 name: mongodb-enterprise-operator-multi-cluster-mongodb-operator-webhook-binding
    142roleRef:
    143 apiGroup: rbac.authorization.k8s.io
    144 kind: ClusterRole
    145 name: mongodb-enterprise-operator-mongodb-webhook
    146subjects:
    147 - kind: ServiceAccount
    148 name: mongodb-enterprise-operator-multi-cluster
    149 namespace: mongodb-operator
    150---
    151# Source: enterprise-operator/templates/operator.yaml
    152apiVersion: apps/v1
    153kind: Deployment
    154metadata:
    155 name: mongodb-enterprise-operator-multi-cluster
    156 namespace: mongodb-operator
    157spec:
    158 replicas: 1
    159 selector:
    160 matchLabels:
    161 app.kubernetes.io/component: controller
    162 app.kubernetes.io/name: mongodb-enterprise-operator-multi-cluster
    163 app.kubernetes.io/instance: mongodb-enterprise-operator-multi-cluster
    164 template:
    165 metadata:
    166 labels:
    167 app.kubernetes.io/component: controller
    168 app.kubernetes.io/name: mongodb-enterprise-operator-multi-cluster
    169 app.kubernetes.io/instance: mongodb-enterprise-operator-multi-cluster
    170 spec:
    171 serviceAccountName: mongodb-enterprise-operator-multi-cluster
    172 securityContext:
    173 runAsNonRoot: true
    174 runAsUser: 2000
    175 containers:
    176 - name: mongodb-enterprise-operator-multi-cluster
    177 image: "quay.io/mongodb/mongodb-enterprise-operator-ubi:1.27.0"
    178 imagePullPolicy: Always
    179 args:
    180 - -watch-resource=mongodb
    181 - -watch-resource=opsmanagers
    182 - -watch-resource=mongodbusers
    183 - -watch-resource=mongodbmulticluster
    184 command:
    185 - /usr/local/bin/mongodb-enterprise-operator
    186 volumeMounts:
    187 - mountPath: /etc/config/kubeconfig
    188 name: kube-config-volume
    189 resources:
    190 limits:
    191 cpu: 1100m
    192 memory: 1Gi
    193 requests:
    194 cpu: 500m
    195 memory: 200Mi
    196 env:
    197 - name: OPERATOR_ENV
    198 value: prod
    199 - name: MDB_DEFAULT_ARCHITECTURE
    200 value: non-static
    201 - name: WATCH_NAMESPACE
    202 value: "mongodb"
    203 - name: NAMESPACE
    204 valueFrom:
    205 fieldRef:
    206 fieldPath: metadata.namespace
    207 - name: CLUSTER_CLIENT_TIMEOUT
    208 value: "10"
    209 - name: IMAGE_PULL_POLICY
    210 value: Always
    211 # Database
    212 - name: MONGODB_ENTERPRISE_DATABASE_IMAGE
    213 value: quay.io/mongodb/mongodb-enterprise-database-ubi
    214 - name: INIT_DATABASE_IMAGE_REPOSITORY
    215 value: quay.io/mongodb/mongodb-enterprise-init-database-ubi
    216 - name: INIT_DATABASE_VERSION
    217 value: 1.27.0
    218 - name: DATABASE_VERSION
    219 value: 1.27.0
    220 # Ops Manager
    221 - name: OPS_MANAGER_IMAGE_REPOSITORY
    222 value: quay.io/mongodb/mongodb-enterprise-ops-manager-ubi
    223 - name: INIT_OPS_MANAGER_IMAGE_REPOSITORY
    224 value: quay.io/mongodb/mongodb-enterprise-init-ops-manager-ubi
    225 - name: INIT_OPS_MANAGER_VERSION
    226 value: 1.27.0
    227 # AppDB
    228 - name: INIT_APPDB_IMAGE_REPOSITORY
    229 value: quay.io/mongodb/mongodb-enterprise-init-appdb-ubi
    230 - name: INIT_APPDB_VERSION
    231 value: 1.27.0
    232 - name: OPS_MANAGER_IMAGE_PULL_POLICY
    233 value: Always
    234 - name: AGENT_IMAGE
    235 value: "quay.io/mongodb/mongodb-agent-ubi:107.0.0.8502-1"
    236 - name: MDB_AGENT_IMAGE_REPOSITORY
    237 value: "quay.io/mongodb/mongodb-agent-ubi"
    238 - name: MONGODB_IMAGE
    239 value: mongodb-enterprise-server
    240 - name: MONGODB_REPO_URL
    241 value: quay.io/mongodb
    242 - name: MDB_IMAGE_TYPE
    243 value: ubi8
    244 - name: PERFORM_FAILOVER
    245 value: 'true'
    246 - name: MDB_MAX_CONCURRENT_RECONCILES
    247 value: "1"
    248 volumes:
    249 - name: kube-config-volume
    250 secret:
    251 defaultMode: 420
    252 secretName: mongodb-enterprise-operator-multi-cluster-kubeconfig
  3. 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 10s
    6
    7Operator pod in mongodb-operator namespace
    8NAME READY STATUS RESTARTS AGE
    9mongodb-enterprise-operator-multi-cluster-54d786b796-7l5ct 2/2 Running 1 (4s ago) 10s
7

この手順では、アプリケーション データベースと アプリケーションに対して 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
    9x509_extensions = v3_ca
    10
    11[ dn ]
    12C=US
    13ST=New York
    14L=New York
    15O=Example Company
    16OU=IT Department
    17CN=exampleCA
    18
    19[ v3_ca ]
    20basicConstraints = CA:TRUE
    21keyUsage = critical, keyCertSign, cRLSign
    22subjectKeyIdentifier = hash
    23authorityKeyIdentifier = keyid:always,issuer
    24EOF
    25
    26cat <<EOF >certs/om.cnf
    27[ req ]
    28default_bits = 2048
    29prompt = no
    30default_md = sha256
    31distinguished_name = dn
    32req_extensions = req_ext
    33
    34[ dn ]
    35C=US
    36ST=New York
    37L=New York
    38O=Example Company
    39OU=IT Department
    40CN=${OPS_MANAGER_EXTERNAL_DOMAIN}
    41
    42[ req_ext ]
    43subjectAltName = @alt_names
    44keyUsage = critical, digitalSignature, keyEncipherment
    45extendedKeyUsage = serverAuth, clientAuth
    46
    47[ alt_names ]
    48DNS.1 = ${OPS_MANAGER_EXTERNAL_DOMAIN}
    49DNS.2 = om-svc.${NAMESPACE}.svc.cluster.local
    50EOF
    51
    52cat <<EOF >certs/appdb.cnf
    53[ req ]
    54default_bits = 2048
    55prompt = no
    56default_md = sha256
    57distinguished_name = dn
    58req_extensions = req_ext
    59
    60[ dn ]
    61C=US
    62ST=New York
    63L=New York
    64O=Example Company
    65OU=IT Department
    66CN=AppDB
    67
    68[ req_ext ]
    69subjectAltName = @alt_names
    70keyUsage = critical, digitalSignature, keyEncipherment
    71extendedKeyUsage = serverAuth, clientAuth
    72
    73[ alt_names ]
    74# multi-cluster mongod hostnames from service for each pod
    75DNS.1 = *.${NAMESPACE}.svc.cluster.local
    76# single-cluster mongod hostnames from headless service
    77DNS.2 = *.om-db-svc.${NAMESPACE}.svc.cluster.local
    78EOF
    79
    80# generate CA keypair and certificate
    81openssl genrsa -out certs/ca.key 2048
    82openssl req -x509 -new -nodes -key certs/ca.key -days 1024 -out certs/ca.crt -config certs/ca.cnf
    83
    84# generate OpsManager's keypair and certificate
    85openssl genrsa -out certs/om.key 2048
    86openssl req -new -key certs/om.key -out certs/om.csr -config certs/om.cnf
    87
    88# generate AppDB's keypair and certificate
    89openssl genrsa -out certs/appdb.key 2048
    90openssl req -new -key certs/appdb.key -out certs/appdb.csr -config certs/appdb.cnf
    91
    92# generate certificates signed by CA for OpsManager and AppDB
    93openssl 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
    94openssl 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

この時点で、 リソースを配置するための環境と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.topologyspec.applicationDatabase.topologyMultiClusterに設定されています。

    この方法で配置すると、単一の 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 13m
    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 10m
    22om-db-0-0 4/4 Running 0 69s
    23om-db-0-1 4/4 Running 0 2m12s
    24om-db-0-2 4/4 Running 0 3m32s
    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 Running Running Disabled 20m
    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 Running 0 2m56s
    14om-db-0-0 4/4 Running 0 7m48s
    15om-db-0-1 4/4 Running 0 8m51s
    16om-db-0-2 4/4 Running 0 10m
    17
    18Pods running in cluster gke_scratch-kubernetes-team_europe-central2-b_k8s-mdb-1
    19NAME READY STATUS RESTARTS AGE
    20om-1-0 2/2 Running 0 3m27s
    21om-db-1-0 4/4 Running 0 6m32s
    22om-db-1-1 4/4 Running 0 5m5s
9

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

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

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

    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}\"}]}]"
  2. バックアップを構成して有効にする前に、 シークレット を作成します。

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

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

    一般に信頼されている証明書を使用している場合は、この手順をスキップして、 spec.backup.s3Stores.customCertificateSecretRefsspec.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
  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 26m
    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 5m11s
    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 16m
    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 5m12s
    23om-db-1-0 4/4 Running 0 12m
    24om-db-1-1 4/4 Running 0 11m
    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 3m8s
11

次のスクリプトを実行して、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