Tutoriel : Mettre à l’échelle une application de conteneur

Azure Container Apps gère la mise à l’échelle horizontale automatique en utilisant un ensemble de règles de mise à l’échelle déclaratives. Quand une application conteneur effectue un scale-out, des instances de l’application conteneur sont créées à la demande. Ces instances sont appelées réplicas.

Dans ce tutoriel, vous ajoutez une règle de mise à l’échelle HTTP à votre application de conteneur et observez la façon dont votre application est mise à l’échelle.

Prérequis

Programme d’installation

Pour vous connecter à Azure à partir de l’interface CLI, exécutez la commande suivante et suivez les invites pour procéder à l’authentification.

az login

Connect-AzAccount

Pour être sûr d’utiliser la dernière version de l’interface CLI, exécutez la commande upgrade.

az upgrade

Install-Module -Name Az -Scope CurrentUser -Repository PSGallery -Force

Ensuite, installez ou mettez à jour l’extension Azure Container Apps pour l’interface CLI.

Si vous recevez des erreurs concernant des paramètres manquants lorsque vous exécutez des commandes az containerapp dans Azure CLI ou des cmdlets du module Az.App dans PowerShell, assurez-vous que la dernière version de l’extension Azure Container Apps est installée.

az extension add --name containerapp --upgrade

az extension add --name containerapp --upgrade --allow-preview true

Install-Module -Name Az.App

Update-Module -Name Az.App

Maintenant que la version actuelle de l’extension ou du module est installée, inscrivez les espaces de noms Microsoft.App et Microsoft.OperationalInsights.

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

Register-AzResourceProvider -ProviderNamespace Microsoft.App

Register-AzResourceProvider -ProviderNamespace Microsoft.OperationalInsights

Créer et déployer l’application conteneur

Créez et déployez votre application de conteneur à l’aide de la commande containerapp up. Cette commande crée :

• groupe de ressources
• Environnement Container Apps
• Espace de travail Log Analytics

Si l’une de ces ressources existe déjà, la commande utilise les ressources existantes plutôt que d’en créer de nouvelles.

Enfin, la commande crée et déploie l’application conteneur à l’aide d’une image conteneur publique. mcr.microsoft.com/dotnet/samples:aspnetapp Cette image est utilisée pour déclencher les règles de mise à l’échelle que vous créez dans cet article. Vous n’avez pas besoin de savoir ou d’utiliser .NET pour effectuer cette procédure.

az containerapp up \
  --name my-container-app \
  --resource-group my-container-apps \
  --location centralus \
  --environment 'my-container-apps' \
  --image mcr.microsoft.com/dotnet/samples:aspnetapp \
  --target-port 8080 \
  --ingress external \
  --query properties.configuration.ingress.fqdn \

