Partager via

Mettre à l’échelle des applications Dapr avec les outils de mise à l’échelle KEDA

  • Article

Azure Container Apps met automatiquement à l’échelle le trafic HTTP à zéro. Toutefois, pour mettre à l’échelle le trafic non-HTTP (par exemple, Dapr pub/sub et liaisons), vous pouvez utiliser des outils de mise à l’échelle KEDA pour effectuer un scale-up ou un scale-down de votre application et de son side-car Dapr, en fonction du nombre de messages et d’événements entrants en attente.

Ce guide montre comment configurer les règles de mise à l’échelle d’une application Dapr pub/sub avec un outil de mise à l’échelle de messagerie KEDA. Pour le contexte, reportez-vous aux exemples d’applications pub/sub correspondants :

Dans les exemples ci-dessus, l’application utilise les éléments suivants :

  1. Le serveur de publication checkout est une application qui est censée s’exécuter indéfiniment et ne jamais effectuer de scale-down à zéro, même si elle ne reçoit jamais de trafic HTTP entrant.
  2. Le composant Dapr Azure Service Bus pub/sub.
  3. Une application conteneur d’abonnés order-processor récupère les messages reçus via la rubrique orders et les traite à mesure qu’ils arrivent.
  4. La règle de mise à l’échelle pour Azure Service Bus, qui est responsable du scale-up du service order-processor et de son side-car Dapr lorsque les messages commencent à arriver dans la rubrique orders.

Diagramme montrant l’architecture de mise à l’échelle de l’application de traitement des commandes.

Examinons comment appliquer les règles de mise à l’échelle dans une application Dapr.

Application conteneur du serveur de publication

Le serveur de publication checkout est un service sans périphérique de contrôle qui s’exécute indéfiniment et n’effectue jamais de scale-down à zéro.

Par défaut, le runtime Container Apps affecte aux applications une règle de mise à l’échelle basée sur HTTP qui détermine la mise à l’échelle en fonction du nombre de requêtes HTTP entrantes. Dans l’exemple suivant, minReplicas est défini sur 1. Cette configuration garantit que l’application conteneur ne suit pas le comportement par défaut de mise à l’échelle à zéro sans aucun trafic HTTP entrant.

resource checkout 'Microsoft.App/containerApps@2022-03-01' = {
  name: 'ca-checkout-${resourceToken}'
  location: location
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    //...
    template: {
      //...
      // Scale the minReplicas to 1
      scale: {
        minReplicas: 1
        maxReplicas: 1
      }
    }
  }
}

Application conteneur d’abonné

L’application d’abonné order-processor suivante inclut une règle de mise à l’échelle personnalisée qui surveille une ressource de type azure-servicebus. Avec cette règle, l’application (et son side-car) effectue un scale-up et un scale-down en fonction du nombre de messages en attente dans le bus.

resource orders 'Microsoft.App/containerApps@2022-03-01' = {
  name: 'ca-orders-${resourceToken}'
  location: location
  tags: union(tags, {
      'azd-service-name': 'orders'
    })
  identity: {
    type: 'SystemAssigned'
  }
  properties: {
    managedEnvironmentId: containerAppsEnvironment.id
    configuration: {
      //...
      // Enable Dapr on the container app
      dapr: {
        enabled: true
        appId: 'orders'
        appProtocol: 'http'
        appPort: 5001
      }
      //...
    }
    template: {
      //...
      // Set the scale property on the order-processor resource
      scale: {
        minReplicas: 0
        maxReplicas: 10
        rules: [
          {
            name: 'topic-based-scaling'
            custom: {
              type: 'azure-servicebus'
              identity: 'system'
              metadata: {
                topicName: 'orders'
                subscriptionName: 'membership-orders'
                messageCount: '30'
              }
            }
          }
        ]
      }
    }
  }
}

Fonctionnement de l’outil de mise à l’échelle

Notez la propriété messageCount dans la configuration de l’outil de mise à l’échelle dans l’application d’abonné :

{
  //...
  properties: {
    //...
    template: {
      //...
      scale: {
        //...
        rules: [
          //...
          custom: {
            //...
            metadata: {
              //...
              messageCount: '30'
            }
          }
        ]
      }
    }
  }
}

Cette propriété indique à l’outil de mise à l’échelle le nombre de messages que chaque instance de l’application peut traiter en même temps. Dans cet exemple, la valeur est définie sur 30, ce qui indique qu’une instance de l’application doit être créée pour chaque groupe de 30 messages en attente dans la rubrique.

Par exemple, si 150 messages sont en attente, KEDA effectue un scale-out de l’application sur cinq instances. La propriété maxReplicas est définie sur 10. Même avec un grand nombre de messages dans la rubrique, l’outil de mise à l’échelle ne crée jamais plus de 10 instances de cette application. Ce paramètre permet d’éviter un scale-up excessif et une augmentation importante des coûts.

Étapes suivantes

Découvrez-en plus sur l’utilisation des composants Dapr avec Azure Container Apps.