Udostępnij przez

Konfigurowanie i wdrażanie klastra bazy danych MongoDB w usłudze Azure Kubernetes Service (AKS)

W tym artykule skonfigurujesz i wdrożysz klaster bazy danych MongoDB w usłudze Azure Kubernetes Service (AKS).

Konfiguracja tożsamości zadania

  1. Utwórz przestrzeń nazw dla klastra Bazy danych MongoDB przy użyciu kubectl create namespace polecenia .

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

    Przykładowy wynik:

    namespace/mongodb created

  2. Utwórz konto usługi i skonfiguruj tożsamość dla obciążenia przy użyciu polecenia 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

    Przykładowy wynik:

    serviceaccount/mongodb created

Instalacja External Secrets Operator

W tej sekcji użyjesz Helm do zainstalowania External Secrets Operator. Operator Zewnętrznych Tajemnic to Operator Kubernetes, który zarządza cyklem życia tajemnic przechowywanych w zewnętrznych repozytoriach tajemnic, takich jak Azure Key Vault.

  1. Dodaj repozytorium Helm Zewnętrznych Sekretów i zaktualizuj repozytorium przy użyciu poleceń helm repo add i helm repo update.

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

    Przykładowy wynik:

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

  2. Zainstaluj Operator zewnętrznych wpisów tajnych przy użyciu polecenia 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

    Przykładowy wynik:

    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. Wygeneruj losowe hasło przy użyciu funkcji :

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

Utwórz sekrety MongoDB

  1. Utwórz tajny użytkownika i hasła kopii zapasowej MongoDB do użycia podczas operacji tworzenia i przywracania kopii zapasowych z wykorzystaniem polecenia 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. Utwórz sekretny wpis danych użytkownika administratora bazy danych i hasła dla administracji bazą MongoDB przy użyciu polecenia az keyvault secret set.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-DATABASE-ADMIN-USER --value MONGODB_DATABASE_ADMIN_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-DATABASE-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output none

  3. Utwórz użytkownika administracyjnego klastra MongoDB i tajemnicę administratora dla roli administracyjnej klastra, która umożliwia zarządzanie wieloma bazami danych przy użyciu az keyvault secret set polecenia.

    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. Utwórz sekret "użytkownika monitorowania klastra" oraz "admina" do monitorowania klastra bazy danych MongoDB przy użyciu polecenia .

    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. Utwórz sekret użytkownika oraz hasła do administrowania użytkownikami przy użyciu polecenia az keyvault secret set.

    az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-USER-ADMIN-USER --value MONGODB_USER_ADMIN_USER --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-USER-ADMIN-PASSWORD --value $(generateRandomPasswordString) --output none

  6. Utwórz sekret dla klucza API używanego do uzyskiwania dostępu do serwera Percona Monitoring and Management (PMM) za pomocą polecenia az keyvault secret set. Zaktualizujesz wartość tego sekretu później, podczas wdrażania serwera PMM.

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

  7. Dodaj AZURE-STORAGE-ACCOUNT-NAME do późniejszego użycia w kopiach zapasowych, korzystając z polecenia az keyvault secret set.

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

  1. Uruchom następujące polecenie, aby zaktualizować mongodb.tfvars utworzony wcześniej plik przy użyciu następującej konfiguracji:

    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. Zastosuj konfigurację Terraform do docelowego zasobu.

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

Tworzenie zasobów wpisów tajnych

  1. Utwórz zasób SecretStore aby uzyskać dostęp do haseł MongoDB przechowywanych w magazynie kluczy przy użyciu polecenia 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

    Przykładowy wynik:

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

  2. Utwórz zasób ExternalSecret za pomocą polecenia kubectl apply Ten zasób tworzy tajny Kubernetes w przestrzeni nazw mongodb z tajnymi danymi MongoDB przechowywanymi w magazynie kluczy.

    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

    Przykładowy wynik:

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

  3. Utwórz zasób ExternalSecret za pomocą polecenia kubectl apply Ten zasób tworzy tajemnicę Kubernetes w przestrzeni nazw mongodb dla tajemnic dotyczących Azure Blob Storage przechowywanych w twoim magazynie kluczy.

    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

    Przykładowy wynik:

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

  1. Utwórz poświadczenia federacyjne za pomocą polecenia 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. Nadaj uprawnienia tożsamości przypisanej przez użytkownika, aby uzyskać dostęp do sekretu za pomocą polecenia az keyvault set-policy.

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

    Przykładowy wynik:

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

  1. Dodaj następującą konfigurację terraform w mongodb/main.tf aby utworzyć poświadczenia federacyjne.

    ## 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. Dodaj następującą konfigurację narzędzia terraform w mongodb/main.tf, aby udzielić uprawnień tożsamości przypisanej przez użytkownika do uzyskania dostępu do tajemnicy.

    ## 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. Zastosuj konfigurację 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

