Mengonfigurasi dan menyebarkan kluster MongoDB di Azure Kubernetes Service (AKS)

Dalam artikel ini, Anda mengonfigurasi dan menyebarkan kluster MongoDB di Azure Kubernetes Service (AKS).

Mengonfigurasi identitas tugas

  1. Buat namespace untuk kluster MongoDB menggunakan perintah .

    kubectl create namespace ${AKS_MONGODB_NAMESPACE} --dry-run=client --output yaml | kubectl apply -f -

    Contoh output:

    namespace/mongodb created

  2. Buat akun layanan dan konfigurasikan identitas beban kerja menggunakan kubectl apply perintah .

    export TENANT_ID=$(az account show --query tenantId -o tsv)
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: ServiceAccount
metadata:
  annotations:
    azure.workload.identity/client-id: "${MY_IDENTITY_NAME_CLIENT_ID}"
    azure.workload.identity/tenant-id: "${TENANT_ID}"
  name: "${SERVICE_ACCOUNT_NAME}"
  namespace: "${AKS_MONGODB_NAMESPACE}"
EOF

    Contoh output:

    serviceaccount/mongodb created

Menginstal Operator Rahasia Eksternal

Di bagian ini, Anda akan menggunakan Helm untuk memasang External Secrets Operator. Operator Rahasia Eksternal adalah operator Kubernetes yang mengelola siklus hidup rahasia eksternal yang disimpan di penyimpanan rahasia eksternal seperti Azure Key Vault.

  1. Tambahkan repositori External Secrets Helm dan perbarui repositori menggunakan perintah helm repo add dan helm repo update.

    helm repo add external-secrets https://charts.external-secrets.io
helm repo update

    Contoh output:

    Hang tight while we grab the latest from your chart repositories...
...Successfully got an update from the "external-secrets" chart repository

  2. Instal External Secrets Operator menggunakan perintah helm install.

    helm install external-secrets \
external-secrets/external-secrets \
--namespace ${AKS_MONGODB_NAMESPACE} \
--create-namespace \
--set installCRDs=true \
--wait \
--set nodeSelector."kubernetes\.azure\.com/agentpool"=mongodbpool

    Contoh output:

    NAME: external-secrets
LAST DEPLOYED: Tue Jun 11 11:55:32 2024
NAMESPACE: mongodb
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
external-secrets has been deployed successfully in namespace mongodb!

In order to begin using ExternalSecrets, you will need to set up a SecretStore
or ClusterSecretStore resource (for example, by creating a 'vault' SecretStore).

More information on the different types of SecretStores and how to configure them
can be found in our Github: https://github.com/external-secrets/external-secrets

  3. Buat kata sandi acak menggunakan fungsi :

    #MongoDB connection strings can contain special characters in the password, which need to be URL encoded. 
#This is because the connection string is a URI, and special characters can interfere with the URI structure.
#This function generates secrets of 32 characters using only alphanumeric characters.

generateRandomPasswordString() {
    cat /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1
}

Membuat rahasia MongoDB

  1. Buat pengguna cadangan MongoDB dan rahasia kata sandi untuk digunakan untuk operasi pencadangan dan pemulihan apa pun menggunakan az keyvault secret set perintah .

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-BACKUP-USER --value MONGODB_BACKUP_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-BACKUP-PASSWORD --value $(generateRandomPasswordString) --output none

  2. Buat rahasia pengguna admin database MongoDB dan kata sandi untuk administrasi database dengan menggunakan az keyvault secret set sebuah perintah.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-DATABASE-ADMIN-USER --value MONGODB_DATABASE_ADMIN_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-DATABASE-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output none

  3. Buat pengguna admin kluster MongoDB dan rahasia kredensial admin untuk peran administrasi kluster yang menyediakan administrasi untuk lebih dari satu database dengan menggunakan perintah .

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-ADMIN-USER --value MONGODB_CLUSTER_ADMIN_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output none

  4. Buat pengguna untuk pemantauan kluster dan rahasia admin MongoDB untuk pemantauan kluster menggunakan perintah az keyvault secret set.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-MONITOR-USER --value MONGODB_CLUSTER_MONITOR_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-MONITOR-PASSWORD --value $(generateRandomPasswordString) --output none

  5. Buat rahasia pengguna dan kata sandi untuk administrasi pengguna menggunakan az keyvault secret set perintah .

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-USER-ADMIN-USER --value MONGODB_USER_ADMIN_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-USER-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output none

  6. Buat rahasia untuk kunci API yang digunakan untuk mengakses server Percona Monitoring and Management (PMM) menggunakan az keyvault secret set perintah . Anda akan memperbarui nilai dari informasi rahasia ini nanti saat Anda menyebarkan server PMM.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name PMM-SERVER-API-KEY --value $(openssl rand -base64 32) --output none

  7. Tambahkan AZURE-STORAGE-ACCOUNT-NAME untuk digunakan nanti dalam pencadangan menggunakan perintah az keyvault secret set.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name AZURE-STORAGE-ACCOUNT-NAME --value $AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME --output none

  1. Jalankan perintah berikut untuk memperbarui file yang mongodb.tfvars dibuat sebelumnya dengan konfigurasi berikut:

    cat >> mongodb.tfvars <<EOL
