Déployer une application cliente pour se connecter à un cluster MongoDB sur Azure Kubernetes Service (AKS)

Après avoir déployé le cluster MongoDB sur AKS, vous pouvez déployer un exemple d’application cliente pour interagir avec MongoDB. Ce tutoriel s’appuie sur le déploiement du cluster MongoDB abordé dans les guides précédents.

Se connecter à l’interpréteur de commandes MongoDB

Dans cette section, vous vous connectez à l’interpréteur de commandes MongoDB. Une fois connecté, vous créez une base de données et une collection, vous insérez des données, puis vous exécutez des requêtes.

Créez un pod nommé percona-client dans l’espace de noms ${AKS_MONGODB_NAMESPACE} de votre cluster à l’aide de la commande kubectl run. Assurez-vous de transmettre la variable d'environnement correcte $connectionString exportée à l'étape 3 du didacticiel précédent.
```
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 
```
Connectez-vous à l’interpréteur de commandes MongoDB à l’aide de la commande suivante.
```
mongosh $CONN_STR
```

Dans l’interpréteur de commandes MongoDB, créez la base de données et la collection à l’aide du script suivant :

// 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}`
    });
}

Dans l’interpréteur de commandes MongoDB, vous pouvez exécuter différentes requêtes sur la collection employees. Les commandes suivantes montrent quelques exemples de requêtes que vous pouvez exécuter :

# 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();

Créer et mettre à jour des secrets

Pour déployer l’application cliente mongo-express, vous devez d’abord créer des secrets spécifiques à mongo-express dans Azure Key Vault et mettre à jour votre magasin de secrets créé lors du précédent tutoriel.

Générez un mot de passe aléatoire à l’aide de la fonction :

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

Créez un secret comprenant un nom d'utilisateur et mot de passe pour l'authentification de base à utiliser pour vous connecter à l'application cliente à l'aide des commandes :

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

Créez un secret pour les détails du serveur de configuration mongo-express à l’aide de la commande az keyvault secret set.

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

Exécutez la commande suivante pour mettre à jour le mongodb.tfvars fichier créé précédemment avec la configuration suivante :

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

Appliquez la configuration terraform à la ressource cible.

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

Mettez à jour les secrets dans le magasin de secrets que vous avez créé lors du précédent tutoriel à l’aide de la commande kubectl apply.

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

Exemple de sortie :

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

Déployer Mongo Express

L’exemple d’application cliente utilise mongo-express, une interface web d’administration de MongoDB créée avec Node.js, Express et Bootstrap 5 pour effectuer des opérations CRUD.

Appliquez le manifeste YAML suivant à l’aide de la commande kubectl apply :

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

Exemple de sortie :

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

Tester l’application

Lorsque l’application s’exécute, un service Kubernetes expose l’application à Internet. Ce processus peut prendre un certain temps.

Attendez que le service mongo-express déploie et récupère l’adresse EXTERNAL-IP à l’aide du script suivant.

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

Lorsque l’adresse EXTERNAL-IP est affectée, vous voyez une adresse IP publique valide pour le service, comme illustré dans l’exemple de sortie suivant :

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

Ouvrez votre navigateur web et accédez à http://<EXTERNAL-IP>:8081.

Lorsque vous y êtes invité, entrez le username et le password définis dans la configuration du déploiement. Si vous devez récupérer le nom d’utilisateur et le mot de passe, vous pouvez le faire à l’aide des commandes suivantes :

  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)

Étape suivante

Tester la résilience MongoDB avec Locust

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-09-15