Leer en inglés

Compartir a través de


Configuración e implementación de un clúster de MongoDB en Azure Kubernetes Service (AKS)

En este artículo, configura e implementa un clúster de MongoDB en Azure Kubernetes Service (AKS).

Configuración de una identidad de carga de trabajo

  1. Cree un espacio de nombres para el clúster de MongoDB mediante el comando kubectl create namespace:

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

    Ejemplo:

    namespace/mongodb created
    
  2. Cree una cuenta de servicio y configure una identidad de carga de trabajo mediante el comando kubectl apply:

    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
    

    Ejemplo:

    serviceaccount/mongodb created
    

Instalación del operador de secretos externos

En esta sección, usa Helm para instalar el operador de secretos externos. El operador de secretos externos es un operador de Kubernetes que administra el ciclo de vida de los secretos externos almacenados en almacenes de secretos externos, como Azure Key Vault.

  1. Agregue el repositorio de Helm de secretos externos y actualice el repositorio mediante los comandos helm repo add y helm repo update:

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

    Ejemplo:

    Hang tight while we grab the latest from your chart repositories...
    ...Successfully got an update from the "external-secrets" chart repository
    
  2. Instale el operador de secretos externos mediante el comando helm install:

    helm install external-secrets \
    external-secrets/external-secrets \
    --namespace ${AKS_MONGODB_NAMESPACE} \
    --create-namespace \
    --set installCRDs=true \
    --wait
    

    Ejemplo:

    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. Genere una contraseña aleatoria para el clúster de MongoDB y almacénela en Azure Key Vault mediante el comando az keyvault secret set:

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

    Cree un usuario de copia de seguridad y una contraseña de MongoDB secreta que se usarán para cualquier operación de copia de seguridad y restauración:

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

    Cree un usuario administrador de la base de datos y una contraseña secreta de MongoDB para la administración de la base de datos:

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

    Cree un usuario administrador de clústeres y un secreto de administración de MongoDB para un rol de administración de clústeres que proporcione administración para más de una base de datos:

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

    Cree un usuario de supervisión del clúster y administrador secreto de MongoDB para la supervisión del clúster:

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

    Creación de un usuario y una contraseña secreta para la administración de usuarios:

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

    Agregue AZURE-STORAGE-ACCOUNT-NAME para usarlo más adelante para las copias de seguridad:

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

    Salidas de ejemplo para cada uno de los comandos anteriores:

    Name                Value
    ------------------  --------------------------------------------
    PMM-SERVER-API-KEY  KH4uE6MlJ6fbhVbVT5sz...
    

Crear secretos

  1. Cree un recurso SecretStore para acceder a las contraseñas de MongoDB almacenadas en el almacén de claves mediante el comando 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
    

    Ejemplo:

    secretstore.external-secrets.io/azure-store created
    
  2. Cree un recurso ExternalSecret mediante el comando kubectl apply. Este recurso crea un secreto de Kubernetes en el espacio de nombres mongodb con los secretos de MongoDB almacenados en el almacén de claves.

    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
    EOF
    

    Ejemplo:

    externalsecret.external-secrets.io/cluster-aks-mongodb-secrets created
    
  3. Cree un recurso ExternalSecret mediante el comando kubectl apply. Este recurso crea un secreto de Kubernetes en el espacio de nombres mongodb para los secretos de Azure Blob Storage almacenados en el almacén de claves.

    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
    

    Ejemplo:

    externalsecret.external-secrets.io/cluster-aks-azure-secrets created
    
  4. Cree una credencial federada mediante el comando az identity federated-credential create:

    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 table
    

    Ejemplo:

    Issuer                                                                                                                   Name                      ResourceGroup                     Subject
    -----------------------------------------------------------------------------------------------------------------------  ------------------------  --------------------------------  -------------------------------------
    https://australiaeast.oic.prod-aks.azure.com/07fa200c-6006-411f-bb29-a43bdf1a2bcc/d0709689-42d4-49a4-a6c8-5caa0b2384ba/  external-secret-operator  myResourceGroup-rg-australiaeast  system:serviceaccount:mongodb:mongodb
    
  5. Conceda permiso a la identidad asignada por el usuario para acceder al secreto mediante el comando az keyvault set-policy:

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

    Ejemplo:

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

Instalación de Percona Operator y CRD

Percona Operator se distribuye normalmente como una Deployment o Operator de Kubernetes. Puede implementarlo mediante un comando kubectl apply -f con un archivo de manifiesto. Puede encontrar los manifiestos más recientes en el repositorio de GitHub de Percona o en la documentación oficial.

Use el comando kubectl apply para implementar Percona Operator y las definiciones de recursos personalizadas (CRD):

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

Ejemplo:

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

Implementación del clúster de MongoDB

  1. Implemente un clúster de MongoDB con Percona Operator. Para ayudar a garantizar la alta disponibilidad, el clúster de MongoDB se implementa con un conjunto de réplicas, con el particionamiento habilitado, y en varias zonas de disponibilidad. El clúster de MongoDB se implementa con una solución de copia de seguridad que almacena las copias de seguridad en una cuenta de Azure Blob Storage.

    El script implementa un clúster de MongoDB con la siguiente configuración:

    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: false
        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"
          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"
            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"
            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"
          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"
          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
    

    Ejemplo:

    perconaservermongodb.psmdb.percona.com/cluster-aks-mongodb created
    
  2. Finalice el proceso de implementación del clúster de MongoDB mediante el siguiente script:

    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
    

    Una vez finalizado el proceso, el clúster muestra el estado ready. Para ver el estado, ejecute el siguiente comando:

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}
    

    Ejemplo:

    NAME                  ENDPOINT                                               STATUS   AGE
    cluster-aks-mongodb   cluster-aks-mongodb-mongos.mongodb.svc.cluster.local   ready    3m1s
    
  3. Para ayudar a garantizar la alta disponibilidad, el clúster de MongoDB se implementa en varias zonas de disponibilidad. Para ver esta información, ejecute el siguiente comando:

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

    Ejemplo:

    Name                                Zone
    aks-nodepool1-28994785-vmss000000   australiaeast-1
    aks-nodepool1-28994785-vmss000001   australiaeast-2
    aks-nodepool1-28994785-vmss000002   australiaeast-3
    

Conexión a Percona Server

Para conectarse a Percona Server para MongoDB, debe construir la cadena de URI de conexión de MongoDB. Incluye las credenciales del usuario administrador, que se almacenan en el objeto Secrets.

  1. Enumere los objetos Secrets mediante el comando kubectl get:

    kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}
    

    Ejemplo:

    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. Vea el contenido del Secrets para recuperar las credenciales del usuario administrador mediante el comando kubectl get:

    kubectl get secret ${AKS_MONGODB_SECRETS_NAME} -o yaml -n ${AKS_MONGODB_NAMESPACE}
    

    Ejemplo:

    apiVersion: v1
    data:
    MONGODB_BACKUP_PASSWORD: SmhBRFo4aXNI...
    MONGODB_BACKUP_USER: TU9OR09EQl9...
    MONGODB_CLUSTER_ADMIN_PASSWORD: cE1oOFRMS1p0VkRQc...
    MONGODB_CLUSTER_ADMIN_USER: TU9OR09EQl9DTFV...
    MONGODB_CLUSTER_MONITOR_PASSWORD: emRuc0tPSVdWR0ZtS01i...
    MONGODB_CLUSTER_MONITOR_USER: TU9OR09EQl9DTFV...
    MONGODB_DATABASE_ADMIN_PASSWORD: cmZDZ2xEbDR2SVI...
    MONGODB_DATABASE_ADMIN_USER: TU9OR09EQl9EQVRB...
    MONGODB_USER_ADMIN_PASSWORD: ZE1uQW9tOXVNVGdyMVh...
    MONGODB_USER_ADMIN_USER: TU9OR09EQl9VU0...
    immutable: false
    kind: Secret
    metadata:
    annotations:
        kubectl.kubernetes.io/last-applied-configuration: |
        {"apiVersion":"external-secrets.io/v1beta1","kind":"ExternalSecret","metadata":{"annotations":{},"name":"cluster-aks-mongodb-secrets","namespace":"mongodb"},"spec":{"data":[{"remoteRef":{"key":"MONGODB-BACKUP-USER"},"secretKey":"MONGODB_BACKUP_USER"},{"remoteRef":{"key":"MONGODB-BACKUP-PASSWORD"},"secretKey":"MONGODB_BACKUP_PASSWORD"},{"remoteRef":{"key":"MONGODB-DATABASE-ADMIN-USER"},"secretKey":"MONGODB_DATABASE_ADMIN_USER"},{"remoteRef":{"key":"MONGODB-DATABASE-ADMIN-PASSWORD"},"secretKey":"MONGODB_DATABASE_ADMIN_PASSWORD"},{"remoteRef":{"key":"MONGODB-CLUSTER-ADMIN-USER"},"secretKey":"MONGODB_CLUSTER_ADMIN_USER"},{"remoteRef":{"key":"MONGODB-CLUSTER-ADMIN-PASSWORD"},"secretKey":"MONGODB_CLUSTER_ADMIN_PASSWORD"},{"remoteRef":{"key":"MONGODB-CLUSTER-MONITOR-USER"},"secretKey":"MONGODB_CLUSTER_MONITOR_USER"},{"remoteRef":{"key":"MONGODB-CLUSTER-MONITOR-PASSWORD"},"secretKey":"MONGODB_CLUSTER_MONITOR_PASSWORD"},{"remoteRef":{"key":"MONGODB-USER-ADMIN-USER"},"secretKey":"MONGODB_USER_ADMIN_USER"},{"remoteRef":{"key":"MONGODB-USER-ADMIN-PASSWORD"},"secretKey":"MONGODB_USER_ADMIN_PASSWORD"}],"refreshInterval":"1h","secretStoreRef":{"kind":"SecretStore","name":"azure-store"},"target":{"creationPolicy":"Owner","name":"cluster-aks-mongodb-secrets"}}}
        reconcile.external-secrets.io/data-hash: 66c2c896ca641ffd72afead32fc24239
    creationTimestamp: "2024-07-01T12:24:38Z"
    labels:
        reconcile.external-secrets.io/created-by: d2ddd20e883057790bca8dc5f304303d
    name: cluster-aks-mongodb-secrets
    namespace: mongodb
    ownerReferences:
    - apiVersion: external-secrets.io/v1beta1
        blockOwnerDeletion: true
        controller: true
        kind: ExternalSecret
        name: cluster-aks-mongodb-secrets
        uid: 2e24dbbd-7144-4227-9015-5bd69468953a
    resourceVersion: "1872"
    uid: 3b37617f-b3e3-40df-8dff-d9e5c1916275
    type: Opaque
    
  3. Descodifique el nombre de inicio de sesión codificado en Base64 y la contraseña de la salida mediante los siguientes comandos:

    #Decode login name and password on the output, which are Base64-encoded
    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)
    
    echo $databaseAdmin
    echo $databaseAdminPassword
    echo $AKS_MONGODB_CLUSTER_NAME
    

    Ejemplo:

    MONGODB_DATABASE_ADMIN_USER
    rfCglDl4vIR3W...
    cluster-aks-mongodb
    

Comprobación del clúster de MongoDB

