Nastavení pravidel škálování v Azure Container Apps

Azure Container Apps spravuje automatické horizontální škálování prostřednictvím sady deklarativních pravidel škálování. Při horizontálním navýšení kapacity revizí aplikace typu kontejner vytvoří platforma nové instance revize na vyžádání. Tyto instance se označují jako repliky.

Pro podporu tohoto chování škálování Azure Container Apps používá KEDA (automatické škálování řízené událostmi Kubernetes). KEDA podporuje škálování na různé metriky, jako jsou požadavky HTTP, zprávy fronty, zatížení procesoru a paměti a zdroje událostí, jako jsou Azure Service Bus, Azure Event Hubs, Apache Kafka a Redis. Další informace najdete v tématu Škálování v dokumentaci KEDA.

Když přidáte nebo upravíte pravidla škálování, vytvoříte novou revizi aplikace kontejneru. Revize je neměnný snímek vaší aplikace kontejneru. Informace o typech změn, které aktivují novou revizi, najdete v tématu Typy změn revizí.

Úlohy Container Apps řízené událostmi používají pravidla škálování k aktivaci spouštění na základě událostí.

Definice škálování

Škálování je kombinace omezení, pravidel a chování.

Omezení definují minimální a maximální možný počet replik na revizi při škálování vaší aplikace kontejneru.

Limit škálování	Výchozí hodnota	Min. hodnota	Max. hodnota
Minimální počet replik na revizi	0	0	Maximální počet konfigurovatelných replik je 1 000.
Maximální počet replik na revizi	10	1	Maximální počet konfigurovatelných replik je 1 000.

Pravidla jsou kritéria používaná službou Container Apps k rozhodování, kdy přidat nebo odebrat repliky.

Pravidla škálování se implementují jako HTTP, TCP (Transmission Control Protocol) nebo vlastní.
Chování je kombinace pravidel a omezení k určení rozhodnutí o škálování v průběhu času.

Chování škály vysvětluje, jak se provádějí rozhodnutí o škálování.

Při definování pravidel škálování zvažte následující položky:

Pokud se vaše aplikace kontejneru škáluje na nulu, neúčtují se vám poplatky za využití.
Repliky, které se nezpracovávají, ale zůstávají v paměti, se můžou účtovat s nižší mírou nečinnosti. Další informace najdete v tématu Fakturace.
Pokud chcete zajistit, aby byla instance revize vždy spuštěná, nastavte minimální počet replik na 1 nebo vyšší.
Během upgradů nebo údržby platformy se může dočasně zobrazit více replik, než se čekalo. Container Apps zajišťuje, že vaše produkční úloha není ovlivněna předehřátím nových replik před samotným přesunem provozu, podobně jako je tomu u výchozího chování Kubernetes. Další repliky se po dokončení operace automaticky odeberou.

Pravidla škálování

Tři kategorie triggerů určují, jak dochází ke škálování:

HTTP: Na základě počtu souběžných požadavků HTTP na vaši revizi.
TCP: Na základě počtu souběžných připojení TCP k revizi.
Vlastní: Na základě vlastních metrik, jako jsou:
- CPU
- Paměť
- Podporované zdroje dat řízené událostmi:
  - Azure Service Bus
  - Azure Event Hubs
  - Apache Kafka
  - Redis

Pokud definujete více než jedno pravidlo škálování, začne se aplikace kontejneru škálovat, jakmile splníte první podmínku libovolného pravidla.

Poznámka:

Pokud používáte functions v Container Apps, výchozí prostředí automaticky konfiguruje pravidla škálování na základě triggerů a vazeb funkcí. Portál Azure zakáže u těchto aplikací tlačítko Přidat pravidla škálování. Pokud potřebujete uživatelsky definovaná pravidla, použijte allowScalingRuleOverride, jak je popsáno v článku Přepsání automaticky generovaných pravidel škálování KEDA pro Azure Functions v Container Apps.

HTTP

Když použijete pravidlo škálování HTTP, určíte prahovou hodnotu souběžných požadavků HTTP, která určuje, jak se škáluje revize vaší kontejnerové aplikace. Každých 15 sekund se počet souběžných požadavků vypočítá jako počet požadavků v posledních 15 sekundách vydělený číslem 15. Úlohy Container Apps nepodporují pravidla škálování HTTP.

V následujícím příkladu se revize škáluje až na pět replik a může se škálovat na nulu. Vlastnost škálování je nastavená na 100 souběžných požadavků za sekundu.

Příklad

Oddíl http definuje pravidlo škálování HTTP.

Vlastnost měřítka	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`concurrentRequests`	Pokud počet požadavků HTTP tuto hodnotu překročí, aplikace přidá další repliku. Aplikace pokračuje v přidávání replik až do počtu `maxReplicas`.	10	1	Není k dispozici

