Konfigurace a nasazení clusteru MongoDB ve službě Azure Kubernetes Service (AKS)

V tomto článku nakonfigurujete a nasadíte cluster MongoDB ve službě Azure Kubernetes Service (AKS).

Konfigurujte identitu úlohy

  1. Vytvořte obor názvů pro cluster MongoDB pomocí příkazu kubectl create namespace.

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

    Příklad výstupu:

    namespace/mongodb created

  2. Vytvořte účet služby a pomocí příkazu nakonfigurujte identitu kubectl apply úlohy.

    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

    Příklad výstupu:

    serviceaccount/mongodb created

Zprovoznění aplikace External Secrets Operator

V této části použijete Helm k instalaci External Secrets Operator. Operátor externích tajných kódů je operátor Kubernetes, který spravuje životní cyklus externích tajných kódů uložených v externích úložištích tajných kódů, jako je Azure Key Vault.

  1. Přidejte úložiště Helm pro externí tajemství a aktualizujte úložiště pomocí příkazů helm repo add a helm repo update.

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

    Příklad výstupu:

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

  2. Pomocí příkazu helm install nainstalujte Externí Secrets Operator.

    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

    Příklad výstupu:

    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. Pomocí funkce vygenerujte náhodné heslo:

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

Vytvoření tajných kódů MongoDB

  1. Pomocí příkazu vytvořte tajný údaj uživatele a hesla pro zálohování MongoDB, který se použije pro všechny operace zálohování a obnovení 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. Vytvořte tajemství obsahující uživatelský účet správce databáze MongoDB a heslo pro správu databáze pomocí az keyvault secret set příkazu.

    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. Vytvořte uživatele pro správu clusteru MongoDB a tajný klíč správce pro roli správy clusteru, která poskytuje správu více než jedné databáze pomocí az keyvault secret set příkazu.

    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. Pomocí příkazu vytvořte tajný klíč pro uživatele a správce pro monitorování clusteru MongoDB .

    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. Pomocí příkazu vytvořte tajný kód uživatele a hesla pro správuaz keyvault secret set uživatelů.

    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. Pomocí příkazu az keyvault secret set vytvořte tajemství pro API klíč použitý pro přístup k serveru monitorování a správy (PMM) Percona. Hodnotu tohoto tajného kódu aktualizujete později při nasazení serveru PMM.

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

  7. Přidejte AZURE-STORAGE-ACCOUNT-NAME k pozdějšímu použití pro zálohy pomocí az keyvault secret set příkazu.

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

  1. Spuštěním následujícího příkazu aktualizujte mongodb.tfvars soubor vytvořený dříve pomocí následující konfigurace:

    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. Použijte konfiguraci Terraform na cílový zdroj.

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

Vytváření zdrojů tajných údajů

  1. Pomocí příkazu vytvořte SecretStore prostředek pro přístup k heslům MongoDB uloženým v trezoru kubectl apply klíčů.

    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

    Příklad výstupu:

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

  2. Vytvořte ExternalSecret prostředek pomocí kubectl apply příkazu. Tento prostředek vytvoří tajný klíč Kubernetes v mongodb oboru názvů s tajnými kódy MongoDB uloženými ve vašem trezoru klíčů.

    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

    Příklad výstupu:

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

  3. Vytvořte ExternalSecret prostředek pomocí kubectl apply příkazu. Tento prostředek vytvoří tajný klíč Kubernetes v mongodb oboru názvů pro tajné kódy služby Azure Blob Storage uložené ve vašem trezoru klíčů.

    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

    Příklad výstupu:

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

  1. Pomocí příkazu vytvořte federované přihlašovací údaje 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. Pomocí příkazu az keyvault set-policy udělte identitě přiřazené uživatelem oprávnění k přístupu k tajemství.

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

    Příklad výstupu:

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

  1. Přidáním následující konfigurace terraformu mongodb/main.tf vytvořte federované přihlašovací údaje.

    ## 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. Přidejte následující konfiguraci terraformu do mongodb/main.tf, abyste uživatelem přiřazené identitě umožnili přístup k tajemství.

    ## 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. Použijte konfiguraci terraformu.

        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

Instalace operátoru Percona a CRD

Operátor Percona se obvykle distribuuje jako Kubernetes Deployment nebo Operator. Můžete ho nasadit pomocí kubectl apply -f příkazu se souborem manifestu. Nejnovější manifesty najdete v úložišti Percona Na GitHubu nebo v oficiální dokumentaci.

  • Pomocí příkazu `kubectl apply` nasaďte operátora Percona a definice vlastních prostředků (CRD).

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

    Příklad výstupu:

    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

Nasazení clusteru MongoDB

  1. Nasaďte cluster MongoDB pomocí příkazu kubectl apply s Percona Operator. Abyste zajistili vysokou dostupnost, nasadíte cluster MongoDB se sadou replik, s povoleným horizontálním dělením, ve více zónách dostupnosti a se záložním řešením, které ukládá zálohy do účtu služby 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

    Příklad výstupu:

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

  2. Dokončete proces nasazení clusteru MongoDB pomocí následujícího skriptu:

    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. Po dokončení procesu se v clusteru Ready zobrazí stav. Stav můžete zobrazit pomocí kubectl get příkazu.

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

    Příklad výstupu:

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

  4. Pomocí příkazu zobrazte zóny dostupnosti uzlů ve vašem clusteru kubectl get .

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

    Příklad výstupu:

    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