Instalowanie operatorów Percona i CRD

Percona Operator jest zwykle rozprowadzany jako operator Kubernetes Deployment lub Operator. Można go wdrożyć przy użyciu kubectl apply -f polecenia z plikiem manifestu. Najnowsze manifesty można znaleźć w repozytorium Percona GitHub lub oficjalnej dokumentacji.

  • Wdróż Operator Percona i niestandardowe definicje zasobów (CRD) przy użyciu polecenia 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}"

    Przykładowy wynik:

    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

Wdrażanie klastra bazy danych MongoDB

  1. Wdróż klaster Bazy danych MongoDB za pomocą operatora Percona przy użyciu kubectl apply polecenia . Aby zapewnić wysoką dostępność, należy wdrożyć klaster Bazy danych MongoDB z zestawem replik z włączonym fragmentowaniem, w wielu strefach dostępności i rozwiązaniem do tworzenia kopii zapasowych, które przechowuje kopie zapasowe na koncie usługi 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

    Przykładowy wynik:

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

  2. Zakończ proces wdrażania klastra MongoDB przy użyciu następującego skryptu:

    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 zakończeniu procesu klaster pokazuje status Ready. Stan można wyświetlić przy użyciu kubectl get polecenia .

    kubectl get psmdb -n ${AKS_MONGODB_NAMESPACE}

    Przykładowy wynik:

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

  4. Wyświetl strefy dostępności węzłów w klastrze przy użyciu kubectl get polecenia .

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

    Przykładowy wynik:

    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

Nawiązywanie połączenia z serwerem Percona

Aby nawiązać połączenie z Percona Server for MongoDB, należy skonstruować ciąg URI połączenia MongoDB. Zawiera poświadczenia użytkownika administratora, które są przechowywane w Secrets obiekcie.

  1. Secrets Wyświetl listę obiektów przy użyciu kubectl get polecenia .

    kubectl get secrets -n ${AKS_MONGODB_NAMESPACE}

    Przykładowy wynik:

    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. Wyświetl zawartość Secrets aby pobrać poświadczenia użytkownika administratora przy użyciu polecenia kubectl get.

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

    Przykładowy wynik:

    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. Zdekoduj zakodowaną w formacie Base64 nazwę logowania i hasło i wyeksportuj parametry połączenia do zmiennej środowiskowej przy użyciu następujących poleceń:

Important

Firma Microsoft zaleca korzystanie z najbezpieczniejszego dostępnego przepływu uwierzytelniania. Przepływ uwierzytelniania opisany w tej procedurze wymaga bardzo wysokiego poziomu zaufania w aplikacji i niesie ze sobą ryzyko, które nie występują w innych przepływach. Tego przepływu należy używać tylko wtedy, gdy inne bezpieczniejsze przepływy, takie jak tożsamości zarządzane, nie są opłacalne.

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"

Weryfikowanie klastra bazy danych MongoDB

W tej sekcji zweryfikujesz klaster bazy danych MongoDB, uruchamiając kontener z klientem bazy danych MongoDB i połączysz dane wyjściowe konsoli z terminalem.

  1. Utwórz pod o nazwie percona-client w przestrzeni nazw ${AKS_MONGODB_NAMESPACE} w swoim klastrze przy użyciu polecenia kubectl run.

    kubectl -n "${AKS_MONGODB_NAMESPACE}" run -i --rm --tty percona-client --image=${MY_ACR_REGISTRY}.azurecr.io/percona-server-mongodb:7.0.8-5 --restart=Never -- env CONN_STR=$connectionString bash -il

  2. W innym oknie terminalu sprawdź, czy pod został pomyślnie utworzony przy użyciu polecenia kubectl get.

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

    Przykładowy wynik:

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

  3. Połącz się z klastrem MongoDB używając poświadczeń użytkownika admin z poprzedniego działu w oknie terminalu, które było użyte do utworzenia zasobnika percona-client.

    mongosh $CONN_STR

    Przykładowy wynik:

    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. Wyświetl listę baz danych w klastrze przy użyciu show dbs polecenia .

    show dbs

    Przykładowy wynik:

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

