Azure Kubernetes Service'te (AKS) MongoDB kümesi yapılandırma ve dağıtma

Bu makalede, Azure Kubernetes Service'te (AKS) bir MongoDB kümesi yapılandırıp dağıtacaksınız.

İş yükü kimliğini yapılandırma

  1. komutunu kullanarak MongoDB kümesi için bir ad alanı kubectl create namespace oluşturun.

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

    Örnek çıkış:

    namespace/mongodb created

  2. Komutunu kullanarak kubectl apply bir hizmet hesabı oluşturun ve bir iş yükü kimliği yapılandırın.

    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

    Örnek çıkış:

    serviceaccount/mongodb created

Harici Gizli Bilgiler Operatörü Kurulumu

Bu bölümde, Helm aracını kullanarak External Secrets Operator'ü yükleyeceksiniz. Dış Gizli Diziler operatörü, Azure Key Vault gibi dış gizli dizi depolarında depolanan dış gizli dizilerin yaşam döngüsünü yöneten bir Kubernetes operatörüdür.

  1. Harici Sırlar Helm deposunu ekleyin ve helm repo add ve helm repo update komutlarını kullanarak depoyu güncelleyin.

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

    Örnek çıkış:

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

  2. helm install komutunu kullanarak External Secrets Operator'ü yükleyin.

    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

    Örnek çıkış:

    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. işlevini kullanarak rastgele bir parola oluşturun:

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

MongoDB gizli bilgileri oluşturma

  1. komutunu kullanarak herhangi bir yedekleme ve geri yükleme işlemi için kullanılacak bir MongoDB yedekleme kullanıcısı ve parola gizli dizisi az keyvault secret set oluşturun.

    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. Komutu kullanarak veritabanı yönetimi için bir MongoDB veritabanı yöneticisi kullanıcı adı ve parola gizli anahtarı oluşturun.

    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. Komutunu kullanarak birden fazla veritabanı için yönetim sağlayan bir küme yönetim rolü için MongoDB küme yönetim kullanıcısı ve yönetici gizli anahtarı oluşturun.

    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. Cluster izleme kullanıcısı ve yönetici sırrı oluşturmak için az keyvault secret set komutunu kullanarak bir MongoDB kümesi izleme oluşturun.

    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. komutunu kullanarak az keyvault secret set için bir kullanıcı ve parola sırrı oluşturun.

    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. az keyvault secret set komutunu kullanarak Percona İzleme ve Yönetimi (PMM) sunucusuna erişmek için kullanılan API anahtarına ait bir gizli anahtar oluşturun. Bu gizlinin değerini daha sonra PMM sunucusunu dağıttığınızda güncellersiniz.

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

  7. AZURE-STORAGE-ACCOUNT-NAME öğesini, az keyvault secret set komutunu kullanarak daha sonra yedeklemeler için kullanmak üzere ekleyin.

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

  1. Daha önce oluşturulan dosyayı aşağıdaki yapılandırmayla güncelleştirmek mongodb.tfvars için aşağıdaki komutu çalıştırın:

    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. Terraform yapılandırmasını hedef kaynağa uygulayın.

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

Gizli kaynaklar oluştur

  1. komutunu kullanarak SecretStore anahtar kasanızda depolanan MongoDB parolalarına erişmek için bir kubectl apply kaynak oluşturun.

    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

    Örnek çıkış:

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

  2. ExternalSecret kaynak oluşturmak için kubectl apply komutunu kullanın. Bu kaynak, anahtar kasanızda depolanan MongoDB gizli verisiyle mongodb ad alanında bir Kubernetes gizli veri oluşturur.

    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

    Örnek çıkış:

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

  3. ExternalSecret kaynak oluşturmak için kubectl apply komutunu kullanın. Bu kaynak, anahtar kasanızda depolanan Azure Blob Depolama gizli anahtarları için mongodb namespace'inde bir Kubernetes gizli anahtarı oluşturur.

    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

    Örnek çıkış:

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

  1. komutunu kullanarak az identity federated-credential create bir federasyon kimlik bilgisi oluşturun.

    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. Kullanıcı atanmış kimliğe az keyvault set-policy komutu kullanılarak gizli anahtara erişim izni verin.

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

    Örnek çıkış:

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

  1. Federasyon kimlik bilgisi oluşturmak için aşağıdaki terraform yapılandırmasını mongodb/main.tf içine ekleyin.

    ## 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. Kullanıcı tarafından atanan kimliğe gizli anahtara erişim izni vermek için aşağıdaki terraform yapılandırmasını mongodb/main.tf içine ekleyin.

    ## 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. Terraform yapılandırmasını uygulayın.

        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

