Configurare e distribuire un cluster MongoDB nel servizio Azure Kubernetes

In questo articolo viene configurato e distribuito un cluster MongoDB nel servizio Azure Kubernetes.

Configurare un'identità del carico di lavoro

Creare uno spazio dei nomi per il cluster MongoDB usando il comando kubectl create namespace.

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

Output di esempio:

namespace/mongodb created

Creare un account del servizio e configurare un'identità del carico di lavoro usando il 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

Output di esempio:

serviceaccount/mongodb created

Installare l'operatore dei segreti esterni

In questa sezione si usa Helm per installare External Secrets Operator. External Secrets Operator è un operatore Kubernetes che gestisce il ciclo di vita dei segreti esterni archiviati in archivi di segreti esterni come Azure Key Vault.

Aggiungere il repository Helm dei segreti esterni e aggiornare il repository usando i comandi helm repo add e helm repo update.

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

Output di esempio:

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

Installare External Secrets Operator usando il 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

Output di esempio:

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

Generare una password casuale usando la funzione :

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

Creare segreti MongoDB

Creare un segreto di tipo utente e password di backup di MongoDB da usare per qualsiasi operazione di backup e ripristino usando il 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

Creare un segreto di tipo utente e password di amministrazione database di MongoDB per l'amministrazione dei database usando il 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

Creare un utente di amministrazione del cluster MongoDB e un segreto amministratore per un ruolo amministrativo del cluster che fornisce amministrazione a più di un database usando il 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

Creare un segreto di tipo utente e amministratore di monitoraggio cluster di MongoDB per il monitoraggio dei cluster usando il 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

Creare un segreto di tipo utente e password per l'amministrazione utenti usando il 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

Creare un segreto per la chiave API usata per accedere al server Percona Monitoring and Management (PMM) usando il comando az keyvault secret set. Il valore di questo segreto viene aggiornato in un secondo momento quando si distribuisce il server PMM.
```
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name PMM-SERVER-API-KEY --value $(openssl rand -base64 32) --output none
```

Aggiungere AZURE-STORAGE-ACCOUNT-NAME per usarlo in un secondo momento per i backup tramite il 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

Eseguire il comando seguente per aggiornare il mongodb.tfvars file creato in precedenza con la configurazione seguente:

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

Applicare la configurazione terraform alla risorsa di destinazione.

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

Creare risorse dei segreti

Creare una risorsa SecretStore per accedere alle password di MongoDB archiviate nell'insieme di credenziali usando il 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

Output di esempio:

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

Creare una risorsa ExternalSecret usando il comando kubectl apply. Questa risorsa crea un segreto di Kubernetes nello spazio dei nomi mongodb con i segreti di MongoDB archiviati nell'insieme di credenziali delle chiavi.

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

Output di esempio:

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

Creare una risorsa ExternalSecret usando il comando kubectl apply. Questa risorsa crea un segreto di Kubernetes nel namespace mongodb per i segreti di Azure Blob Storage archiviati nell'insieme di credenziali delle chiavi.

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

Output di esempio:

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

Creare una credenziale federata usando il 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

Concedere l'autorizzazione all'identità assegnata dall'utente per accedere al segreto usando il 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

Output di esempio:

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

Aggiungere la configurazione di terraform seguente in mongodb/main.tf per creare una credenziale federata.

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

Aggiungere la seguente configurazione di terraform in mongodb/main.tf per concedere all'identità assegnata all'utente l'autorizzazione ad accedere alle informazioni riservate.

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

Applicare la configurazione 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

Installare l'operatore Percona e le Definizioni delle Risorse Personalizzate (CRD)

L'operatore Percona viene in genere distribuito come Kubernetes Deployment o Operator. È possibile distribuirlo usando un comando kubectl apply -f con un file manifesto. È possibile trovare i manifesti più recenti nel repository GitHub di Percona o nella documentazione ufficiale.

Distribuire l'operatore Percona e le definizioni di risorse personalizzate usando il 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}"

Output di esempio:

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

Distribuire il cluster MongoDB

Distribuire un cluster MongoDB con l'operatore Percona usando il comando kubectl apply. Per garantire la disponibilità elevata, distribuire il cluster MongoDB con un set di repliche, con partizionamento orizzontale abilitato, in più zone di disponibilità e con una soluzione di backup che archivia i backup in un account di Archiviazione BLOB di Azure.

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

Output di esempio:

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

Completare il processo di distribuzione del cluster MongoDB usando lo script seguente:

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

Al termine del processo, il cluster mostra lo stato Ready. È possibile visualizzare lo stato usando il comando kubectl get.

kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

Output di esempio:

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

Visualizzare le zone di disponibilità dei nodi nel cluster usando il comando kubectl get.

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

Output di esempio:

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

Connettersi al server Percona

Per connettersi al server Percona per MongoDB, è necessario costruire la stringa dell'URI di connessione di MongoDB. Include le credenziali dell'utente amministratore, archiviate nell'oggetto Secrets.