mongodb_kv_secrets = {
  MONGODB-BACKUP-USER              = "MONGODB_BACKUP_USER"
  MONGODB-BACKUP-PASSWORD          = "$(generateRandomPasswordString)"
  MONGODB-DATABASE-ADMIN-USER      = "MONGODB_DATABASE_ADMIN_USER"
  MONGODB-DATABASE-ADMIN-PASSWORD  = "$(generateRandomPasswordString)"
  MONGODB-CLUSTER-ADMIN-USER       = "MONGODB_CLUSTER_ADMIN_USER"
  MONGODB-CLUSTER-ADMIN-PASSWORD   = "$(generateRandomPasswordString)"
  MONGODB-CLUSTER-MONITOR-USER     = "MONGODB_CLUSTER_MONITOR_USER"
  MONGODB-CLUSTER-MONITOR-PASSWORD = "$(generateRandomPasswordString)"
  MONGODB-USER-ADMIN-USER          = "MONGODB_USER_ADMIN_USER"
  MONGODB-USER-ADMIN-PASSWORD      = "$(generateRandomPasswordString)"
  PMM-SERVER-API-KEY               = "$(generateRandomPasswordString)"
}
EOL

  2. Terapkan konfigurasi terraform ke sumber daya target.

    terraform fmt
terraform apply -var-file="mongodb.tfvars" -target module.mongodb[0].azurerm_key_vault_secret.this

Membuat sumber daya rahasia

  1. Buat SecretStore sumber daya untuk mengakses kata sandi MongoDB yang disimpan di brankas kunci Anda dengan perintah kubectl apply.

    kubectl apply -f - <<EOF
apiVersion: external-secrets.io/v1beta1
kind: SecretStore
metadata:
  name: azure-store
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  provider:
    # provider type: azure keyvault
    azurekv:
      authType: WorkloadIdentity
      vaultUrl: "${KEYVAULTURL}"
      serviceAccountRef:
        name: ${SERVICE_ACCOUNT_NAME}
EOF

    Contoh output:

    secretstore.external-secrets.io/azure-store created

  2. Buat sumber daya ExternalSecret dengan menggunakan perintah kubectl apply. Sumber daya ini membuat rahasia Kubernetes di mongodb namespace dengan rahasia MongoDB yang disimpan di key vault Anda.

    kubectl apply -f - <<EOF
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: ${AKS_MONGODB_SECRETS_NAME}
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: SecretStore
    name: azure-store

  target:
    name: "${AKS_MONGODB_SECRETS_NAME}"
    creationPolicy: Owner

  data:
    # name of the SECRET in the Azure key vault (no prefix is by default a SECRET)
    - secretKey: MONGODB_BACKUP_USER
      remoteRef:
        key: MONGODB-BACKUP-USER
    - secretKey: MONGODB_BACKUP_PASSWORD
      remoteRef:
        key: MONGODB-BACKUP-PASSWORD
    - secretKey: MONGODB_DATABASE_ADMIN_USER
      remoteRef:
        key: MONGODB-DATABASE-ADMIN-USER
    - secretKey: MONGODB_DATABASE_ADMIN_PASSWORD
      remoteRef:
        key: MONGODB-DATABASE-ADMIN-PASSWORD
    - secretKey: MONGODB_CLUSTER_ADMIN_USER
      remoteRef:
        key: MONGODB-CLUSTER-ADMIN-USER
    - secretKey: MONGODB_CLUSTER_ADMIN_PASSWORD
      remoteRef:
        key: MONGODB-CLUSTER-ADMIN-PASSWORD
    - secretKey: MONGODB_CLUSTER_MONITOR_USER
      remoteRef:
        key: MONGODB-CLUSTER-MONITOR-USER
    - secretKey: MONGODB_CLUSTER_MONITOR_PASSWORD
      remoteRef:
        key: MONGODB-CLUSTER-MONITOR-PASSWORD
    - secretKey: MONGODB_USER_ADMIN_USER
      remoteRef:
        key: MONGODB-USER-ADMIN-USER
    - secretKey: MONGODB_USER_ADMIN_PASSWORD
      remoteRef:
        key: MONGODB-USER-ADMIN-PASSWORD
    - secretKey: PMM_SERVER_API_KEY
      remoteRef:
        key: PMM-SERVER-API-KEY