Para comprobar el clúster de MongoDB, ejecute un contenedor con un cliente de MongoDB y conecte su salida de consola al terminal:

  1. Cree un pod denominado percona-client en el espacio de nombres ${AKS_MONGODB_NAMESPACE} del clúster mediante el comando 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 -- bash -il
    
  2. En otra ventana de terminal, compruebe que el pod se creó correctamente mediante el comando kubectl get:

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

    Ejemplo:

    NAME             READY   STATUS    RESTARTS   AGE
    percona-client   1/1     Running   0          39s
    
  3. Conéctese al clúster de MongoDB mediante las credenciales de usuario administrador de la sección anterior en la ventana de terminal que usó para crear el pod percona-client:

    # Note: Replace variables `databaseAdmin` , `databaseAdminPassword` and `AKS_MONGODB_CLUSTER_NAME` with actual values printed in step 3.
    
    mongosh "mongodb://${databaseAdmin}:${databaseAdminPassword}@${AKS_MONGODB_CLUSTER_NAME}-mongos.mongodb.svc.cluster.local/admin?replicaSet=rs0&ssl=false&directConnection=true"
    

    Ejemplo:

    Current Mongosh Log ID: 66c76906115c6c831866efba
    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. Enumere las bases de datos del clúster mediante el comando show dbs:

    show dbs
    

    Ejemplo:

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

Creación de una copia de seguridad de MongoDB

Puede realizar una copia de seguridad de los datos en Azure mediante uno de los siguientes métodos:

  • Manual: realice una copia de seguridad manual de los datos en cualquier momento.
  • Programada: configure copias de seguridad y sus programaciones en CRD YAML. Percona Operator realiza las copias de seguridad automáticamente según la programación especificada.

Percona Operator puede realizar cualquiera de estos tipos de copia de seguridad:

  • Copia de seguridad lógica: consulte Percona Server for MongoDB para los datos de la base de datos y, a continuación, escriba los datos recuperados en el almacenamiento de copia de seguridad remoto.
  • Copia de seguridad física: copia de archivos físicos del directorio de datos de Percona Server for MongoDB dbPath al almacenamiento de copia de seguridad remoto.

Las copias de seguridad lógicas usan menos almacenamiento, pero son más lentas que las copias de seguridad físicas.

Para almacenar copias de seguridad en Azure Blob Storage mediante Percona, debe crear un secreto. Ha completado este paso en un comando anterior. Para obtener instrucciones detalladas, siga los pasos descritos en la documentación de Percona sobre Azure Blob Storage.

Configuración de copias de seguridad programadas

Puede definir la programación de copia de seguridad en la sección de copia de seguridad del CRD en mongodb-cr.yaml mediante las siguientes instrucciones:

  • Establezca la clave backup.enabled en true.
  • Asegúrese de que la subsección backup.storages contiene al menos un recurso de almacenamiento configurado.
  • Asegúrese de que la subsección backup.tasks habilita la programación de copias de seguridad.

Para obtener más información, consulte Realización de copias de seguridad programadas.

Realización de copias de seguridad manuales

Puede realizar una copia de seguridad manual a petición en la sección de copia de seguridad del CRD en mongodb-cr.yaml mediante las siguientes instrucciones:

  • Establezca la clave backup.enabled en true.
  • Asegúrese de que la subsección backup.storages contiene al menos un recurso de almacenamiento configurado.

Para obtener más información, consulte Realización de copias de seguridad a petición.

Implementación de una copia de seguridad de MongoDB

  1. Implemente la copia de seguridad de MongoDB mediante el comando 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
    

    Ejemplo:

    perconaservermongodbbackup.psmdb.percona.com/az-backup1 created
    
  2. Finalice el proceso de implementación de la copia de seguridad de MongoDB mediante el siguiente script:

    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
    

    Ejemplo:

    waiting for the backup to be ready
    
  3. Cuando finalice el proceso, la copia de seguridad debe devolver el estado ready. Compruebe que la implementación de la copia de seguridad se realizó correctamente mediante el comando kubectl get:

    kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}
    

    Ejemplo:

    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. Si tiene algún problema con la copia de seguridad, puede ver los registros del contenedor backup-agent del pod adecuado mediante el siguiente comando:

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

Para más información acerca de la implementación de software de código abierto en AKS, consulte los siguientes artículos: