Wdrażanie aplikacji klienckiej w celu nawiązania połączenia z klastrem Bazy danych MongoDB w usłudze Azure Kubernetes Service (AKS)

Po wdrożeniu klastra Bazy danych MongoDB w usłudze AKS możesz wdrożyć przykładową aplikację kliencką w celu interakcji z bazą danych MongoDB. Ten samouczek opiera się na wdrożeniu klastra MongoDB omówionego w poprzednich przewodnikach.

Nawiązywanie połączenia z powłoką bazy danych MongoDB

W tej sekcji nawiąż połączenie z powłoką bazy danych MongoDB. Po nawiązaniu połączenia utworzysz bazę danych i kolekcję, wstawisz dane i uruchomisz zapytania.

Utwórz zasobnik o nazwie percona-client w ${AKS_MONGODB_NAMESPACE} przestrzeni nazw w klastrze przy użyciu kubectl run polecenia . Upewnij się, że przekazujesz poprawną $connectionString zmienną środowiskową wyeksportowaną z kroku 3 poprzedniego samouczka.
```
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 
```
Połącz się z powłoką bazy danych MongoDB przy użyciu następującego polecenia.
```
mongosh $CONN_STR
```

W powłoce bazy danych MongoDB utwórz bazę danych i kolekcję przy użyciu następującego skryptu:

// Connect to MongoDB
use employeeDB;

// Create the employees collection and insert 200 records
for (let i = 1; i <= 200; i++) {
    db.employees.insertOne({
        Id: i,
        EmployeeId: `E${1000 + i}`,
        FirstName: `FirstName${i}`,
        LastName: `LastName${i}`,
        Department: `Department${(i % 10) + 1}`
    });
}

W powłoce bazy danych MongoDB można wykonywać różne zapytania w kolekcji employees . Następujące polecenia pokazują przykładowe zapytania, które można uruchomić:

# Find all employees
db.employees.find().pretty();

# Find an employee by EmployeeId
db.employees.find({ EmployeeId: "E1001" }).pretty();

# Find employees in a specific department
db.employees.find({ Department: "Department1" }).pretty();

# Count the number of employees in a specific department
db.employees.countDocuments({ Department: "Department1" });

# Count the total number of records in the employee collection
db.employees.countDocuments();

Tworzenie i aktualizowanie wpisów tajnych

Aby wdrożyć aplikację mongo-express kliencka, należy najpierw utworzyć wpisy tajne specyficzne dla mongo-express usługi Azure Key Vault i zaktualizować magazyn wpisów tajnych utworzony w poprzednim samouczku.

Wygeneruj losowe hasło przy użyciu funkcji :

#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 podstawową mongo-express nazwę użytkownika i klucz tajny uwierzytelniania, który ma być używany do logowania się do aplikacji klienckiej przy użyciu az keyvault secret set poleceń:

az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGOEXPRESS-CONFIG-BASICAUTH-USERNAME --value MONGOEXPRESSADMINUSER  --output none
az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGOEXPRESS-CONFIG-BASICAUTH-PASSWORD --value $(generateRandomPasswordString) --output none

Utwórz wpis tajny dla mongo-express szczegółów serwera konfiguracji przy użyciu az keyvault secret set polecenia .

az keyvault secret set --vault-name $MY_KEYVAULT_NAME --name MONGODB-CONFIG-SERVER --value ${MY_CLUSTER_NAME}-${AKS_MONGODB_NAMESPACE}-mongos.mongodb.svc.cluster.local --output none

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

sed -i '/mongodb_kv_secrets = {/,/^ *}/s/^ *}/  MONGOEXPRESS-CONFIG-BASICAUTH-USERNAME = "'"$(generateRandomPasswordString)"'"\
MONGOEXPRESS-CONFIG-BASICAUTH-PASSWORD = "'"$(generateRandomPasswordString)"'"\
MONGODB-CONFIG-SERVER = "'"$MY_CLUSTER_NAME-$AKS_MONGODB_NAMESPACE-mongos.mongodb.svc.cluster.local"'"\
}/' mongodb.tfvars

Zastosuj konfigurację narzędzia terraform do zasobu docelowego.

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