Percona İşlecini ve CRD'leri yükleme

Percona İşleci genellikle kubernetes Deployment veya Operatorolarak dağıtılır. Bildirim dosyası içeren bir kubectl apply -f komut kullanarak dağıtabilirsiniz. En son bildirimleri Percona GitHub deposunda veya resmi belgelerde bulabilirsiniz.

  • komutunu kullanarak Percona İşleci'ni ve özel kaynak tanımlarını (CRD) dağıtın 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}"

    Örnek çıkış:

    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

MongoDB kümesini dağıtma

  1. komutunu kullanarak Percona İşleci ile bir MongoDB kümesi dağıtın kubectl apply . Yüksek kullanılabilirlik sağlamaya yardımcı olmak için MongoDB kümesini, parçalama etkinleştirilmiş bir çoğaltma kümesiyle, birden çok erişilebilirlik bölgesinde ve yedeklemeleri bir Azure Blob Depolama hesabında depolayan bir yedekleme çözümüyle dağıtırsınız.

    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

    Örnek çıkış:

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

  2. Aşağıdaki betiği kullanarak MongoDB kümesi dağıtım işlemini tamamlayın:

    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. İşlem tamamlandığında, kümeniz Ready durumunu gösterir. komutunu kullanarak kubectl get durumu görüntüleyebilirsiniz.

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

    Örnek çıkış:

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

  4. komutunu kullanarak kubectl get kümenizdeki düğümlerin kullanılabilirlik alanlarını görüntüleyin.

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

    Örnek çıkış:

    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

Percona Sunucusuna bağlanma

MongoDB için Percona Sunucusu'na bağlanmak için MongoDB bağlantı URI dizesini oluşturmanız gerekir. Nesnesinde Secrets depolanan yönetici kullanıcının kimlik bilgilerini içerir.

  1. Secrets komutunu kullanarak nesneleri listeleyinkubectl get.

    kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

    Örnek çıkış:

    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. Secrets komutunu kullanarak kubectl get yönetici kullanıcı kimlik bilgilerini almak için içeriği görüntüleyin.

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

    Örnek çıkış:

    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. Aşağıdaki komutları kullanarak Base64 ile kodlanmış oturum açma adı ve parolasının kodunu çözerek bağlantı dizesini ortam değişkenine aktarın:

Important

Microsoft, kullanılabilir en güvenli kimlik doğrulama akışını kullanmanızı önerir. Bu yordamda açıklanan kimlik doğrulama akışı, uygulamada çok yüksek düzeyde güven gerektirir ve diğer akışlarda mevcut olmayan riskleri taşır. Bu akışı yalnızca yönetilen kimlikler gibi diğer daha güvenli akışlar uygun olmadığında kullanmalısınız.

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"

MongoDB kümesini doğrulama