Elencare gli Secrets oggetti usando il comando kubectl get.

kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

Output di esempio:

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

Visualizzare i contenuti Secrets per recuperare le credenziali utente amministratore usando il comando kubectl get.

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

Output di esempio:

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

Decodificare il nome e la password dell'account di accesso con codifica Base64 ed esportare la stringa di connessione nella variabile di ambiente usando i comandi seguenti:

Important

Microsoft consiglia di usare il flusso di autenticazione più sicuro disponibile. Il flusso di autenticazione descritto in questa procedura richiede un livello di attendibilità molto elevato nell'applicazione e comporta rischi che non sono presenti in altri flussi. Si consiglia di usare questo flusso solo quando altri flussi più sicuri, come le identità gestite, non sono validi.

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"

Verificare il cluster MongoDB

In questa sezione si verifica il cluster MongoDB eseguendo un contenitore con un client MongoDB e si connette il rispettivo output della console al terminale.

Creare un pod denominato percona-client nello spazio dei nomi ${AKS_MONGODB_NAMESPACE} nel cluster usando il 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

In un'altra finestra del terminale verificare che il pod sia stato creato correttamente usando il comando kubectl get.

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

Output di esempio:

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

Connettersi al cluster MongoDB usando le credenziali utente amministratore della sezione precedente nella finestra del terminale usata per creare il pod percona-client.

mongosh $CONN_STR

Output di esempio:

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/
...

Elencare i database nel cluster usando il comando show dbs.

show dbs

Output di esempio:

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

Creare un backup di MongoDB

È possibile eseguire il backup dei dati in Azure usando uno dei metodi seguenti:

Manuale: eseguire manualmente il backup dei dati in qualsiasi momento.
Pianificato: configurare i backup e le relative pianificazioni in YAML CRD. L'operatore Percona esegue automaticamente i backup in base alla pianificazione specificata.

L'operatore Percona può eseguire uno dei tipi di backup seguenti:

Backup logico: eseguire query sul server Percona per MongoDB per ottenere i dati del database e quindi scrivere i dati recuperati nell'archivio di backup remoto.
Backup fisico: copiare i file fisici dalla directory dei dati del server Percona per MongoDB dbPath all'archiviazione di backup remoto.

I backup logici usano meno spazio di archiviazione, ma sono più lenti rispetto ai backup fisici.

Per archiviare i backup in Archiviazione BLOB di Azure usando Percona, è necessario creare un segreto. Questo passaggio è stato completato in un comando precedente. Per istruzioni dettagliate, seguire la procedura descritta nella documentazione di Percona su Archiviazione BLOB di Azure.

Configurare backup pianificati

È possibile definire la pianificazione del backup nella sezione relativa al backup di CRD in mongodb-cr.yaml usando le indicazioni seguenti:

Impostare la chiave backup.enabled su true.
Assicurarsi che la sottosezione backup.storages contenga almeno una risorsa di archiviazione configurata.
Assicurarsi che la sottosezione backup.tasks consenta la pianificazione dei backup.

Per altre informazioni, vedere Creazione di backup pianificati.

Eseguire backup manuali

È possibile eseguire un backup manuale su richiesta nella sezione relativa al backup di CRD in mongodb-cr.yaml usando le indicazioni seguenti:

Impostare la chiave backup.enabled su true.
Assicurarsi che la sottosezione backup.storages contenga almeno una risorsa di archiviazione configurata.

Per altre informazioni, vedere Creazione di backup su richiesta.

Distribuire un backup di MongoDB

Distribuire il backup di MongoDB usando il 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

Output di esempio:

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

Completare il processo di distribuzione del backup di MongoDB usando lo script seguente:

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

Output di esempio:

waiting for the backup to be ready

Al termine del processo, il backup deve restituire lo stato Ready. Verificare che la distribuzione del backup abbia avuto esito positivo usando il comando kubectl get.

kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

Output di esempio:

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

Se si verificano problemi relativi al backup, è possibile visualizzare i log dal contenitore backup-agent del pod appropriato usando il comando kubectl logs.
```
kubectl logs pod/${AKS_MONGODB_CLUSTER_NAME}-rs0-0 -c backup-agent -n ${AKS_MONGODB_NAMESPACE}
```

Passo successivo

Distribuire un'applicazione client (Mongo Express)

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-09-22

Condividi tramite

Configurare e distribuire un cluster MongoDB nel servizio Azure Kubernetes

Configurare un'identità del carico di lavoro

Installare l'operatore dei segreti esterni

Creare segreti MongoDB

Creare risorse dei segreti

Installare l'operatore Percona e le Definizioni delle Risorse Personalizzate (CRD)

Distribuire il cluster MongoDB

Connettersi al server Percona

Verificare il cluster MongoDB

Creare un backup di MongoDB

Configurare backup pianificati

Eseguire backup manuali

Distribuire un backup di MongoDB

Passo successivo

Commenti e suggerimenti

Risorse aggiuntive