Een MongoDB-cluster configureren en implementeren in Azure Kubernetes Service (AKS)

In dit artikel configureert en implementeert u een MongoDB-cluster in Azure Kubernetes Service (AKS).

Een workloadidentiteit configureren

Maak een naamruimte voor het MongoDB-cluster met behulp van de kubectl create namespace opdracht.

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

Voorbeelduitvoer:

namespace/mongodb created

Maak een serviceaccount en configureer een workloadidentiteit met behulp van de kubectl apply opdracht.

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

Voorbeelduitvoer:

serviceaccount/mongodb created

External Secrets Operator installeren

In deze sectie gebruikt u Helm om External Secrets Operator te installeren. External Secrets Operator is een Kubernetes-operator die de levenscyclus beheert van externe geheimen die zijn opgeslagen in externe geheime archieven, zoals Azure Key Vault.

Voeg de Helm-opslagplaats voor externe geheimen toe en werk de opslagplaats bij met behulp van de helm repo add en helm repo update opdrachten.

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

Voorbeelduitvoer:

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

Installeer de operator Externe geheimen met behulp van de helm install opdracht.

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

Voorbeelduitvoer:

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

Genereer een willekeurig wachtwoord met behulp van de functie:

#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-geheimen maken

Maak een MongoDB-back-upgebruikersgegevens en wachtwoord aan voor back-up- en herstelbewerkingen met behulp van het az keyvault secret set commando.

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

Maak een MongoDB-databasebeheerder account en wachtwoordgeheim voor databasebeheer met behulp van de az keyvault secret set opdracht.

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

Maak een MongoDB-clusterbeheergebruiker en een admin-geheime sleutel voor een clusteradministratierol die beheer biedt voor meer dan één database met behulp van de az keyvault secret set opdracht.

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

Maak een MongoDB-gebruikers- en beheerdersgeheime sleutel voor clusterbewaking met behulp van de az keyvault secret set opdracht.

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

Maak een gebruikers- en wachtwoordgeheim voor gebruikersbeheer met behulp van de az keyvault secret set opdracht.

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

Maak een geheim voor de API-sleutel die wordt gebruikt voor toegang tot de PMM-server (Percona Monitoring and Management) met behulp van de az keyvault secret set opdracht. U werkt de waarde van dit geheim later bij wanneer u de PMM-server implementeert.
```
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name PMM-SERVER-API-KEY --value $(openssl rand -base64 32) --output none
```

Voeg AZURE-STORAGE-ACCOUNT-NAME dit toe om later te gebruiken voor back-ups met behulp van de az keyvault secret set opdracht.

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

Voer de volgende opdracht uit om het mongodb.tfvars bestand dat u eerder hebt gemaakt bij te werken met de volgende configuratie:

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

Pas de terraform-configuratie toe op de doelresource.

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

Bronnen voor geheimen aanmaken

Maak een SecretStore resource voor toegang tot de MongoDB-wachtwoorden die zijn opgeslagen in uw sleutelkluis met behulp van de kubectl apply opdracht.

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

Voorbeelduitvoer:

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

Maak een ExternalSecret resource met behulp van de kubectl apply opdracht. Deze resource maakt een Kubernetes-geheim in de mongodb naamruimte met de MongoDB-geheimen die zijn opgeslagen in uw sleutelkluis.

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

Voorbeelduitvoer:

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

Maak een ExternalSecret resource met behulp van de kubectl apply opdracht. Met deze resource maakt u een Kubernetes-geheim in de mongodb naamruimte voor Azure Blob Storage-geheimen die zijn opgeslagen in uw sleutelkluis.

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

Voorbeelduitvoer:

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

Maak een federatieve referentie met behulp van de az identity federated-credential create opdracht.

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

Geef toestemming voor de door de gebruiker toegewezen identiteit om toegang te krijgen tot het geheim met behulp van de az keyvault set-policy opdracht.

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

Voorbeelduitvoer:

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

Voeg de volgende terraform-configuratie toe mongodb/main.tf om een federatieve referentie te maken.

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

Voeg de volgende terraform-configuratie toe mongodb/main.tf om de door de gebruiker toegewezen identiteit toegang te geven tot het geheim.

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

Pas de Terraform-configuratie toe.

    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

De Percona Operator en CRD's installeren.

De Percona-operator wordt doorgaans gedistribueerd als een Kubernetes Deployment of Operator. U kunt deze implementeren met behulp van een kubectl apply -f opdracht met een manifestbestand. U vindt de meest recente manifesten in de Percona GitHub-opslagplaats of de officiële documentatie.