Připojení k serveru Percona

Pokud se chcete připojit k Serveru Percona pro MongoDB, musíte vytvořit připojovací řetězec URI MongoDB. Obsahuje přihlašovací údaje uživatele správce, které jsou uložené v objektu Secrets .

  1. Secrets Vypíše objekty pomocí kubectl get příkazu.

    kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

    Příklad výstupu:

    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. Zobrazte obsah Secrets, abyste získali přihlašovací údaje uživatele správce pomocí příkazu kubectl get.

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

    Příklad výstupu:

    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. Dekódujte přihlašovací jméno a heslo s kódováním Base64 a exportujte připojovací řetězec do proměnné prostředí pomocí následujících příkazů:

Important

Společnost Microsoft doporučuje používat nejbezpečnější dostupný způsob autentizace. Ověřovací tok popsaný v tomto postupu vyžaduje velmi vysoký stupeň důvěryhodnosti v aplikaci a nese rizika, která nejsou přítomna v jiných tocích. Tento tok byste měli použít jenom v případě, že jiné bezpečnější toky, jako jsou spravované identity, nejsou přijatelné.

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"

Ověření clusteru MongoDB

V této části ověříte cluster MongoDB spuštěním kontejneru s klientem MongoDB a připojením výstupu konzoly k terminálu.

  1. Pomocí příkazu percona-client vytvořte pod s názvem ${AKS_MONGODB_NAMESPACE} v oboru názvů kubectl run ve svém clusteru.

    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. V jiném okně terminálu ověřte, že se pod úspěšně vytvořil pomocí kubectl get příkazu.

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

    Příklad výstupu:

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

  3. Připojte se ke clusteru MongoDB pomocí přihlašovacích údajů uživatele správce z předchozí části okna terminálu, které jste použili k vytvoření podu percona-client .

    mongosh $CONN_STR

    Příklad výstupu:

    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. Pomocí příkazu vypište databáze v clusteru show dbs .

    show dbs

    Příklad výstupu:

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

Vytvoření zálohy MongoDB

Data můžete zálohovat do Azure pomocí jedné z následujících metod:

  • Ruční: Data můžete kdykoli ručně zálohovat.
  • Naplánováno: Nakonfigurujte zálohy a jejich plány v YAML souboru CRD. Operátor Percona provádí zálohy automaticky podle zadaného plánu.

Operátor Percona může provádět některý z následujících typů zálohování:

  • Logické zálohování: Zadejte dotaz na Server Percona pro MongoDB pro data databáze a potom zapište načtená data do vzdáleného úložiště zálohování.
  • Fyzické zálohování: Zkopírujte fyzické soubory z datového adresáře Percona Server for MongoDB dbPath do vzdáleného úložiště zálohování.

Logické zálohy využívají méně úložiště, ale jsou pomalejší než fyzické zálohy.

Pokud chcete ukládat zálohy ve službě Azure Blob Storage pomocí Percona, musíte vytvořit tajný klíč. Tento krok jste dokončili v dřívějším příkazu. Podrobné pokyny najdete v dokumentaci k Percona o službě Azure Blob Storage.

Konfigurace plánovaných záloh

Plán zálohování můžete definovat v části zálohování CRD v mongodb-cr.yaml pomocí následujících doprovodných materiálů:

  • Nastavte klíč backup.enabled na true.
  • Ujistěte se, že backup.storages pododdíl obsahuje alespoň jeden nakonfigurovaný prostředek úložiště.
  • Ujistěte se, že pododdíl backup.tasks umožňuje plánování zálohování.

Další informace naleznete v tématu Vytváření plánovaných záloh.

Provádění ručních záloh

Ruční zálohu na vyžádání můžete provést v sekci zálohování CRD v mongodb-cr.yaml pomocí následující příručky.

  • Nastavte klíč backup.enabled na true.
  • Ujistěte se, že backup.storages pododdíl obsahuje alespoň jeden nakonfigurovaný prostředek úložiště.

Další informace najdete v tématu Vytváření záloh na vyžádání.

Nasazení zálohy MongoDB

  1. Pomocí příkazu nasaďte zálohu kubectl apply MongoDB.

    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

    Příklad výstupu:

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

  2. Dokončete proces nasazení zálohování MongoDB pomocí následujícího skriptu:

    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

    Příklad výstupu:

    waiting for the backup to be ready

  3. Po dokončení procesu by zálohování mělo vrátit Ready stav. Pomocí příkazu ověřte, že nasazení zálohování proběhlo úspěšně kubectl get .

    kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

    Příklad výstupu:

    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. Pokud máte s zálohováním nějaké problémy, můžete pomocí příkazu zobrazit protokoly z backup-agent kontejneru příslušného podu kubectl logs .

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

Další krok

Nasazení klientské aplikace (Mongo Express)

  • Poslední aktualizace v