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 de resultado:

    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 de resultado:

    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 de resultado:

    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 \
--set nodeSelector."kubernetes\.azure\.com/agentpool"=mongodbpool

    Ejemplo de resultado:

    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 mediante la función :

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

Crear secretos de MongoDB

  1. Cree un usuario y una contraseña secreta de respaldo de MongoDB para usar en cualquier operación de respaldo y restauración mediante el comando az keyvault secret set.

    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. 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 usando el comando az keyvault secret set.

    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. 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 usando el comando az keyvault secret set.

    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. Cree un usuario de supervisión del clúster y administrador secreto de MongoDB para la supervisión del clúster usando el comando 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. Creación de un usuario y una contraseña secreta para la administración de usuarios usando el comando az keyvault secret set.

    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. Cree un secreto para la clave de API que se usa para acceder al servidor de administración y supervisión de Percona (PMM) mediante el comando az keyvault secret set. Actualice el valor de este secreto más adelante al implementar el servidor PMM.

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

  7. Agregue AZURE-STORAGE-ACCOUNT-NAME para usarlos más adelante para las copias de seguridad mediante el comando 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. Ejecute el siguiente comando para actualizar el mongodb.tfvars archivo creado anteriormente con la siguiente configuració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. Aplique la configuración de Terraform al recurso de destino.

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

Crear recursos de 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 de resultado:

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

  2. Cree un recurso de 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
    - secretKey: PMM_SERVER_API_KEY
      remoteRef:
        key: PMM-SERVER-API-KEY
EOF

    Ejemplo de resultado:

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

  3. Cree un recurso de 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 de resultado:

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

  1. 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 none

  2. 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 de resultado:

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

  1. Agregue la siguiente configuración de terraform en mongodb/main.tf para crear una credencial federada.

    ## 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. Agregue la siguiente configuración de terraform en mongodb/main.tf para conceder permiso a la identidad asignada por el usuario para acceder al secreto.

    ## 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. Aplique la configuración de 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

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.

  • Implemente el Percona Operator y las definiciones de recursos personalizados (CRD) mediante el comando 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}"

    Ejemplo de resultado:

    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 el Percona Operator mediante el comando kubectl apply. Para ayudar a garantizar la alta disponibilidad, implemente el clúster de MongoDB con un conjunto de réplicas, con particionamiento habilitado, en varias zonas de disponibilidad y con una solución de copia de seguridad que almacene las copias de seguridad en una cuenta de 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

    Ejemplo de resultado:

    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

  3. Una vez finalizado el proceso, el clúster muestra el estado Ready. Puede ver el estado mediante el comando kubectl get.

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

    Ejemplo de resultado:

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

  4. Vea las zonas de disponibilidad de los nodos del clúster mediante el comando kubectl get.

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

    Ejemplo de resultado:

    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

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 de resultado:

    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 describe secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE}

    Ejemplo de resultado:

    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. Descodifique el nombre de inicio de sesión y la contraseña codificados en Base64 y exporte la cadena de conexión a la variable de entorno mediante los siguientes comandos:

Important

Microsoft recomienda usar el flujo de autenticación más seguro disponible. El flujo de autenticación que se describe en este procedimiento requiere un alto grado de confianza en la aplicación y conlleva riesgos que no están presentes en otros flujos. Solo debe usar este flujo cuando otros flujos más seguros, como las identidades administradas, no sean viables.

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"

Comprobación del clúster de MongoDB

En esta sección, comprobará el clúster de MongoDB mediante la ejecución de un contenedor con un cliente de MongoDB y conectará 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 -- env CONN_STR=$connectionString 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 de resultado:

    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 de la ventana de terminal que usó para crear el pod de percona-client.

    mongosh $CONN_STR

    Ejemplo de resultado:

    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. Enumere las bases de datos del clúster mediante el comando show dbs.

    show dbs

    Ejemplo de resultado:

    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.

El Percona Operator puede realizar cualquiera de los siguientes 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 instrucciones siguientes:

  • 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 instrucciones siguientes:

  • 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 de resultado:

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

  2. Finalice el proceso de implementación de 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 de resultado:

    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 de resultado:

    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 comando kubectl logs.

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

Paso siguiente

implementar una aplicación cliente (Mongo Express)

  • Last updated on