az containerapp up `
  --name my-container-app `
  --resource-group my-container-apps `
  --location centralus `
  --environment my-container-apps `
  --image mcr.microsoft.com/dotnet/samples:aspnetapp `
  --target-port 8080 `
  --ingress external `
  --query properties.configuration.ingress.fqdn `

En définissant --ingress sur external, vous rendez l’application conteneur disponible pour les demandes publiques.

La commande up retourne le nom de domaine complet de l’application de conteneur. Copiez ce nom de domaine complet (FQDN) dans un fichier texte. Vous l’utilisez dans la section Envoyer des demandes . Votre FQDN ressemble à l’exemple suivant :

https://my-container-app.icydune-96848328.centralus.azurecontainerapps.io

Ajouter une règle de mise à l’échelle

Ajoutez une règle de mise à l’échelle HTTP à votre application de conteneur en exécutant la commande az containerapp update.

az containerapp update \
    --name my-container-app \
    --resource-group my-container-apps \
    --min-replicas 1 \
    --max-replicas 10 \
    --scale-rule-name my-http-scale-rule \
    --scale-rule-http-concurrency 1

az containerapp update `
    --name my-container-app `
    --resource-group my-container-apps `
    --min-replicas 1 `
    --max-replicas 10 `
    --scale-rule-name my-http-scale-rule `
    --scale-rule-http-concurrency 1

Cette commande ajoute une règle de mise à l’échelle HTTP à votre application de conteneur avec le nom my-http-scale-rule et un paramètre d’accès concurrentiel de 1. Si votre application reçoit plusieurs requêtes HTTP simultanées, le runtime crée des réplicas de votre application pour gérer les requêtes.

La commande update retourne la nouvelle configuration en tant que réponse JSON pour vérifier que votre demande a réussi.

Sortie du journal de démarrage

Vous pouvez observer les effets de la mise à l’échelle de votre application en affichant les journaux générés par le runtime Container Apps. Utilisez la commande az containerapp logs show pour commencer à écouter les entrées de journal.

az containerapp logs show \
    --name my-container-app \
    --resource-group my-container-apps \
    --type=system \
    --follow=true

az containerapp logs show `
    --name my-container-app `
    --resource-group my-container-apps `
    --type=system `
    --follow=true

La commande show retourne les entrées des journaux système pour votre application de conteneur en temps réel. Vous pouvez vous attendre à une réponse semblable à celle-ci :

{
    "TimeStamp":"2023-08-01T16:49:03.02752",
    "Log":"Connecting to the container 'my-container-app'..."
}
{
    "TimeStamp":"2023-08-01T16:49:03.04437",
    "Log":"Successfully Connected to container:
    'my-container-app' [Revision: 'my-container-app--9uj51l6',
    Replica: 'my-container-app--9uj51l6-5f96557ffb-5khg9']"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9480811+00:00",
    "Log":"Microsoft.Hosting.Lifetime[14]"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9481264+00:00",
    "Log":"Now listening on: http://[::]:80"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9490917+00:00",
    "Log":"Microsoft.Hosting.Lifetime[0]"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9491036+00:00",
    "Log":"Application started. Press Ctrl+C to shut down."
}
{
    "TimeStamp":"2023-08-01T16:47:31.949723+00:00",
    "Log":"Microsoft.Hosting.Lifetime[0]"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9497292+00:00",
    "Log":"Hosting environment: Production"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9497325+00:00",
    "Log":"Microsoft.Hosting.Lifetime[0]"
}
{
    "TimeStamp":"2023-08-01T16:47:31.9497367+00:00",
    "Log":"Content root path: /app/"
}

Pour plus d’informations, consultez Journaux d’activité az containerapp.

Envoyer des demandes

seq 1 50 | xargs -Iname -P10 curl "<YOUR_CONTAINER_APP_FQDN>"

$url="<YOUR_CONTAINER_APP_FQDN>"
$Runspace = [runspacefactory]::CreateRunspacePool(1,10)
$Runspace.Open()
1..50 | % {
    $ps = [powershell]::Create()
    $ps.RunspacePool = $Runspace
    [void]$ps.AddCommand("Invoke-WebRequest").AddParameter("UseBasicParsing",$true).AddParameter("Uri",$url)
    [void]$ps.BeginInvoke()
}

Dans le premier interpréteur de commandes, où vous avez exécuté la commande az containerapp logs show, la sortie contient désormais une ou plusieurs entrées de journal comme suit.

{
    "TimeStamp":"2023-08-01 18:09:52 +0000 UTC",
    "Type":"Normal",
    "ContainerAppName":"my-container-app",
    "RevisionName":"my-container-app--00001111",
    "ReplicaName":"my-container-app--00001111-aaaaa22222-bbbb",
    "Msg":"Replica 'my-container-app--00001111-aaaaa22222-bbbb' has been scheduled to run on a node.",
    "Reason":"AssigningReplica",
    "EventSource":"ContainerAppController",
    "Count":0
}

Afficher la mise à l’échelle dans le portail Azure (facultatif)

1. Connectez-vous au portail Azure.

2. Dans la barre de Recherche en haut, entrez my-container-app.

3. Dans les résultats de la recherche, sous Ressources, sélectionnez my-container-app.

4. Dans la barre de navigation à gauche, développez Application, puis sélectionnez Mettre à l’échelle et réplicas.

5. Dans la page Mettre à l’échelle et réplicas, sélectionnez Réplicas.

6. Votre application de conteneur a maintenant plusieurs réplicas en cours d’exécution.

   

   Vous devrez peut-être sélectionner Actualiser pour afficher les nouveaux réplicas.

7. Dans la barre de navigation à gauche, développez Supervision, puis sélectionnez Métriques.

8. Dans la page Métriques, définissez Métrique sur Requêtes.

9. Sélectionnez Appliquer le fractionnement.

10. Développez la liste déroulante Valeurs et cochez Réplica.

11. Sélectionnez l’icône de coche bleue pour terminer la modification du fractionnement.

12. Le graphique montre les requêtes reçues par votre application de conteneur, divisées par réplica.

    

13. Par défaut, l’échelle du graphique est définie sur une durée de 24 heures, avec une granularité de temps de 15 minutes. Sélectionnez l’échelle et remplacez-la par les 30 dernières minutes, avec une granularité de temps d’une minute. Sélectionnez le bouton Appliquer.

14. Sélectionnez sur le graphique et faites glisser pour mettre en évidence l’augmentation récente du nombre de requêtes reçues par votre application de conteneur.

    

    La capture d’écran suivante montre une vue zoomée de la façon dont les requêtes reçues par votre application de conteneur sont réparties entre les réplicas.

    

Mise à l’échelle du processeur et de la mémoire

Vous devez préférer les règles d’échelle HTTP aux règles de mise à l’échelle du processeur ou de la mémoire lorsque cela est possible. La mise à l’échelle de l’UC et de la mémoire ne permet pas à votre application de conteneur de mettre à l’échelle jusqu’à zéro.

Après avoir ajouté une règle de mise à l’échelle du processeur ou de la mémoire, vous pouvez la tester en envoyant des demandes à votre application conteneur et en consultant la mise à l’échelle dans le portail Azure.

Une fois que vous avez envoyé des demandes à votre application de scaling, il peut s'écouler une minute avant que la règle de mise à l’échelle soit déclenchée et que de nouvelles répliques soient créées.

Mise à l’échelle du processeur

La mise à l’échelle du processeur permet à votre application d’effectuer un scale-in ou un scale-out en fonction de la quantité de processeur utilisée.

Par exemple, si vous créez une règle de mise à l’échelle du processeur avec une valeur d’utilisation de 50, Azure Container Apps crée davantage de réplicas de votre application conteneur lorsque l’utilisation moyenne du processeur pour tous les réplicas atteint 50%.

La scalabilité du CPU n'autorise pas votre application conteneur à être réduite à zéro. Pour plus d'informations sur ce déclencheur, consultez le déclencheur d'échelle CPU de KEDA.

Ajoutez une règle de mise à l’échelle du processeur à votre application conteneur en exécutant la az containerapp update commande.

Avant d’exécuter la commande suivante, remplacez-la <PLACEHOLDERS> par vos valeurs. Pour ce tutoriel, remplacez <UTILIZATION> par 1. Cela entraîne la mise à l’échelle de votre application conteneur lorsque l’utilisation moyenne du processeur pour tous les réplicas atteint 1 %. Cette valeur est uniquement destinée à la démonstration. Le nombre de réplicas est limité à 10 par le paramètre --max-replicas 10 spécifié lors de l'exécution de az containerapp update.

az containerapp update \
    --name my-container-app \
    --resource-group my-container-apps \
    --min-replicas 1 \
    --max-replicas 10 \
    --scale-rule-name my-cpu-scale-rule \
    --scale-rule-type cpu \
    --scale-rule-metadata type=Utilization value=<UTILIZATION>

az containerapp update `
    --name my-container-app `
    --resource-group my-container-apps `
    --min-replicas 1 `
    --max-replicas 10 `
    --scale-rule-name my-cpu-scale-rule `
    --scale-rule-type cpu `
    --scale-rule-metadata type=Utilization value=<UTILIZATION>

Mise à l’échelle de la mémoire

La mise à l’échelle de la mémoire permet à votre application d’effectuer un scale-in ou d’un scale-out en fonction de la quantité de mémoire utilisée.

Par exemple, si vous créez une règle d’échelle de mémoire avec une valeur d’utilisation 50, Azure Container Apps crée plus de réplicas de votre application conteneur lorsque l’utilisation moyenne de la mémoire pour tous les réplicas atteint 50%.

La mise à l’échelle de la mémoire ne permet pas de réduire à zéro votre application conteneur. Pour plus d’informations sur ce déclencheur, consultez le déclencheur d’échelle de mémoire KEDA.

Ajoutez une règle d’échelle de mémoire à votre application conteneur en exécutant la az containerapp update commande.

Avant d’exécuter la commande suivante, remplacez-la <PLACEHOLDERS> par vos valeurs. Pour ce tutoriel, remplacez <UTILIZATION> par 1. Cela entraîne la mise à l’échelle de votre application conteneur lorsque l’utilisation moyenne de la mémoire pour tous les réplicas atteint 1 %. Cette valeur est uniquement destinée à la démonstration. Le nombre de réplicas est limité à 10 par le paramètre --max-replicas 10 spécifié lors de l'exécution de az containerapp update.

az containerapp update \
    --name my-container-app \
    --resource-group my-container-apps \
    --min-replicas 1 \
    --max-replicas 10 \
    --scale-rule-name my-memory-scale-rule \
    --scale-rule-type memory \
    --scale-rule-metadata type=Utilization value=<UTILIZATION>

az containerapp update `
    --name my-container-app `
    --resource-group my-container-apps `
    --min-replicas 1 `
    --max-replicas 10 `
    --scale-rule-name my-memory-scale-rule `
    --scale-rule-type memory `
    --scale-rule-metadata type=Utilization value=<UTILIZATION>

Règles de mise à l’échelle multiples

Pour ajouter plusieurs règles d’échelle à votre application conteneur à l’aide d’Azure CLI, vous devez utiliser YAML.

1. Exportez la configuration de votre application conteneur vers YAML avec la az containerapp show commande.

   • Bash
   • PowerShell

   az containerapp show \
       --name my-container-app \
       --resource-group my-container-apps \
       --output yaml > app.yaml
   

2. Dans la properties>template>scale>rules section de app.yaml, ajoutez les propriétés suivantes. Remplacez les <PLACEHOLDERS> par vos valeurs.

   ...
   properties:
   ...
     template:
   ...
       scale:
   ...
         rules:
           - name: cpu-scaling-rule
             custom:
               type: cpu
               metadata:
                 type: "Utilization"
                 value: "<CPU_UTILIZATION>"
           - name: memory-scaling-rule
             custom:
               type: memory
               metadata:
                 type: "Utilization"
                 value: "<MEMORY_UTILIZATION>"
   ...
   

3. Importez la configuration de votre application conteneur à partir de app.yaml avec la commande az containerapp update.

   • Bash
   • PowerShell

   az containerapp update \
     --name my-container-app \
     --resource-group my-container-apps \
     --yaml app.yaml
   

Nettoyer les ressources

Si vous ne souhaitez pas continuer à utiliser cette application, exécutez la commande suivante pour supprimer le groupe de ressources ainsi que toutes les ressources créées dans ce tutoriel.

az group delete --name my-container-apps

Étapes suivantes