EOF

    Contoh output:

    externalsecret.external-secrets.io/cluster-aks-mongodb-secrets created

  3. Buat sumber daya ExternalSecret dengan menggunakan perintah kubectl apply. Sumber daya ini membuat rahasia Kubernetes di mongodb namespace untuk rahasia Azure Blob Storage yang disimpan di brankas kunci Anda.

    kubectl apply -f - <<EOF
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: ${AKS_AZURE_SECRETS_NAME}
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: SecretStore
    name: azure-store

  target:
    name: "${AKS_AZURE_SECRETS_NAME}"
    creationPolicy: Owner

  data:
    # name of the SECRET in the Azure key vault (no prefix is by default a SECRET)
    - secretKey: AZURE_STORAGE_ACCOUNT_NAME
      remoteRef:
        key: AZURE-STORAGE-ACCOUNT-NAME
    - secretKey: AZURE_STORAGE_ACCOUNT_KEY
      remoteRef:
        key: AZURE-STORAGE-ACCOUNT-KEY
EOF

    Contoh output:

    externalsecret.external-secrets.io/cluster-aks-azure-secrets created

  1. Buat kredensial federasi menggunakan az identity federated-credential create perintah .

    az identity federated-credential create \
            --name external-secret-operator \
            --identity-name ${MY_IDENTITY_NAME} \
            --resource-group ${MY_RESOURCE_GROUP_NAME} \
            --issuer ${OIDC_URL} \
            --subject system:serviceaccount:${AKS_MONGODB_NAMESPACE}:${SERVICE_ACCOUNT_NAME} \
            --output none

  2. Berikan izin ke identitas yang ditetapkan pengguna untuk mengakses informasi rahasia menggunakan perintah az keyvault set-policy.

    az keyvault set-policy --name $MY_KEYVAULT_NAME --object-id $MY_IDENTITY_NAME_PRINCIPAL_ID --secret-permissions get --output table

    Contoh output:

    Location       Name            ResourceGroup
-------------  --------------  --------------------------------
australiaeast  vault-cjcfc-kv  myResourceGroup-rg-australiaeast

  1. Tambahkan konfigurasi terraform berikut di mongodb/main.tf untuk membuat kredensial gabungan.

    ## Section to create the federated identity credential for external secret operator
resource "azurerm_federated_identity_credential" "this" {
  name                = "external-secret-operator"
  resource_group_name = var.resource_group_name
  audience            = ["api://AzureADTokenExchange"]
  issuer              = var.oidc_issuer_url
  parent_id           = azurerm_user_assigned_identity.this.id
  subject             = "system:serviceaccount:${var.mongodb_namespace}:${var.service_account_name}"
}

  2. Tambahkan konfigurasi terraform berikut di mongodb/main.tf untuk memberikan izin ke identitas yang ditetapkan oleh pengguna agar dapat mengakses akun rahasia.

    ## Section to assign permission to the user-assigned identity to access the secret
resource "azurerm_key_vault_access_policy" "this" {
  key_vault_id = var.key_vault_id
  tenant_id    = azurerm_user_assigned_identity.this.tenant_id
  object_id    = azurerm_user_assigned_identity.this.principal_id

  secret_permissions = [
    "Get"
  ]
}

  3. Terapkan konfigurasi terraform.

        terraform fmt

    terraform apply -var-file="mongodb.tfvars" \
   -target=module.mongodb[0].azurerm_federated_identity_credential.this \
   -target=module.mongodb[0].azurerm_key_vault_access_policy.this

