Delen via

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

  • Artikel

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

Een workloadidentiteit configureren

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

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

Externe geheimen-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.

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

  2. 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"=userpool

    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

  3. Genereer een willekeurig wachtwoord voor het MongoDB-cluster en sla het op in Azure Key Vault met behulp van de az keyvault secret set opdracht.

    #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

  1. Maak een MongoDB-back-upgeheim en wachtwoordgeheim voor back-up- en herstelbewerkingen met behulp van de az keyvault secret set opdracht.

    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

  2. Maak een mongoDB-databasebeheerder 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 table
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-DATABASE-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output table

  3. Maak een MongoDB-clusterbeheergeheim voor een clusterbeheerrol 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 table
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output table

  4. Maak een MongoDB-clusterbewakingsgeheim 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 table
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CLUSTER-MONITOR-PASSWORD --value $(generateRandomPasswordString) --output table

  5. 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 table
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-USER-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output table

  6. 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 table

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

Geheimenbronnen maken

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

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

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

  4. 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 table

    Voorbeelduitvoer:

    Issuer                                                                                                                   Name                      ResourceGroup                     Subject
-----------------------------------------------------------------------------------------------------------------------  ------------------------  --------------------------------  -------------------------------------
https://australiaeast.oic.prod-aks.azure.com/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/a0a0a0a0-bbbb-cccc-dddd-e1e1e1e1e1e1/  external-secret-operator  myResourceGroup-rg-australiaeast  system:serviceaccount:mongodb:mongodb

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

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

  1. 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: "userpool"
      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: "userpool"		 
        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: "userpool"
        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: "userpool"
      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: "userpool"
      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

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

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

  4. 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-systempool-30094695-vmss000000    australiaeast-1
aks-nodepool1-28994785-vmss000000     australiaeast-1
aks-nodepool1-28994785-vmss000001     australiaeast-2
aks-nodepool1-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.

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

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

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

    Voorbeelduitvoer:

    apiVersion: v1
data:
MONGODB_BACKUP_PASSWORD: aB1cD2eF-3gH...
MONGODB_BACKUP_USER: cD2eF3gH4iJ...
MONGODB_CLUSTER_ADMIN_PASSWORD: eF3gH4iJ5kL6mN7oP...
MONGODB_CLUSTER_ADMIN_USER: gH4iJ5kL6mN7oP8...
MONGODB_CLUSTER_MONITOR_PASSWORD: iJ5kL6mN7oP8qR9sT0-u...
MONGODB_CLUSTER_MONITOR_USER: kL6mN7oP8qR9sT0...
MONGODB_DATABASE_ADMIN_PASSWORD: mN7oP8qR9sT0uV1...
MONGODB_DATABASE_ADMIN_USER: A1bC2dE3fH4iJ5kL...
MONGODB_USER_ADMIN_PASSWORD: C2dE3fH4iJ5kL6mN7oP...
MONGODB_USER_ADMIN_USER: E3fH4iJ5kL6mN7...
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: aB1cD2eF-3gH4iJ5kL6-mN7oP8qR=
creationTimestamp: "2024-07-01T12:24:38Z"
labels:
    reconcile.external-secrets.io/created-by: N7oP8qR9sT0uV1wX2yZ3aB4cD5eF6g
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: aaaaaaaa-0b0b-1c1c-2d2d-333333333333
resourceVersion: "1872"
uid: bbbbbbbb-1c1c-2d2d-3e3e-444444444444
type: Opaque

  3. Decoderen van de met Base64 gecodeerde aanmeldingsnaam en het wachtwoord uit de uitvoer met behulp van de volgende opdrachten:

    #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

    Voorbeelduitvoer:

    MONGODB_DATABASE_ADMIN_USER
gH4iJ5kL6mN7oP8...
cluster-aks-mongodb

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.

  1. 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 -- bash -il

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

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

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

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

  4. 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 back-upplanning 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

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

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

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

  4. 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 clienttoepassing implementeren (Mongo Express)