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 kontejneru se vytvoří nové instance revize na vyžádání. Tyto instance se označují jako repliky.

Aby bylo toto chování škálování podporováno, služba Azure Container Apps využí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 je Azure Service Bus, Azure Event Hubs, Apache Kafka a Redis. Další informace najdete v tématu Škálování v dokumentaci KEDA.

Přidání nebo úprava pravidel škálování vytvoří novou revizi vaší 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í je důležité vzít v úvahu 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 nižší sazbou 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šší.

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 všech pravidel.

Poznámka:

Pokud používáte funkce v Container Apps , pravidla škálování se automaticky konfigurují na základě triggerů a vazeb funkce. V důsledku toho bude tlačítko Přidat pravidla škálování na webu Azure Portal pro tyto aplikace zakázané. V tomto scénáři se nevyžaduje ani nepodporuje konfigurace pravidla ručního škálování.

HTTP

S pravidlem škálování HTTP máte kontrolu nad prahovou hodnotou souběžných požadavků HTTP, která určuje, jak se vaše revize aplikace kontejneru škáluje. 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čí, přidá se další replika. Repliky se do fondu přidávají až do `maxReplicas` částky.	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:

Nastavte vlastnost aplikace kontejneru na properties.configuration.activeRevisionsMode, 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čí, přidá se další replika. Repliky se do fondu přidávají až do `maxReplicas` částky.	10	1	Není k dispozici

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

Poznámka:

Nastavte vlastnost aplikace kontejneru na properties.configuration.activeRevisionsMode, 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.

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čí, přidá se další replika. Repliky se do fondu přidávají až do `max-replicas` částky.	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

Přechod do aplikace kontejneru na webu Azure Portal
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

U pravidla škálování protokolu TCP máte kontrolu nad prahovou hodnotou souběžných připojení TCP, která určuje, jak se vaše aplikace škáluje. Každých 15 sekund se počet souběžných připojení vypočítá 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 je revize kontejnerové aplikace škálována až na pět kopií a může být škálována zpět 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čí, přidá se další replika. Repliky se při nárůstu počtu souběžných připojení přidávají až do množství `maxReplicas`.	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čí, přidá se další replika. Repliky se při nárůstu počtu souběžných připojení přidávají až do množství `maxReplicas`.	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í protokolu TCP pomocí parametru --scale-rule-tcp-concurrency v příkazu 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čí, přidá se další replika. Repliky se dále přidávají až do počtu `max-replicas`, jak se zvyšuje počet souběžný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

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

Vlastní

Vlastní pravidlo škálování Container Apps můžete vytvořit na základě libovolného škálovače KEDA založeného na ScaledObjectu s těmito výchozími nastaveními:

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

Poznámka:

Období ochlazení se projeví pouze při snížení kapacity z konečné repliky na nulu. Období ochlazování nemá vliv na škálování, protože jsou odstraněny všechny ostatní repliky.

Pro úlohy v Container Apps řízené událostmi můžete vytvořit vlastní pravidlo škálování na základě jakéhokoli škálovače KEDA založeného na 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 škálovací nástroj služby Azure Service Bus na pravidlo škálování Container Apps, ale stejný postup použijete pro jakoukoli jinou specifikaci škálování KEDA založenou na Objektu ScaledObject.

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 definujete 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 pro ověřování používat tajné kódy, musíte v poli kontejnerové aplikace secrets vytvořit tajný kód. Hodnota tajného kódu se používá v auth poli pravidla škálování.

Škálovací nástroje KEDA můžou používat tajné kódy v TriggerAuthentication , na které tato authenticationRef vlastnost odkazuje. 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í služeb Azure. Následující šablona Bicep předává spravovanou identitu založenou na systému, aby se ověřila pro službu Azure Queue Scaler.

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 definujete 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ů

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í služeb Azure. Následující šablona ARM 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.

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.

Pro použití na příkazovém řádku je potřeba transformovat hodnoty z formátu YAML na pár klíč/hodnota. 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í služeb Azure. Následující příkaz vytvoří aplikaci kontejneru se spravovanou identitou přiřazenou uživatelem a použije ji k ověření pro službu Azure Queue Scaler.

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>

Přejděte do aplikace kontejneru na webu Azure Portal.
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 se na webu Azure Portal nepodporuje. 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 příchozí přenos dat zakázaný a nedefinujete minReplicas ani vlastní pravidlo škálování, vaše aplikace kontejneru se škáluje na nulu a nemá způsob, jak ji 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 nástroj KEDA dotazuje zdroje událostí. Tato hodnota se nevztahuje na pravidla škálování HTTP a TCP.
Doba chladnutí je doba, po které byla poslední událost pozorována předtím než aplikace sníží svou kapacitu na minimální počet replik.
Okno stabilizace při rozšiřování kapacity je doba čekání před provedením rozhodnutí o rozšíření kapacity poté, co jsou splněny podmínky pro rozšíření.
Okno stabilizace snížení kapacity určuje, jak dlouho čekat před provedením rozhodnutí o snížení kapacity poté, co byly splněny podmínky pro snížení.
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.
Škálovací krok určuje, kolik replik se odebere při zmenšování vaší kontejnerové aplikace. Odebírá se 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 na (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 na (1).

Pokud se aplikace škálovala na maximální počet replik 20, škálování prochází stejnými předchozími kroky. K redukci kapacity dochází pouze tehdy, pokud je podmínka splněna po dobu 300 sekund (okno stabilizace). 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, nebudou účtovány žádné poplatky za využití. Další informace o cenách najdete v tématu Fakturace v Azure Container Apps.
Potřebujete povolit ochranu dat pro všechny aplikace .NET v Azure Container Apps. Podrobnosti najdete v tématu Nasazení a škálování aplikace ASP.NET Core v 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ěli byste mít 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 je možné provoz zkontrolovat nebo přesměrovat odsud.

Další kroky

Správa tajemství

Váš názor

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

Last updated on 2025-06-26

Sdílet prostřednictvím

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