Menginstal Operator dan CRD Percona

Operator Percona biasanya didistribusikan sebagai Kubernetes Deployment atau Operator. Anda dapat menyebarkannya dengan menggunakan perintah kubectl apply -f dengan berkas manifes. Anda dapat menemukan manifes terbaru di repositori Percona GitHub atau dokumentasi resmi.

  • Sebarkan Operator Percona dan definisi sumber daya kustom (CRDs) dengan perintah kubectl apply.

    kubectl apply --server-side -f https://raw.githubusercontent.com/percona/percona-server-mongodb-operator/v1.16.0/deploy/bundle.yaml -n "${AKS_MONGODB_NAMESPACE}"

    Contoh output:

    customresourcedefinition.apiextensions.k8s.io/perconaservermongodbbackups.psmdb.percona.com serverside-applied
customresourcedefinition.apiextensions.k8s.io/perconaservermongodbrestores.psmdb.percona.com serverside-applied
customresourcedefinition.apiextensions.k8s.io/perconaservermongodbs.psmdb.percona.com serverside-applied
role.rbac.authorization.k8s.io/percona-server-mongodb-operator serverside-applied
serviceaccount/percona-server-mongodb-operator serverside-applied
rolebinding.rbac.authorization.k8s.io/service-account-percona-server-mongodb-operator serverside-applied
deployment.apps/percona-server-mongodb-operator serverside-applied

Menyebarkan kluster MongoDB

  1. Sebarkan kluster MongoDB dengan Operator Percona menggunakan perintah kubectl apply. Untuk membantu memastikan ketersediaan tinggi, Anda menyebarkan kluster MongoDB dengan set replika, dengan sharding diaktifkan, di beberapa zona ketersediaan, dan dengan solusi cadangan yang menyimpan cadangan di akun Azure Blob Storage.

    kubectl apply -f - <<EOF
apiVersion: psmdb.percona.com/v1
kind: PerconaServerMongoDB
metadata:
  name: ${AKS_MONGODB_CLUSTER_NAME}
  namespace: ${AKS_MONGODB_NAMESPACE}
  finalizers:
    - delete-psmdb-pods-in-order