Bu bölümde, MongoDB istemcisiyle bir kapsayıcı çalıştırarak MongoDB kümenizi doğrular ve konsol çıkışını terminalinize bağlarsınız.

  1. komutunu kullanarak percona-client kümenizdeki ad alanının altında ${AKS_MONGODB_NAMESPACE} adlı kubectl run bir pod oluşturun.

    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. Farklı bir terminal penceresinde kubectl get komutunu kullanarak pod'un başarıyla oluşturulduğunu doğrulayın.

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

    Örnek çıkış:

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

  3. Pod oluşturmak için kullandığınız terminal penceresinin önceki bölümünde yer alan yönetici kullanıcı kimlik bilgilerini kullanarak MongoDB kümesine bağlanın percona-client .

    mongosh $CONN_STR

    Örnek çıkış:

    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. komutunu kullanarak kümenizdeki veritabanlarını listeleyin show dbs .

    show dbs

    Örnek çıkış:

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

MongoDB yedeklemesi oluşturma

Aşağıdaki yöntemlerden birini kullanarak verilerinizi Azure'a yedekleyebilirsiniz:

  • El ile: Verilerinizi istediğiniz zaman el ile yedekleyin.
  • Zamanlandı: CRD YAML'de yedeklemeleri ve bunların zamanlamalarını yapılandırın. Percona İşleci, yedeklemeleri belirtilen zamanlamaya göre otomatik olarak yapar.

Percona İşleci aşağıdaki yedekleme türlerinden birini gerçekleştirebilir:

  • Mantıksal yedekleme: Veritabanı verileri için MongoDB için Percona Sunucusu'nu sorgulayın ve ardından alınan verileri uzak yedekleme depolama alanına yazın.
  • Fiziksel yedekleme: MongoDB dbPath için Percona Sunucusu veri dizininden uzak yedekleme depolama alanına fiziksel dosyaları kopyalayın.

Mantıksal yedeklemeler daha az depolama alanı kullanır ancak fiziksel yedeklemelerden daha yavaştır.

Percona kullanarak Azure Blob Depolama'da yedeklemeleri depolamak için bir giz oluşturmanız gerekir. Bu adımı önceki bir komutta tamamladınız. Ayrıntılı yönergeler için Azure Blob Depolama hakkında Percona belgelerindeki adımları izleyin.

Zamanlanmış yedeklemeleri yapılandırma

Aşağıdaki yönergeleri kullanarak yedekleme zamanlamasını mongodb-cr.yaml içindeki CRD'nin yedekleme bölümünde tanımlayabilirsiniz:

  • backup.enabled anahtarını trueolarak ayarlayın.
  • Alt bölümün backup.storages en az bir yapılandırılmış depolama kaynağı içerdiğinden emin olun.
  • Alt bölümün backup.tasks yedekleme zamanlamasını etkinleştirdiğinden emin olun.

Daha fazla bilgi için bkz. Zamanlanmış yedeklemeler yapma.

El ile yedekleme gerçekleştirme

Aşağıdaki yönergeleri kullanarak mongodb-cr.yaml içindeki CRD'nin yedekleme bölümünde el ile ve isteğe bağlı yedekleme yapabilirsiniz:

  • backup.enabled anahtarını trueolarak ayarlayın.
  • Alt bölümün backup.storages en az bir yapılandırılmış depolama kaynağı içerdiğinden emin olun.

Daha fazla bilgi için bkz. İsteğe bağlı yedeklemeler yapma.

MongoDB yedeğini dağıtma

  1. Komutunu kullanarak MongoDB yedeklemenizi dağıtın kubectl apply .

    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

    Örnek çıkış:

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

  2. Aşağıdaki betiği kullanarak MongoDB yedekleme dağıtım işlemini tamamlayın:

    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

    Örnek çıkış:

    waiting for the backup to be ready

  3. İşlem tamamlandığında yedekleme, Ready durumunu döndürmelidir. komutunu kullanarak yedekleme dağıtımının kubectl get başarılı olduğunu doğrulayın.

    kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

    Örnek çıkış:

    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. Yedeklemeyle ilgili herhangi bir sorun yaşıyorsanız, backup-agent komutunu kullanarak uygun podun kubectl logs kapsayıcısından günlükleri görüntüleyebilirsiniz.

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

Sonraki adım

İstemci uygulaması dağıtma (Mongo Express)

  • Son güncelleştirme: