Delen via

Een clienttoepassing implementeren om verbinding te maken met een MongoDB-cluster in Azure Kubernetes Service (AKS)

  • Artikel

Nadat u het MongoDB-cluster op AKS hebt geïmplementeerd, kunt u een voorbeeldclienttoepassing implementeren om te communiceren met MongoDB. Deze zelfstudie bouwt voort op de MongoDB-clusterimplementatie die in de vorige handleidingen wordt behandeld.

Verbinding maken met de MongoDB-shell

In deze sectie maakt u verbinding met de MongoDB-shell. Zodra u verbinding hebt, maakt u een database en verzameling, voegt u gegevens in en voert u query's uit.

  1. Maak een pod met de naam percona-client in de ${AKS_MONGODB_NAMESPACE} naamruimte in uw cluster met behulp van de kubectl run opdracht.

    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 -- bash -il

  2. Maak verbinding met de MongoDB-shell met behulp van de volgende opdracht. Zorg ervoor dat u de werkelijke waarden vervangt databaseAdmindie AKS_MONGODB_CLUSTER_NAME databaseAdminPasswordu hebt verkregen uit de vorige zelfstudie.

    mongosh "mongodb://${databaseAdmin}:${databaseAdminPassword}@${AKS_MONGODB_CLUSTER_NAME}-mongos.mongodb.svc.cluster.local/admin?replicaSet=rs0&ssl=false&directConnection=true"

  3. Maak in de MongoDB-shell de database en verzameling met behulp van het volgende script:

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

  4. In de MongoDB-shell kunt u verschillende query's uitvoeren op de employees verzameling. In de volgende opdrachten ziet u enkele voorbeeldquery's die u kunt uitvoeren:

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

Geheimen maken en bijwerken

Als u de mongo-express client-app wilt implementeren, moet u eerst geheimen maken die specifiek zijn voor mongo-express azure Key Vault en uw geheime archief bijwerken dat u in de vorige zelfstudie hebt gemaakt.

  1. Maak een mongo-express basisverificatie-gebruikersnaam en wachtwoordgeheim dat u wilt gebruiken om u aan te melden bij de client-app met behulp van het volgende script en az keyvault secret set de volgende opdrachten:

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

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

  2. Maak een geheim voor de details van de mongo-express configuratieserver met behulp van de az keyvault secret set opdracht.

    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 table

  3. Werk de geheimen in het geheime archief bij dat u in de vorige zelfstudie hebt gemaakt met behulp van de kubectl apply opdracht.

    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

    Voorbeelduitvoer:

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

Mongo Express implementeren

De voorbeeldclienttoepassing maakt gebruik van mongo-expresseen webgebaseerde MongoDB-beheerinterface die is gebouwd met Node.js, Express en Bootstrap 5 om CRUD-bewerkingen uit te voeren.

  • Pas het volgende YAML-manifest toe met behulp van de kubectl apply opdracht:

    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

    Voorbeelduitvoer:

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

De toepassing testen

Wanneer de toepassing wordt uitgevoerd, maakt een Kubernetes-service de toepassing beschikbaar op internet. Dit proces kan enige tijd in beslag nemen.

  1. Wacht tot de mongo-express service is geïmplementeerd en opgehaald EXTERNAL-IP met behulp van het volgende script.

    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

    Wanneer de EXTERNAL-IP service is toegewezen, ziet u een geldig openbaar IP-adres voor de service, zoals wordt weergegeven in de volgende voorbeelduitvoer:

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

  2. Open uw webbrowser en navigeer naar http://<EXTERNAL-IP>:8081.

  3. Wanneer u hierom wordt gevraagd, voert u de username implementatieconfiguratie in en password stelt u deze in. Als u de gebruikersnaam en het wachtwoord wilt ophalen, kunt u dit doen met behulp van de volgende opdrachten:

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

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

    Schermopname van mongo-express-voorbeeldtoepassing.

Volgende stap

MongoDB-tolerantie testen met Locust