Tworzenie kopii zapasowej bazy danych MongoDB

Możesz utworzyć kopię zapasową danych na platformie Azure przy użyciu jednej z następujących metod:

  • Ręczne: ręczne tworzenie kopii zapasowych danych w dowolnym momencie.
  • Zaplanowane: Skonfiguruj kopie zapasowe i ich harmonogramy w YAML CRD. Operator percona tworzy kopie zapasowe automatycznie zgodnie z określonym harmonogramem.

Operator percona może wykonywać jedną z następujących typów kopii zapasowych:

  • Kopia zapasowa logiczna: wykonaj zapytanie względem serwera Percona Server for MongoDB dla danych bazy danych, a następnie zapisz pobrane dane w zdalnym magazynie kopii zapasowych.
  • Kopia zapasowa fizyczna: skopiuj pliki fizyczne z katalogu danych Programu Percona Server for MongoDB dbPath do zdalnego magazynu kopii zapasowych.

Kopie zapasowe logiczne używają mniejszej ilości miejsca do magazynowania, ale są wolniejsze niż fizyczne kopie zapasowe.

Aby przechowywać kopie zapasowe w Azure Blob Storage za pomocą Percona, musisz utworzyć sekret. Ten krok został ukończony we wcześniejszym poleceniu. Aby uzyskać szczegółowe instrukcje, wykonaj kroki opisane w dokumentacji narzędzia Percona dotyczącej usługi Azure Blob Storage.

Konfigurowanie zaplanowanych kopii zapasowych

Harmonogram tworzenia kopii zapasowych można zdefiniować w sekcji kopii zapasowej crD w pliku mongodb-cr.yaml , korzystając z poniższych wskazówek:

  • Ustaw klucz backup.enabled na wartość true.
  • Upewnij się, że podsekcja backup.storages zawiera co najmniej jeden skonfigurowany zasób pamięci masowej.
  • Upewnij się, że podsekcja backup.tasks umożliwia planowanie kopii zapasowych.

Aby uzyskać więcej informacji, zobacz Tworzenie zaplanowanych kopii zapasowych.

Wykonywanie ręcznych kopii zapasowych

Możesz utworzyć ręczną kopię zapasową na żądanie w sekcji kopii zapasowej crD w pliku mongodb-cr.yaml , korzystając z poniższych wskazówek:

  • Ustaw klucz backup.enabled na wartość true.
  • Upewnij się, że podsekcja backup.storages zawiera co najmniej jeden skonfigurowany zasób pamięci masowej.

Aby uzyskać więcej informacji, zobacz Tworzenie kopii zapasowych na żądanie.

Wdrażanie kopii zapasowej bazy danych MongoDB

  1. Wdróż kopię zapasową kubectl apply bazy danych MongoDB przy użyciu polecenia .

    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

    Przykładowy wynik:

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

  2. Zakończ proces wdrażania kopii zapasowej bazy danych MongoDB przy użyciu następującego skryptu:

    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

    Przykładowy wynik:

    waiting for the backup to be ready

  3. Po zakończeniu procesu, kopia zapasowa powinna zwrócić status Ready. Sprawdź, czy wdrożenie kopii zapasowej zakończyło się pomyślnie, używając kubectl get polecenia .

    kubectl get psmdb-backup -n ${AKS_MONGODB_NAMESPACE}

    Przykładowy wynik:

    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. Jeśli masz problemy z kopią zapasową, możesz wyświetlić dzienniki z kontenera odpowiedniego podu przy użyciu polecenia backup-agent.

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

Następny krok

Wdrażanie aplikacji klienckiej (Mongo Express)

  • Last updated on