Zaktualizuj wpisy tajne w magazynie wpisów tajnych utworzonych w poprzednim samouczku przy użyciu kubectl apply polecenia .

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 KV (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
    - secretKey: MONGOEXPRESS_CONFIG_BASICAUTH_USERNAME
      remoteRef:
        key: MONGOEXPRESS-CONFIG-BASICAUTH-USERNAME
    - secretKey: MONGOEXPRESS_CONFIG_BASICAUTH_PASSWORD
      remoteRef:
        key: MONGOEXPRESS-CONFIG-BASICAUTH-PASSWORD
    - secretKey: MONGODB_CONFIG_SERVER
      remoteRef:
        key: MONGODB-CONFIG-SERVER
EOF

Przykładowe wyjście:

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

Wdrażanie bazy danych Mongo Express

Przykładowa aplikacja kliencka używa mongo-expressinterfejsu administracyjnego bazy danych MongoDB opartego na sieci Web z Node.js, Express i Bootstrap 5 do wykonywania operacji CRUD.

Zastosuj następujący manifest YAML przy użyciu kubectl apply polecenia :

kubectl apply -f -<<EOF
apiVersion: v1
kind: Service
metadata:
  name: mongo-express
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  type: LoadBalancer
  ports:
    - port: 8081  # Service port for HTTP access
      targetPort: 8081  # Container port for Mongo Express
  selector:
    app: mongo-express
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mongo-express
  namespace: ${AKS_MONGODB_NAMESPACE}
spec:
  replicas: 1
  selector:
    matchLabels:
      app: mongo-express
  template:
    metadata:
      labels:
        app: mongo-express
    spec:
      containers:
        - name: mongo-express
          image: mongo-express
          ports:
            - containerPort: 8081
          env:
            - name: ME_CONFIG_MONGODB_SERVER
              valueFrom:
                secretKeyRef:
                  name: ${AKS_MONGODB_SECRETS_NAME}
                  key: MONGODB_CONFIG_SERVER        
            - name: ME_CONFIG_BASICAUTH_USERNAME
              valueFrom:
                secretKeyRef:
                  name: ${AKS_MONGODB_SECRETS_NAME}
                  key: MONGOEXPRESS_CONFIG_BASICAUTH_USERNAME 
            - name: ME_CONFIG_BASICAUTH_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: ${AKS_MONGODB_SECRETS_NAME}
                  key: MONGOEXPRESS_CONFIG_BASICAUTH_PASSWORD
            - name: ME_CONFIG_MONGODB_PORT
              value: "27017"
            - name: ME_CONFIG_MONGODB_ADMINUSERNAME
              valueFrom:
                secretKeyRef:
                  name: ${AKS_MONGODB_SECRETS_NAME}
                  key: MONGODB_DATABASE_ADMIN_USER
            - name: ME_CONFIG_MONGODB_ADMINPASSWORD
              valueFrom:
                secretKeyRef:
                  name: ${AKS_MONGODB_SECRETS_NAME}
                  key: MONGODB_DATABASE_ADMIN_PASSWORD
EOF

Przykładowe wyjście:

service/mongo-express created
deployment.apps/mongo-express created

Testowanie aplikacji

Po uruchomieniu aplikacji usługa Kubernetes uwidacznia aplikację w Internecie. Ukończenie tego procesu może zająć trochę czasu.

Poczekaj mongo-express na wdrożenie usługi i pobierz go EXTERNAL-IP przy użyciu następującego skryptu.

while true; do
IP=$(kubectl get service mongo-express -n ${AKS_MONGODB_NAMESPACE} -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
if [[ -n $IP ]]; then
  kubectl get service mongo-express -n ${AKS_MONGODB_NAMESPACE}
  break
else
  echo "Waiting for LoadBalancer IP..."
  sleep 5
fi
done

Po przypisaniu EXTERNAL-IP elementu zobaczysz prawidłowy publiczny adres IP usługi, jak pokazano w następujących przykładowych danych wyjściowych:

    NAME            TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)          AGE
    mongo-express   LoadBalancer   10.0.150.235   x.xxx.xx.xxx   8081:30908/TCP   86s

Otwórz przeglądarkę internetową i przejdź do http://<EXTERNAL-IP>:8081adresu .

Po wyświetleniu monitu username wprowadź wartość i password ustaw w konfiguracji wdrożenia. Jeśli musisz pobrać nazwę użytkownika i hasło, możesz to zrobić przy użyciu następujących poleceń:

  export Username=$(kubectl get secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE} -o jsonpath="{.data.MONGOEXPRESS_CONFIG_BASICAUTH_USERNAME}" | base64 --decode) 
  export Password=$(kubectl get secret ${AKS_MONGODB_SECRETS_NAME} -n ${AKS_MONGODB_NAMESPACE} -o jsonpath="{.data.MONGOEXPRESS_CONFIG_BASICAUTH_PASSWORD}" | base64 --decode)

Następny krok

Testowanie odporności bazy danych MongoDB za pomocą locust

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-09-22