Distribuire un'applicazione client per connettersi a un cluster MongoDB nel servizio Azure Kubernetes

Dopo aver distribuito il cluster MongoDB nel servizio Azure Kubernetes, è possibile distribuire un'applicazione client di esempio per interagire con MongoDB. Questa esercitazione si basa sulla distribuzione del cluster MongoDB descritta nelle guide precedenti.

Connettersi alla shell MongoDB

In questa sezione ci si connette alla shell MongoDB. Dopo aver stabilito la connessione, creare un database e una raccolta, inserire dati ed eseguire query.

Creare un pod denominato percona-client nello spazio dei nomi ${AKS_MONGODB_NAMESPACE} nel cluster usando il comando kubectl run. Assicurati di passare la variabile di ambiente corretta $connectionString esportata dal passaggio 3 dell'esercitazione precedente.
```
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 
```
Connettersi alla shell MongoDB usando il comando seguente.
```
mongosh $CONN_STR
```

Nella shell MongoDB creare il database e la raccolta usando lo script seguente:

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

Nella shell MongoDB è possibile eseguire varie query sulla raccolta employees. I comandi seguenti mostrano alcune query di esempio che è possibile eseguire:

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

Creare e aggiornare i segreti

Per distribuire l'app client mongo-express, è prima necessario creare segreti specifici di mongo-express in Azure Key Vault e aggiornare l'archivio segreti creato nell'esercitazione precedente.

Generare una password casuale usando la funzione :

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

Creare un nome utente e una mongo-express password di autenticazione di base da usare per accedere all'app client usando i az keyvault secret set comandi:

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

Creare un segreto per i mongo-expressdettagli del server di configurazione usando il comando 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

Eseguire il comando seguente per aggiornare il mongodb.tfvars file creato in precedenza con la configurazione seguente:

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

Applicare la configurazione terraform alla risorsa di destinazione.

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

Aggiornare i segreti nell'archivio segreti creato nell'esercitazione precedente usando il comando 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

Output di esempio:

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

Distribuire Mongo Express

L'applicazione client di esempio usa mongo-express, un'interfaccia di amministrazione MongoDB basata sul Web compilata con Node.js, Express e Bootstrap 5 per eseguire operazioni CRUD.

Applicare il manifesto YAML seguente usando il comando 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

Output di esempio:

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

Test dell'applicazione

Quando l'applicazione viene eseguita, un servizio Kubernetes espone l'applicazione a Internet. Il completamento di questo processo potrebbe richiedere del tempo.

Attendere che il servizio mongo-express venga distribuito e recuperare EXTERNAL-IP usando lo script seguente.

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

Quando EXTERNAL-IP viene assegnato, viene visualizzato un indirizzo IP pubblico valido per il servizio, come illustrato nell'output di esempio seguente:

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

Aprire un Web browser e passare a http://<EXTERNAL-IP>:8081.

Quando richiesto, immettere username e password impostati nella configurazione della distribuzione. Se è necessario recuperare il nome utente e la password, è possibile farlo usando i comandi seguenti:

  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)

Passaggio successivo

Testare la resilienza di MongoDB con Locust

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-09-23