spec:
  crVersion: 1.16.0
  image: ${MY_ACR_REGISTRY}.azurecr.io/percona-server-mongodb:7.0.8-5
  imagePullPolicy: Always
  updateStrategy: SmartUpdate
  upgradeOptions:
    versionServiceEndpoint: https://check.percona.com
    apply: disabled
    schedule: "0 2 * * *"
    setFCV: false
  secrets:
    users: "${AKS_MONGODB_SECRETS_NAME}"
    encryptionKey: "${AKS_MONGODB_SECRETS_ENCRYPTION_KEY}"
  pmm:
    enabled: true
    image: ${MY_ACR_REGISTRY}.azurecr.io/pmm-client:2.41.2
    serverHost: monitoring-service
  replsets:
    - name: rs0
      size: 3
      affinity:
        antiAffinityTopologyKey: "failure-domain.beta.kubernetes.io/zone"
      nodeSelector:
        kubernetes.azure.com/agentpool: "mongodbpool"
      podDisruptionBudget:
        maxUnavailable: 1
      expose:
        enabled: false
        exposeType: ClusterIP
      resources:
        limits:
          cpu: "300m"
          memory: "0.5G"
        requests:
          cpu: "300m"
          memory: "0.5G"
      volumeSpec:
        persistentVolumeClaim:
          storageClassName: managed-csi-premium
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 1Gi
      nonvoting:
        enabled: false
        size: 3
        affinity:
          antiAffinityTopologyKey: "failure-domain.beta.kubernetes.io/zone"
        nodeSelector:
          kubernetes.azure.com/agentpool: "mongodbpool"		 
        podDisruptionBudget:
          maxUnavailable: 1
        resources:
          limits:
            cpu: "300m"
            memory: "0.5G"
          requests:
            cpu: "300m"
            memory: "0.5G"
        volumeSpec:
          persistentVolumeClaim:
            storageClassName: managed-csi-premium
            accessModes: ["ReadWriteOnce"]
            resources:
              requests:
                storage: 1Gi
      arbiter:
        enabled: false
        size: 1
        affinity:
          antiAffinityTopologyKey: "failure-domain.beta.kubernetes.io/zone"
        nodeSelector:
          kubernetes.azure.com/agentpool: "mongodbpool"
        resources:
          limits:
            cpu: "300m"
            memory: "0.5G"
          requests:
            cpu: "300m"
            memory: "0.5G"
  sharding:
    enabled: true
    configsvrReplSet:
      size: 3
      affinity:
        antiAffinityTopologyKey: "failure-domain.beta.kubernetes.io/zone"
      nodeSelector:
        kubernetes.azure.com/agentpool: "mongodbpool"
      podDisruptionBudget:
        maxUnavailable: 1
      expose:
        enabled: false
      resources:
        limits:
          cpu: "300m"
          memory: "0.5G"
        requests:
          cpu: "300m"
          memory: "0.5G"
      volumeSpec:
        persistentVolumeClaim:
          storageClassName: managed-csi-premium
          accessModes: ["ReadWriteOnce"]
          resources:
            requests:
              storage: 1Gi
    mongos:
      size: 3
      affinity:
        antiAffinityTopologyKey: "failure-domain.beta.kubernetes.io/zone"
      nodeSelector:
        kubernetes.azure.com/agentpool: "mongodbpool"
      podDisruptionBudget:
        maxUnavailable: 1
      resources:
        limits:
          cpu: "300m"
          memory: "0.5G"
        requests:
          cpu: "300m"
          memory: "0.5G"
      expose:
        exposeType: ClusterIP
  backup:
    enabled: true
    image: ${MY_ACR_REGISTRY}.azurecr.io/percona-backup-mongodb:2.4.1
    storages:
      azure-blob:
        type: azure
        azure:
          container: "${AKS_MONGODB_BACKUP_STORAGE_CONTAINER_NAME}"
          prefix: psmdb
          endpointUrl: "https://${AKS_MONGODB_BACKUP_STORAGE_ACCOUNT_NAME}.blob.core.windows.net"
          credentialsSecret: "${AKS_AZURE_SECRETS_NAME}"
    pitr:
      enabled: false
      oplogOnly: false
      compressionType: gzip
      compressionLevel: 6
    tasks:
      - name: daily-azure-us-east
        enabled: true
        schedule: "0 0 * * *"
        keep: 3
        storageName: azure-blob    
        compressionType: gzip
        compressionLevel: 6
EOF

    Contoh output:

    perconaservermongodb.psmdb.percona.com/cluster-aks-mongodb created

  2. Selesaikan proses penyebaran kluster MongoDB menggunakan skrip berikut:

    while [ "$(kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE} -o jsonpath='{.items[0].status.state}')" != "ready" ]; do echo "waiting for MongoDB cluster to be ready"; sleep 10; done

  3. Setelah proses selesai, kluster Anda menunjukkan statusnya Ready . Anda dapat melihat status menggunakan kubectl get perintah .

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

    Contoh output:

    NAME                  ENDPOINT                                               STATUS   AGE
cluster-aks-mongodb   cluster-aks-mongodb-mongos.mongodb.svc.cluster.local   ready    3m1s

  4. Lihat zona ketersediaan simpul di kluster Anda menggunakan kubectl get perintah .

    kubectl get node -o custom-columns=Name:.metadata.name,Zone:".metadata.labels.topology\.kubernetes\.io/zone"

    Contoh output:

    Name                                   Zone
aks-mongodbpool-30094695-vmss000000    australiaeast-1
aks-systempool-28994785-vmss000000     australiaeast-1
aks-systempool-28994785-vmss000001     australiaeast-2
aks-systempool-28994785-vmss000002     australiaeast-3

Menyambungkan ke Percona Server

Untuk menyambungkan ke Percona Server for MongoDB, Anda perlu membuat string URI koneksi MongoDB. Ini termasuk kredensial pengguna admin, yang disimpan dalam Secrets objek.

  1. Daftar Secrets objek menggunakan perintah kubectl get.

    kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

    Contoh output:

    NAME                                                 TYPE                 DATA   AGE