resource symbolicname 'Microsoft.App/containerApps@2025-02-02-preview' = {
  ...
  properties: {
    ...
    template: {
      ...
      scale: {
        maxReplicas: 0
        minReplicas: 5
        rules: [
          {
            name: 'http-rule'
            http: {
              metadata: {
                concurrentRequests: '100'
              }
            }
          }
        ]
      }
    }
  }
}

Poznámka:

properties.configuration.activeRevisionsMode Nastavte vlastnost aplikace kontejneru na single při použití pravidel škálování událostí mimo HTTP.

Oddíl http definuje pravidlo škálování HTTP.

Vlastnost měřítka	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`concurrentRequests`	Pokud počet požadavků HTTP tuto hodnotu překročí, aplikace přidá další repliku. Aplikace bude nadále přidávat repliky až do výše `maxReplicas`.	10	1	Není k dispozici

{
  ...
  "resources": {
    ...
    "properties": {
      ...
      "template": {
        ...
        "scale": {
          "minReplicas": 0,
          "maxReplicas": 5,
          "rules": [{
            "name": "http-rule",
            "http": {
              "metadata": {
                "concurrentRequests": "100"
              }
            }
          }]
        }
      }
    }
  }
}

Poznámka:

properties.configuration.activeRevisionsMode Nastavte vlastnost aplikace kontejneru na single při použití pravidel škálování událostí mimo HTTP.

Definujte pravidlo škálování HTTP pomocí parametru --scale-rule-http-concurrency v příkazech create nebo update příkazech.

Parametr rozhraní příkazového řádku	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`--scale-rule-http-concurrency`	Pokud počet souběžných požadavků HTTP tuto hodnotu překročí, aplikace přidá další repliku. Aplikace bude nadále přidávat repliky až do počtu `max-replicas`.	10	1	Není k dispozici

az containerapp create \
  --name <CONTAINER_APP_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --environment <ENVIRONMENT_NAME> \
  --image <CONTAINER_IMAGE_LOCATION>
  --min-replicas 0 \
  --max-replicas 5 \
  --scale-rule-name azure-http-rule \
  --scale-rule-type http \
  --scale-rule-http-concurrency 100

V Azure portal přejděte do aplikace kontejneru.
Vyberte Měřítko.
Vyberte Upravit a nasadit.
Vyberte kartu Měřítko.
Vyberte minimální a maximální rozsah replik.
Vyberte Přidat.
Do pole Název pravidla zadejte název pravidla.
V rozevíracím seznamu Typ vyberte HTTP Škálování.
Do pole Souběžné požadavky zadejte požadovaný počet souběžných požadavků pro vaši aplikaci kontejneru.

protokol TCP

Při použití pravidla škálování protokolu TCP řídíte prahovou hodnotu souběžných připojení TCP, která určuje, jak se vaše aplikace škáluje. Každých 15 sekund systém vypočítá počet souběžných připojení jako počet připojení v posledních 15 sekundách vydělený číslem 15. Úlohy Container Apps nepodporují pravidla škálování TCP.

V následujícím příkladu se revize kontejnerové aplikace škáluje až na pět replik a může se škálovat zpět až na nulu. Prahová hodnota škálování je nastavená na 100 souběžných připojení za sekundu.

Příklad

Oddíl tcp definuje pravidlo škálování protokolu TCP.

Vlastnost měřítka	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`concurrentConnections`	Pokud počet souběžných připojení TCP tuto hodnotu překročí, systém přidá další repliku. Systém postupně přidává repliky až do počtu `maxReplicas`, jak se zvyšuje počet souběžných připojení.	10	1	Není k dispozici

resource symbolicname 'Microsoft.App/containerApps@2025-02-02-preview' = {
  ...
  properties: {
    ...
    template: {
      ...
      scale: {
        maxReplicas: 0
        minReplicas: 5
        rules: [
          {
            name: 'tcp-rule'
            http: {
              metadata: {
                concurrentConnections: '100'
              }
            }
          }
        ]
      }
    }
  }
}

Oddíl tcp definuje pravidlo škálování protokolu TCP.

Vlastnost měřítka	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`concurrentConnections`	Pokud počet souběžných připojení TCP tuto hodnotu překročí, systém přidá další repliku. Systém průběžně přidává repliky až do počtu `maxReplicas`, s tím, jak se zvyšuje počet souběžných připojení.	10	1	Není k dispozici

{
  ...
  "resources": {
    ...
    "properties": {
      ...
      "template": {
        ...
        "scale": {
          "minReplicas": 0,
          "maxReplicas": 5,
          "rules": [{
            "name": "tcp-rule",
            "tcp": {
              "metadata": {
                "concurrentConnections": "100"
              }
            }
          }]
        }
      }
    }
  }
}

Definujte pravidlo škálování TCP pomocí parametru --scale-rule-tcp-concurrency v příkazech create nebo update.

Parametr rozhraní příkazového řádku	Popis	Výchozí hodnota	Min. hodnota	Max. hodnota
`--scale-rule-tcp-concurrency`	Pokud počet souběžných připojení TCP tuto hodnotu překročí, systém přidá další repliku. Systém přidává repliky až do počtu `max-replicas`, jak se zvyšuje počet současných připojení.	10	1	Není k dispozici

az containerapp create \
  --name <CONTAINER_APP_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --environment <ENVIRONMENT_NAME> \
  --image <CONTAINER_IMAGE_LOCATION>
  --min-replicas 0 \
  --max-replicas 5 \
  --transport tcp \
  --ingress <external/internal> \
  --target-port <CONTAINER_TARGET_PORT> \
  --scale-rule-name azure-tcp-rule \
  --scale-rule-type tcp \
  --scale-rule-tcp-concurrency 100

Azure Portal tuto funkci nepodporuje. Ke konfiguraci pravidla škálování PROTOKOLU TCP použijte Azure CLI, Azure Resource Manager nebo Bicep.

Vlastní

Pomocí těchto výchozích hodnot vytvořte vlastní pravidlo škálování Container Apps na základě libovolného škálování KEDA založeného na objektu ScaledObject:

Výchozí hodnota	Sekundy
Interval dotazování	30
Období chladnutí	300

Poznámka:

Období chladnutí se projeví pouze při škálování z konečné repliky na 0. Doba ochlazení neovlivňuje škálování, protože všechny ostatní repliky jsou odebrány.

V případě úloh Container Apps řízených událostmi vytvořte vlastní pravidlo škálování založené na škálovacích modulech KEDA založených na škálovací službě ScaledJob.

Následující příklad ukazuje, jak vytvořit vlastní pravidlo škálování.

Příklad

Tento příklad ukazuje, jak převést Azure Service Bus scaler na pravidlo škálování Container Apps, ale stejný postup použijete pro všechny ostatní specifikace ScaledObject založené na KEDA scaler.

Pro ověřování přebírají parametry ověřování KEDA scaler z tajných kódů Container Apps nebo spravované identity.

Následující postup ukazuje, jak převést škálovací nástroj KEDA na pravidlo škálování kontejnerové aplikace. Tento fragment kódu je výňatek šablony Bicep, která vám ukáže, kde se jednotlivé oddíly vejdou do kontextu celkové šablony.

resource symbolicname 'Microsoft.App/containerApps@2025-02-02-preview' = {
  ...
  properties: {
    ...
    configuration: {
      ...
      secrets: [
        {
          name: '<NAME>'
          value: '<VALUE>'
        }
      ]
    }
    template: {
      ...
      scale: {
        maxReplicas: 0
        minReplicas: 5
        rules: [
          {
            name: '<RULE_NAME>'
            custom: {
              metadata: {
                ...
              }
              auth: [
                {
                  secretRef: '<NAME>'
                  triggerParameter: '<PARAMETER>'
                }
              ]
            }
          }
        ]
      }
    }
  }
}

Informace o tom, jak následující příklady odpovídají šabloně Bicep, najdete v tomto výňatku.

Nejprve definujte typ a metadata pravidla škálování.

Ve specifikaci škálovače KEDA vyhledejte type hodnotu.

triggers:
 - type: azure-servicebus ⬅️
  metadata:
    queueName: my-queue
    namespace: service-bus-namespace
    messageCount: "5"

V šabloně Bicep zadejte hodnotu scaleru type do custom.type vlastnosti pravidla škálování.

...
rules: [
  {
    name: 'azure-servicebus-queue-rule'
    custom: {
      type: 'azure-servicebus' ⬅️
      metadata: {
        queueName: 'my-queue'
        namespace: 'service-bus-namespace'
        messageCount: '5'
      }
    }
  }
]
...

Ve specifikaci škálovače KEDA najděte metadata hodnoty.

triggers:
- type: azure-servicebus
  metadata:
    queueName: my-queue              ⬅️
    namespace: service-bus-namespace ⬅️
    messageCount: "5"                ⬅️

V šabloně Bicep přidejte všechny hodnoty metadat do sekce custom.metadata pravidla škálování.

...
rules: [
  {
    name: 'azure-servicebus-queue-rule'
    custom: {
      type: 'azure-servicebus'
      metadata: {
        queueName: 'my-queue'              ⬅️
        namespace: 'service-bus-namespace' ⬅️
        messageCount: '5'                  ⬅️
      }
    }
  }
]
...

Ověřování

Pravidla škálování Container Apps podporují ověřování založené na tajných kódech. Pravidla škálování pro prostředky Azure, včetně Azure Queue Storage, Azure Service Bus a Azure Event Hubs, podporují také spravovanou identitu. Pokud je to možné, použijte ověřování spravované identity, abyste se vyhnuli ukládání tajných kódů v aplikaci.

Použití tajných kódů

Pokud chcete použít tajné kódy pro ověřování, vytvořte tajný kód v poli aplikace kontejneru secrets . Použijte hodnotu tajného kódu v auth poli pravidla škálování.

Škálovače KEDA mohou v objektu TriggerAuthentication používat tajné údaje, na které odkazuje vlastnost authenticationRef. Objekt TriggerAuthentication můžete mapovat na pravidlo škálování Container Apps.

TriggerAuthentication Vyhledejte objekt odkazovaný specifikací KEDAScaledObject.

V objektu TriggerAuthentication vyhledejte každý secretTargetRef a jeho přidružený tajný klíč.

apiVersion: v1
kind: Secret
metadata:
  name: my-secrets
  namespace: my-project
type: Opaque
data:
  connection-string-secret: <SERVICE_BUS_CONNECTION_STRING> ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-servicebus-auth
spec:
  secretTargetRef:
  - parameter: connection         ⬅️
    name: my-secrets              ⬅️
    key: connection-string-secret ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: azure-servicebus-queue-rule
  namespace: default
spec:
  scaleTargetRef:
    name: my-scale-target
  triggers:
  - type: azure-servicebus
    metadata:
      queueName: my-queue
      namespace: service-bus-namespace
      messageCount: "5"
    authenticationRef:
        name: azure-servicebus-auth

V šabloně Bicep pro každé tajemství:

Přidejte tajný kód do pole aplikace secrets kontejneru obsahující název a hodnotu tajného kódu.

Přidejte položku do auth pole pravidla škálování.

Nastavte hodnotu vlastnosti triggerParameter na hodnotu vlastnosti secretTargetRef objektu parameter.

Nastavte hodnotu vlastnosti secretRef na název vlastnosti secretTargetRef objektu key.

resource symbolicname 'Microsoft.App/containerApps@2025-02-02-preview' = {
  ...
  properties: {
    ...
    configuration: {
      ...
      secrets: [
        {                                          ⬅️
          name: 'connection-string-secret'         ⬅️
          value: '<SERVICE_BUS_CONNECTION_STRING>' ⬅️
        }                                          ⬅️
      ]
    }
    template: {
      ...
      scale: {
        maxReplicas: 0
        minReplicas: 5
        rules: [
          {
            name: 'azure-servicebus-queue-rule'
            custom: {
              type: 'azure-servicebus'
              metadata: {
                queueName: 'my-queue'
                namespace: 'service-bus-namespace'
                messageCount: '5'
              }
              auth: [
                {
                  secretRef: 'connection-string-secret'
                  triggerParameter: 'connection'
                }
              ]
            }
          }
        ]
      }
    }
  }
}

Některé škálovací nástroje podporují metadata s příponou FromEnv pro odkaz na hodnotu v proměnné prostředí. Container Apps se podívá na první kontejner uvedený v šabloně ARM pro proměnnou prostředí.

Další informace související se zabezpečením vyhledejte v části úvah.

Použití spravované identity

Pravidla škálování služby Container Apps můžou používat spravovanou identitu k ověřování pomocí Azure služeb. Následující šablona Bicep předává spravovanou identitu založenou na systému, aby se ověřila pro škálovač front Azure.

Před použitím následujícího kódu nahraďte zástupné symboly ohraničené <> hodnotami.

scale: {
  minReplicas: 0
  maxReplicas: 4
  rules: [
    {
      name: 'azure-queue'
      custom: {
        type: 'azure-queue'
        metadata: {
          accountName: '<ACCOUNT_NAME>'
          queueName: '<QUEUE_NAME>'
          queueLength: '1'
        },
        identity: 'system'
      }
    }
  ]
}

Další informace o používání spravované identity s pravidly škálování najdete v tématu Spravovaná identita.

Následující postup ukazuje, jak převést škálovací nástroj KEDA na pravidlo škálování kontejnerové aplikace. Tento fragment kódu je výňatek šablony ARM, který vám ukáže, kde se jednotlivé oddíly vejdou do kontextu celkové šablony.

{
  ...
  "resources": {
    ...
    "properties": {
      ...
      "configuration": {
        ...
        "secrets": [
          {
            "name": "<NAME>",
            "value": "<VALUE>"
          }
        ]
      },
      "template": {
        ...
        "scale": {
          "minReplicas": 0,
          "maxReplicas": 5,
          "rules": [
            {
              "name": "<RULE_NAME>",
              "custom": {
                "metadata": {
                  ...
                },
                "auth": [
                  {
                    "secretRef": "<NAME>",
                    "triggerParameter": "<PARAMETER>"
                  }
                ]
              }
            }
          ]
        }
      }
    }
  }
}

Informace o tom, jak následující příklady odpovídají šabloně ARM, najdete v tomto výňatku.

Nejprve definujte typ a metadata pravidla škálování.

Ve specifikaci škálovače KEDA vyhledejte type hodnotu.

triggers:
- type: azure-servicebus ⬅️
  metadata:
    queueName: my-queue
    namespace: service-bus-namespace
    messageCount: "5"

V šabloně ARM zadejte hodnotu scaleru type do custom.type vlastnosti pravidla škálování.

...
"rules": [
  {
    "name": "azure-servicebus-queue-rule",
    "custom": {
      "type": "azure-servicebus",  ⬅️
      "metadata": {
        "queueName": "my-queue",
        "namespace": "service-bus-namespace",
        "messageCount": "5"
      }
    }
  }
]
...

Ve specifikaci škálovače KEDA najděte metadata hodnoty.

triggers:
- type: azure-servicebus
  metadata:
    queueName: my-queue              ⬅️
    namespace: service-bus-namespace ⬅️
    messageCount: "5"                ⬅️

V šabloně ARM přidejte do oddílu pravidla pro škálování všechny hodnoty custom.metadata metadat.

...
"rules": [
  {
    "name": "azure-servicebus-queue-rule",
    "custom": {
      "type": "azure-servicebus",
      "metadata": {
        "queueName": "my-queue",              ⬅️
        "namespace": "service-bus-namespace", ⬅️
        "messageCount": "5"                   ⬅️
      }
    }
  }
]
...

Ověřování

Použití tajných kódů

Pokud chcete použít tajné kódy pro ověřování, vytvořte tajný kód v poli aplikace kontejneru secrets . Použijte hodnotu tajného kódu v auth poli pravidla škálování.

Škálovače KEDA mohou používat tajné údaje v objektu TriggerAuthentication, na který odkazuje vlastnost authenticationRef. Objekt TriggerAuthentication můžete mapovat na pravidlo škálování Container Apps.

TriggerAuthentication Vyhledejte objekt odkazovaný specifikací KEDAScaledObject.

V objektu TriggerAuthentication vyhledejte každý secretTargetRef a jeho přidružený tajný klíč.

apiVersion: v1
kind: Secret
metadata:
  name: my-secrets
  namespace: my-project
type: Opaque
data:
  connection-string-secret: <SERVICE_BUS_CONNECTION_STRING> ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-servicebus-auth
spec:
  secretTargetRef:
  - parameter: connection         ⬅️
    name: my-secrets              ⬅️
    key: connection-string-secret ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: azure-servicebus-queue-rule
  namespace: default
spec:
  scaleTargetRef:
    name: my-scale-target
  triggers:
  - type: azure-servicebus
    metadata:
      queueName: my-queue
      namespace: service-bus-namespace
      messageCount: "5"
    authenticationRef:
        name: azure-servicebus-auth

V šabloně ARM pro každý tajný kód:

Přidejte tajný kód do pole aplikace secrets kontejneru obsahující název a hodnotu tajného kódu.
Přidejte položku do auth pole pravidla škálování.
1. Nastavte hodnotu vlastnosti triggerParameter na hodnotu vlastnosti secretTargetRef objektu parameter.
2. Nastavte hodnotu vlastnosti secretRef na název vlastnosti secretTargetRef objektu key.

{
  ...
  "resources": {
    ...
    "properties": {
      ...
      "configuration": {
        ...
        "secrets": [
          {                                            ⬅️
            "name": "connection-string-secret",        ⬅️
            "value": "<SERVICE_BUS_CONNECTION_STRING>" ⬅️
          }                                            ⬅️
        ]
      },
      "template": {
        ...
        "scale": {
          "minReplicas": 0,
          "maxReplicas": 5,
          "rules": [
            {
              "name": "azure-servicebus-queue-rule",
              "custom": {
                "type": "azure-servicebus",
                "metadata": {
                  "queueName": "my-queue",
                  "namespace": "service-bus-namespace",
                  "messageCount": "5"
                },
                "auth": [
                  {                                          ⬅️
                    "secretRef": "connection-string-secret", ⬅️
                    "triggerParameter": "connection"         ⬅️
                  }                                          ⬅️
                ]
              }
            }
          ]
        }
      }
    }
  }
}

Další informace související se zabezpečením vyhledejte v části úvah.

Použití spravované identity

Pravidla škálování služby Container Apps můžou používat spravovanou identitu k ověřování pomocí Azure služeb. Následující šablona ARM předává spravovanou identitu přiřazenou systémem pro ověřování škálovače front Azure Queue.

Před použitím následujícího kódu nahraďte zástupné symboly ohraničené <> hodnotami.

"scale": {
  "minReplicas": 0,
  "maxReplicas": 4,
  "rules": [
    {
      "name": "azure-queue",
      "custom": {
        "type": "azure-queue",
        "metadata": {
          "accountName": "<ACCOUNT_NAME>",
          "queueName": "<QUEUE_NAME>",
          "queueLength": "1"
        },
        "identity": "system"
      }
    }
  ]
}

Další informace o používání spravované identity s pravidly škálování najdete v tématu Spravovaná identita.

Ve specifikaci škálovače KEDA vyhledejte type hodnotu.

triggers:
- type: azure-servicebus ⬅️
  metadata:
    queueName: my-queue
    namespace: service-bus-namespace
    messageCount: "5"

V příkazu rozhraní příkazového řádku nastavte --scale-rule-type parametr na hodnotu specifikace type .

az containerapp create \
  --name <CONTAINER_APP_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --environment <ENVIRONMENT_NAME> \
  --image <CONTAINER_IMAGE_LOCATION>
  --min-replicas 0 \
  --max-replicas 5 \
  --secrets "connection-string-secret=<SERVICE_BUS_CONNECTION_STRING>" \
  --scale-rule-name azure-servicebus-queue-rule \
  --scale-rule-type azure-servicebus \ ⬅️
  --scale-rule-metadata "queueName=my-queue" \
                        "namespace=service-bus-namespace" \
                        "messageCount=5" \
  --scale-rule-auth "connection=connection-string-secret"

Ve specifikaci škálovače KEDA najděte metadata hodnoty.

triggers:
- type: azure-servicebus
  metadata:
    queueName: my-queue              ⬅️
    namespace: service-bus-namespace ⬅️
    messageCount: "5"                ⬅️

V příkazu rozhraní příkazového řádku nastavte --scale-rule-metadata parametr na hodnoty metadat.

Transformujte hodnoty z formátu YAML na dvojici klíč/hodnota pro použití na příkazovém řádku. Jednotlivé páry klíč/hodnota oddělte mezerou.

az containerapp create \
  --name <CONTAINER_APP_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --environment <ENVIRONMENT_NAME> \
  --image <CONTAINER_IMAGE_LOCATION>
  --min-replicas 0 \
  --max-replicas 5 \
  --secrets "connection-string-secret=<SERVICE_BUS_CONNECTION_STRING>" \
  --scale-rule-name azure-servicebus-queue-rule \
  --scale-rule-type azure-servicebus \
  --scale-rule-metadata "queueName=my-queue" \              ⬅️
                        "namespace=service-bus-namespace" \ ⬅️
                        "messageCount=5" \                  ⬅️
  --scale-rule-auth "connection=connection-string-secret"

Ověřování

Použití tajných kódů

Pokud chcete nakonfigurovat ověřování založené na tajných kódech pro pravidlo škálování Container Apps, nakonfigurujte tajné kódy v aplikaci kontejneru a odkazujte na ně v pravidle škálování.

Scaler KEDA podporuje tajemství v TriggerAuthentication, které vlastnost authenticationRef používá jako referenci. Objekt TriggerAuthentication můžete namapovat na pravidlo škálování aplikace kontejnerů.

TriggerAuthentication Vyhledejte objekt odkazovaný specifikací KEDAScaledObject. Identifikujte každý secretTargetRef objektu TriggerAuthentication.

apiVersion: v1
kind: Secret
metadata:
  name: my-secrets
  namespace: my-project
type: Opaque
data:
  connection-string-secret: <SERVICE_BUS_CONNECTION_STRING> ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-servicebus-auth
spec:
  secretTargetRef:
  - parameter: connection         ⬅️
    name: my-secrets              ⬅️
    key: connection-string-secret ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: azure-servicebus-queue-rule
  namespace: default
spec:
  scaleTargetRef:
    name: my-scale-target
  triggers:
  - type: azure-servicebus
    metadata:
      queueName: my-queue
      namespace: service-bus-namespace
      messageCount: "5"
    authenticationRef:
        name: azure-servicebus-auth

V aplikaci kontejneru vytvořte tajné kódy , které odpovídají vlastnostem secretTargetRef .

V příkazu rozhraní příkazového řádku nastavte parametry pro každou secretTargetRef položku.

Vytvořte položku tajného kódu s parametrem --secrets . Pokud existuje více tajných kódů, oddělte je mezerou.
Vytvořte položku ověřování s parametrem --scale-rule-auth . Pokud existuje více položek, oddělte je mezerou.