Implementeer de Percona-operator en aangepaste resourcedefinities (CRD's) met behulp van de kubectl apply opdracht.

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

Voorbeelduitvoer:

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

Het MongoDB-cluster implementeren

Implementeer een MongoDB-cluster met de Percona-operator met behulp van de kubectl apply opdracht. Om hoge beschikbaarheid te garanderen, implementeert u het MongoDB-cluster met een replicaset, waarbij sharding is ingeschakeld, in meerdere beschikbaarheidszones en met een back-upoplossing waarmee de back-ups in een Azure Blob Storage-account worden opgeslagen.

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

Voorbeelduitvoer:

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

Voltooi het mongoDB-clusterimplementatieproces met behulp van het volgende 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

Wanneer het proces is voltooid, wordt in het cluster de Ready status weergegeven. U kunt de status weergeven met behulp van de kubectl get opdracht.

kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

Voorbeelduitvoer:

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

Bekijk de beschikbaarheidszones van de knooppunten in uw cluster met behulp van de kubectl get opdracht.

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

Voorbeelduitvoer:

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

Verbinding maken met de Percona-server

Als u verbinding wilt maken met Percona Server voor MongoDB, moet u de MongoDB-verbindings-URI-tekenreeks maken. Het bevat de referenties van de gebruiker met beheerdersrechten die zijn opgeslagen in het Secrets object.

Geef de Secrets objecten weer met behulp van de kubectl get opdracht.

kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

Voorbeelduitvoer:

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

Bekijk de Secrets inhoud om de gebruikersreferenties van de beheerder op te halen met behulp van de kubectl get opdracht.

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

Voorbeelduitvoer:

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

Decoderen van de met Base64 gecodeerde aanmeldingsnaam en het wachtwoord en exporteer de verbindingsreeks naar de omgevingsvariabele met behulp van de volgende opdrachten:

Important

Microsoft raadt u aan de veiligste verificatiestroom te gebruiken die beschikbaar is. De verificatiestroom die in deze procedure wordt beschreven, vereist een zeer hoge mate van vertrouwen in de toepassing en brengt risico's met zich mee die niet aanwezig zijn in andere stromen. U moet deze stroom alleen gebruiken wanneer andere veiligere stromen, zoals beheerde identiteiten, niet haalbaar zijn.

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"

Het MongoDB-cluster controleren

In deze sectie controleert u uw MongoDB-cluster door een container uit te voeren met een MongoDB-client en de console-uitvoer te verbinden met uw terminal.

Maak een pod met de naam percona-client onder de ${AKS_MONGODB_NAMESPACE} naamruimte in uw cluster met behulp van de kubectl run opdracht.

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

Controleer in een ander terminalvenster of de pod is gemaakt met behulp van de kubectl get opdracht.

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

Voorbeelduitvoer:

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

Maak verbinding met het MongoDB-cluster met behulp van de gebruikersreferenties van de beheerder uit de vorige sectie in het terminalvenster dat u hebt gebruikt om de percona-client pod te maken.

mongosh $CONN_STR

Voorbeelduitvoer:

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

Geef de databases in uw cluster weer met behulp van de show dbs opdracht.

show dbs

Voorbeelduitvoer:

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

Een MongoDB-back-up maken

U kunt een back-up maken van uw gegevens naar Azure met behulp van een van de volgende methoden:

Handmatig: maak op elk gewenst moment handmatig een back-up van uw gegevens.
Gepland: configureer back-ups en hun planningen in de CRD YAML. De Percona-operator maakt de back-ups automatisch volgens het opgegeven schema.

De Percona-operator kan een van de volgende back-uptypen uitvoeren:

Logische back-up: Voer een query uit op Percona Server voor MongoDB voor de databasegegevens en schrijf vervolgens de opgehaalde gegevens naar de externe back-upopslag.
Fysieke back-up: kopieer fysieke bestanden van de Percona-server voor MongoDB-gegevensmap dbPath naar de externe back-upopslag.

Logische back-ups gebruiken minder opslag, maar zijn langzamer dan fysieke back-ups.

Als u back-ups wilt opslaan in Azure Blob Storage met behulp van Percona, moet u een geheim maken. U hebt deze stap in een eerdere opdracht voltooid. Volg de stappen in de Percona-documentatie over Azure Blob Storage voor gedetailleerde instructies.

Geplande back-ups configureren

U kunt het back-upschema definiëren in de back-upsectie van de CRD in mongodb-cr.yaml met behulp van de volgende richtlijnen:

Stel de backup.enabled-sleutel in op true.
Zorg ervoor dat de backup.storages subsectie ten minste één geconfigureerde opslagresource bevat.
Zorg ervoor dat de backup.tasks subsectie de mogelijkheid om een back-upplanning in te stellen inschakelt.

Zie Geplande back-ups maken voor meer informatie.

Handmatige back-ups uitvoeren

U kunt een handmatige, on-demand back-up maken in de back-upsectie van de CRD in mongodb-cr.yaml met behulp van de volgende richtlijnen:

Stel de backup.enabled-sleutel in op true.
Zorg ervoor dat de backup.storages subsectie ten minste één geconfigureerde opslagresource bevat.

Zie Back-ups op aanvraag maken voor meer informatie.

Een MongoDB-back-up implementeren

Implementeer uw MongoDB-back-up met behulp van de kubectl apply opdracht.

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

Voorbeelduitvoer:

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

Voltooi het mongoDB-back-upimplementatieproces met behulp van het volgende 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

Voorbeelduitvoer:

waiting for the backup to be ready

Wanneer het proces is voltooid, moet de back-up de Ready status retourneren. Controleer of de back-upimplementatie is geslaagd met behulp van de kubectl get opdracht.

kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

Voorbeelduitvoer:

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

Als u problemen ondervindt met de back-up, kunt u logboeken bekijken vanuit de backup-agent container van de juiste pod met behulp van de kubectl logs opdracht.
```
kubectl logs pod/${AKS_MONGODB_CLUSTER_NAME}-rs0-0 -c backup-agent -n ${AKS_MONGODB_NAMESPACE}
```

Volgende stap

Een clientapplicatie deployen (Mongo Express)

Feedback

Is deze pagina nuttig?

Last updated on 2025-09-22

Delen via

Een MongoDB-cluster configureren en implementeren in Azure Kubernetes Service (AKS)

Een workloadidentiteit configureren

External Secrets Operator installeren

MongoDB-geheimen maken

Bronnen voor geheimen aanmaken

De Percona Operator en CRD's installeren.

Het MongoDB-cluster implementeren

Verbinding maken met de Percona-server

Het MongoDB-cluster controleren

Een MongoDB-back-up maken

Geplande back-ups configureren

Handmatige back-ups uitvoeren

Een MongoDB-back-up implementeren

Volgende stap

Feedback

Aanvullende resources