cluster-aks-azure-secrets                            Opaque               2      2m56s
cluster-aks-mongodb-mongodb-keyfile                  Opaque               1      2m54s
cluster-aks-mongodb-secrets                          Opaque               11     2m56s
cluster-aks-mongodb-secrets-mongodb-encryption-key   Opaque               1      2m54s
cluster-aks-mongodb-ssl                              kubernetes.io/tls    3      2m55s
cluster-aks-mongodb-ssl-internal                     kubernetes.io/tls    3      2m54s
external-secrets-webhook                             Opaque               4      3m49s
internal-cluster-aks-mongodb-users                   Opaque               11     2m56s
sh.helm.release.v1.external-secrets.v1               helm.sh/release.v1   1      3m49s

  2. Lihat konten Secrets untuk menggunakan perintah kubectl get dalam mendapatkan kredensial admin.

    kubectl describe secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE}

    Contoh output:

    Name:         cluster-aks-mongodb-secrets
Namespace:    mongodb
Labels:       reconcile.external-secrets.io/managed=true
Annotations:  <none>

Type:  Opaque

Data
====
MONGODB_CLUSTER_ADMIN_USER:        12 bytes
MONGODB_CLUSTER_MONITOR_PASSWORD:  16 bytes
MONGODB_CLUSTER_MONITOR_USER:      14 bytes
MONGODB_DATABASE_ADMIN_USER:       13 bytes
MONGODB_USER_ADMIN_USER:           9 bytes
MONGODB_BACKUP_PASSWORD:           16 bytes
MONGODB_BACKUP_USER:               6 bytes
MONGODB_CLUSTER_ADMIN_PASSWORD:    18 bytes
MONGODB_DATABASE_ADMIN_PASSWORD:   18 bytes
MONGODB_USER_ADMIN_PASSWORD:       17 bytes

  3. Dekodekan nama login dan kata sandi yang dikodekan Base64 dan ekspor string koneksi ke variabel lingkungan menggunakan perintah berikut:

Important

Microsoft menyarankan agar Anda menggunakan alur autentikasi paling aman yang tersedia. Alur autentikasi yang dijelaskan dalam prosedur ini membutuhkan tingkat kepercayaan yang sangat tinggi pada aplikasi, dan membawa risiko yang tidak ada dalam alur lain. Anda hanya boleh menggunakan alur ini ketika alur lain yang lebih aman, seperti identitas terkelola, tidak layak.

export databaseAdmin=$(kubectl get secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE} -o jsonpath="{.data.MONGODB_DATABASE_ADMIN_USER}" | base64 --decode)
export databaseAdminPassword=$(kubectl get secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE} -o jsonpath="{.data.MONGODB_DATABASE_ADMIN_PASSWORD}" | base64 --decode)
export connectionString="mongodb://${databaseAdmin}:${databaseAdminPassword}@${AKS_MONGODB_CLUSTER_NAME}-mongos.mongodb.svc.cluster.local/admin?replicaSet=rs0&ssl=false&directConnection=true"

Memverifikasi kluster MongoDB

Di bagian ini, Anda memverifikasi kluster MongoDB dengan menjalankan kontainer dengan klien MongoDB dan menghubungkan output konsolnya ke terminal Anda.

  1. Buat pod bernama percona-client di bawah namespace ${AKS_MONGODB_NAMESPACE} dalam kluster Anda menggunakan perintah kubectl run.

    kubectl -n "${AKS_MONGODB_NAMESPACE}" run -i --rm --tty percona-client --image=${MY_ACR_REGISTRY}.azurecr.io/percona-server-mongodb:7.0.8-5 --restart=Never -- env CONN_STR=$connectionString bash -il

  2. Di jendela terminal yang berbeda, pastikan bahwa pod berhasil dibuat menggunakan perintah kubectl get.

    kubectl get pod percona-client -n ${AKS_MONGODB_NAMESPACE}

    Contoh output:

    NAME             READY   STATUS    RESTARTS   AGE
percona-client   1/1     Running   0          39s

  3. Sambungkan ke kluster MongoDB menggunakan info masuk pengguna admin dari bagian sebelumnya di jendela terminal yang Anda gunakan untuk membuat percona-client pod.

    mongosh $CONN_STR

    Contoh output:

    Current Mongosh Log ID: L6mN7oP8qR9sT0uV1wX2yZ3a
Connecting to:          mongodb://<credentials>@cluster-aks-mongodb-mongos.mongodb.svc.cluster.local/admin?replicaSet=rs0&ssl=false&directConnection=true&appName=mongosh+2.1.5
Using MongoDB:          7.0.8-5
Using Mongosh:          2.1.5