az containerapp create \
  --name <CONTAINER_APP_NAME> \
  --resource-group <RESOURCE_GROUP> \
  --environment <ENVIRONMENT_NAME> \
  --image <CONTAINER_IMAGE_LOCATION>
  --min-replicas 0 \
  --max-replicas 5 \
  --secrets "connection-string-secret=<SERVICE_BUS_CONNECTION_STRING>" \ ⬅️
  --scale-rule-name azure-servicebus-queue-rule \
  --scale-rule-type azure-servicebus \
  --scale-rule-metadata "queueName=my-queue" \
                        "namespace=service-bus-namespace" \
                        "messageCount=5" \
  --scale-rule-auth "connection=connection-string-secret"                ⬅️

Použití spravované identity

Pravidla škálování služby Container Apps můžou používat spravovanou identitu k ověřování pomocí Azure služeb. Následující příkaz vytvoří aplikaci kontejneru se spravovanou identitou přiřazenou uživatelem a použije ji k ověření pro škálovač fronty Azure.

Před použitím následujícího kódu nahraďte zástupné symboly ohraničené <> hodnotami.

az containerapp create \
  --resource-group <RESOURCE_GROUP> \
  --name <APP_NAME> \
  --environment <ENVIRONMENT_ID> \
  --user-assigned <USER_ASSIGNED_IDENTITY_ID> \
  --scale-rule-name azure-queue \
  --scale-rule-type azure-queue \
  --scale-rule-metadata "accountName=<AZURE_STORAGE_ACCOUNT_NAME>" "queueName=queue1" "queueLength=1" \
  --scale-rule-identity <USER_ASSIGNED_IDENTITY_ID>

V Azure portal přejděte do aplikace kontejneru.
Vyberte Měřítko.
Vyberte Upravit a nasadit.
Vyberte kartu Škálování a repliky.
Vyberte minimální a maximální rozsah replik.
Vyberte Přidat.
Do pole Název pravidla zadejte název pravidla.
V rozevíracím seznamu Typ vyberte Vlastní.

Ve specifikaci škálovače KEDA vyhledejte type hodnotu.

triggers:
- type: azure-servicebus ⬅️
  metadata:
    queueName: my-queue
    namespace: service-bus-namespace
    messageCount: "5"

Do pole Typ vlastního pravidla zadejte hodnotu škálovačetype.

Ve specifikaci škálovače KEDA najděte metadata hodnoty.

triggers:
- type: azure-servicebus
  metadata:
    queueName: my-queue              ⬅️
    namespace: service-bus-namespace ⬅️
    messageCount: "5"                ⬅️

Na portálu vyhledejte část Metadata a vyberte Přidat. Zadejte název a hodnotu pro každou položku v části metadat specifikace KEDA ScaledObject .

Ověřování

Použití tajných kódů

V aplikaci kontejneru vytvořte tajemství na které chcete odkazovat.

TriggerAuthentication Vyhledejte objekt odkazovaný specifikací KEDAScaledObject. Identifikujte každý secretTargetRef objektu TriggerAuthentication.

apiVersion: v1
kind: Secret
metadata:
  name: my-secrets
  namespace: my-project
type: Opaque
data:
  connection-string-secret: <SERVICE_BUS_CONNECTION_STRING>
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: azure-servicebus-auth
spec:
  secretTargetRef:
  - parameter: connection         ⬅️
    name: my-secrets              ⬅️
    key: connection-string-secret ⬅️
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: azure-servicebus-queue-rule
  namespace: default
spec:
  scaleTargetRef:
    name: my-scale-target
  triggers:
  - type: azure-servicebus
    metadata:
      queueName: my-queue
      namespace: service-bus-namespace
      messageCount: "5"
    authenticationRef:
        name: azure-servicebus-auth

V části Ověřování vyberte Přidat a vytvořte položku pro každý parametr KEDAsecretTargetRef.

Použití spravované identity

Ověřování spravované identity není v Azure portal podporované. K ověření pomocí spravované identity použijte Azure CLI nebo Azure Resource Manager.

Výchozí pravidlo škálování

Pokud pravidlo škálování nevytvoříte, použije se ve vaší aplikaci kontejneru výchozí pravidlo škálování.

Spoušť	Min. repliky	Maximální počet replik
HTTP	0	10

Důležité

Pokud příchozí přenos dat nepovolíte, nezapomeňte vytvořit pravidlo škálování nebo nastavit minReplicas na 1 nebo více. Pokud je ingress zakázaný a nedefinujete minReplicas ani vlastní pravidlo škálování, vaše kontejnerová aplikace se škáluje na nulu a nemá možnost se znovu spustit.

Chování na škále

Škálování má následující chování:

Chování	Hodnota
Interval dotazování	30 sekund
Období chladnutí	300 sekund
Zvýšení rozsahu okna stabilizace	0 sekund
Zmenšit okno stabilizace	300 sekund
Krok pro zvýšení kapacity	1, 4, 8, 16, 32, ... až do nakonfigurovaného maximálního počtu replik
Krok pro zmenšení velikosti	100% replik, které je potřeba vypnout
Algoritmus škálování	`desiredReplicas = ceil(currentMetricValue / targetMetricValue)`

Interval dotazování určuje, jak často keDA dotazuje zdroje událostí. Tato hodnota se nevztahuje na pravidla škálování HTTP a TCP.
Prodleva před škálováním dolů je doba, po kterou KEDA po poslední události čeká, než aplikaci škáluje dolů na minimální počet replik.
Okno stabilizace vertikálního navýšení kapacity je doba čekání KEDA, než provede rozhodnutí vertikálního navýšení kapacity po splnění podmínek vertikálního navýšení kapacity.
Okno stabilizace škálování dolů udává, jak dlouho KEDA čeká, než rozhodne o škálování dolů poté, co jsou splněny podmínky pro škálování dolů.
Krok vertikálního navýšení kapacity určuje, kolik replik se přidá při horizontálním navýšení kapacity vaší aplikace kontejneru. Začíná na 1 a pak se zvýší na 4, 8, 16, 32 atd. až na nakonfigurovaný maximální počet replik.
Krok škálování dolů je počet replik, které se odeberou při škálování vaší kontejnerové aplikace směrem dolů. KEDA odebere 100% replik, které je potřeba vypnout.
Algoritmus škálování je vzorec použitý k výpočtu aktuálního požadovaného počtu replik.

Příklad

Pro následující pravidlo škálování:

"minReplicas": 0,
"maxReplicas": 20,
"rules": [
  {
    "name": "azure-servicebus-queue-rule",
    "custom": {
      "type": "azure-servicebus",
      "metadata": {
        "queueName": "my-queue",
        "namespace": "service-bus-namespace",
        "messageCount": "5"
      }
    }
  }
]

Při horizontálním navýšení kapacity aplikace začne KEDA s prázdnou frontou a provede následující kroky:

Zkontrolujte my-queue každých 30 sekund.
Pokud se délka fronty rovná 0, vraťte se ke kroku 1.
Pokud je délka fronty větší než 0, škálujte aplikaci na 1.
Pokud je délka fronty 50, vypočítejte desiredReplicas = ceil(50/5) = 10.
Škálování aplikace na min(maxReplicaCount, desiredReplicas, max(4, 2*currentReplicaCount)).
Vraťte se ke kroku 1.

Pokud se aplikace škáluje na maximální počet replik 20, škálování prochází stejnými předchozími kroky. Škálování dolů nastane pouze tehdy, pokud je podmínka splněna po dobu 300 sekund (stabilizační okno pro škálování dolů). Jakmile je délka fronty 0, KEDA před škálováním aplikace na 0 počká 300 sekund (období pro uklidnění).

Úvahy

V režimu více revizí vytvoří přidání nové aktivační události škálování novou revizi aplikace, ale stará revize zůstane k dispozici ve starých pravidlech škálování. Použijte stránku Správa revizí ke správě přidělení provozu.
Pokud se aplikace škáluje na nulu, neúčtují se vám žádné poplatky za využití. Další informace o cenách najdete v tématu Billing in Azure Container Apps.
Potřebujete povolit ochranu dat pro všechny aplikace .NET na Azure Container Apps. Podrobnosti najdete v tématu Nasazení a škálování aplikace ASP.NET Core na Azure Container Apps.

Známá omezení

Vertikální škálování se nepodporuje.
Množství repliky představují cílovou částku, nikoli záruku.
Pokud ke správě stavů používáte aktéry Dapr , mějte na paměti, že škálování na nulu se nepodporuje. Dapr používá virtuální aktéry ke správě asynchronních volání, což znamená, že jejich reprezentace v paměti není svázaná s jejich identitou nebo životností.
Změna proxy serverů KEDA prostřednictvím nastavení proxy serverů se nepodporuje. Zvažte použití profilů úloh se službou NAT Gateway nebo trasou definovanou uživatelem (UDR) k odesílání provozu do síťového zařízení, kde můžete kontrolovat nebo proxy provoz.

Další kroky

Správa tajemství

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-05-26

Nastavení pravidel škálování v Azure Container Apps

Definice škálování

Pravidla škálování

HTTP

Příklad

protokol TCP

Příklad

Vlastní

Příklad

Ověřování

Použití tajných kódů

Použití spravované identity

Ověřování

Použití tajných kódů

Použití spravované identity

Ověřování

Použití tajných kódů

Použití spravované identity

Ověřování

Použití tajných kódů

Použití spravované identity

Výchozí pravidlo škálování

Chování na škále

Příklad

Úvahy

Známá omezení

Další kroky

Váš názor

Další materiály