For mongosh info see: https://docs.mongodb.com/mongodb-shell/
...

  4. Cantumkan database di kluster Anda menggunakan show dbs perintah .

    show dbs

    Contoh output:

    rs0 [direct: mongos] admin> show dbs
admin   960.00 KiB
config    3.45 MiB
rs0 [direct: mongos] admin>

Membuat cadangan MongoDB

Anda dapat mencadangkan data Anda ke Azure menggunakan salah satu metode berikut:

  • Manual: Cadangkan data Anda secara manual kapan saja.
  • Terjadwal: Mengonfigurasi pencadangan dan jadwal dalam file YAML CRD. Operator Percona membuat cadangan secara otomatis sesuai dengan jadwal yang ditentukan.

Operator Percona dapat melakukan salah satu dari dua jenis cadangan berikut:

  • Pencadangan logis: Query Percona Server for MongoDB untuk data database, lalu tulis data yang diambil ke penyimpanan cadangan jarak jauh.
  • Pencadangan fisik: Salin file fisik dari direktori data Percona Server for MongoDB dbPath ke penyimpanan cadangan jarak jauh.

Pencadangan logis menggunakan lebih sedikit penyimpanan tetapi lebih lambat daripada pencadangan fisik.

Untuk menyimpan cadangan di Azure Blob Storage menggunakan Percona, Anda perlu membuat rahasia. Anda menyelesaikan langkah ini di perintah sebelumnya. Untuk instruksi terperinci, ikuti langkah-langkah dalam dokumentasi Percona tentang Azure Blob Storage.

Mengonfigurasi pencadangan terjadwal

Anda dapat menentukan jadwal pencadangan di bagian cadangan CRD di mongodb-cr.yaml menggunakan panduan berikut:

  • Atur kunci backup.enabled ke true.
  • Pastikan bahwa sub-bagian backup.storages berisi setidaknya satu sumber daya penyimpanan yang telah dikonfigurasi.
  • Pastikan sub-bagian backup.tasks mengaktifkan penjadwalan cadangan.

Untuk informasi selengkapnya, lihat Membuat cadangan terjadwal.

Lakukan pencadangan manual

Anda dapat membuat cadangan manual sesuai permintaan di bagian cadangan CRD di mongodb-cr.yaml menggunakan panduan berikut:

  • Atur kunci backup.enabled ke true.
  • Pastikan bahwa sub-bagian backup.storages berisi setidaknya satu sumber daya penyimpanan yang telah dikonfigurasi.

Untuk informasi selengkapnya, lihat Membuat cadangan sesuai permintaan.

Menyebarkan cadangan MongoDB

  1. Sebarkan cadangan MongoDB Anda menggunakan kubectl apply perintah .

    kubectl apply -f - <<EOF
apiVersion: psmdb.percona.com/v1
kind: PerconaServerMongoDBBackup
metadata:
  finalizers:
  - delete-backup
  name: az-backup1
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  clusterName: ${AKS_MONGODB_CLUSTER_NAME}
  storageName: azure-blob
  type: logical
EOF

    Contoh output:

    perconaservermongodbbackup.psmdb.percona.com/az-backup1 created

  2. Selesaikan proses penyebaran cadangan MongoDB menggunakan skrip berikut:

    while [ "$(kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE} -o jsonpath='{.items[0].status.state}')" != "ready" ]; do echo "waiting for the backup to be ready"; sleep 10; done

    Contoh output:

    waiting for the backup to be ready

  3. Ketika proses selesai, cadangan harus mengembalikan Ready status . Verifikasi bahwa penyebaran cadangan berhasil menggunakan kubectl get perintah .

    kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

    Contoh output:

    NAME         CLUSTER               STORAGE      DESTINATION                                                                       TYPE      STATUS   COMPLETED   AGE
az-backup1   cluster-aks-mongodb   azure-blob   https://mongodbsacjcfc.blob.core.windows.net/backups/psmdb/2024-07-01T12:27:57Z   logical   ready    3h3m        3h3m

  4. Jika Anda memiliki masalah dengan cadangan, Anda dapat melihat log dari backup-agent kontainer pod yang sesuai menggunakan kubectl logs perintah .

    kubectl logs pod/${AKS_MONGODB_CLUSTER_NAME}-rs0-0 -c backup-agent -n ${AKS_MONGODB_NAMESPACE}

Langkah selanjutnya

Menyebarkan aplikasi klien (Mongo Express)

  • Terakhir diperbarui pada