Ustawianie reguł skalowania w usłudze Azure Container Apps

Artykuł
06/29/2024

Usługa Azure Container Apps zarządza automatycznym skalowaniem w poziomie za pomocą zestawu reguł skalowania deklaratywnego. W miarę skalowania wersji aplikacji kontenera nowe wystąpienia poprawki są tworzone na żądanie. Te wystąpienia są nazywane replikami.

Dodawanie lub edytowanie reguł skalowania powoduje utworzenie nowej poprawki aplikacji kontenera. Poprawka to niezmienna migawka aplikacji kontenera. Aby dowiedzieć się, które typy zmian wyzwalają nową poprawkę, zobacz Typy zmian poprawek.

Zadania usługi Container Apps oparte na zdarzeniach używają reguł skalowania do wyzwalania wykonań na podstawie zdarzeń.

Definicja skalowania

Skalowanie to kombinacja limitów, reguł i zachowania.

Limity definiują minimalną i maksymalną możliwą liczbę replik na wersję w miarę skalowania aplikacji kontenera.

Limit skalowania	Domyślna wartość	Wartość minimalna	Wartość maksymalna
Minimalna liczba replik na wersję	0	0	Maksymalna liczba konfigurowalnych replik to 1000.
Maksymalna liczba replik na wersję	10	1	Maksymalna liczba konfigurowalnych replik to 1000.

Reguły są kryteriami używanymi przez usługę Container Apps do decydowania, kiedy należy dodawać lub usuwać repliki.

Reguły skalowania są implementowane jako HTTP, TCP (Transmission Control Protocol) lub niestandardowe.
Zachowanie to połączenie reguł i limitów w celu określenia decyzji dotyczących skalowania w czasie.

Zachowanie skalowania wyjaśnia, jak są podejmowane decyzje dotyczące skalowania.

Podczas definiowania reguł skalowania należy wziąć pod uwagę następujące elementy:

Opłaty za użycie nie są naliczane, jeśli aplikacja kontenera skaluje się do zera.
Repliki, które nie są przetwarzane, ale pozostają w pamięci, mogą być rozliczane przy niższym współczynniku bezczynności. Aby uzyskać więcej informacji, zobacz Rozliczenia.
Jeśli chcesz mieć pewność, że wystąpienie poprawki jest zawsze uruchomione, ustaw minimalną liczbę replik na 1 lub większą.

Reguły skalowania

Skalowanie jest oparte na trzech różnych kategoriach wyzwalaczy:

HTTP: na podstawie liczby współbieżnych żądań HTTP do poprawki.
TCP: na podstawie liczby współbieżnych połączeń TCP z poprawką.
Niestandardowe: na podstawie procesora CPU, pamięci lub obsługiwanych źródeł danych opartych na zdarzeniach, takich jak:
- Azure Service Bus
- Azure Event Hubs
- Apache Kafka
- Redis

Jeśli zdefiniujesz więcej niż jedną regułę skalowania, aplikacja kontenera rozpocznie skalowanie po spełnieniu pierwszego warunku wszystkich reguł.

HTTP

Dzięki regule skalowania HTTP masz kontrolę nad progiem współbieżnych żądań HTTP, które określają sposób skalowania poprawek aplikacji kontenera. Co 15 sekund liczba współbieżnych żądań jest obliczana jako liczba żądań w ciągu ostatnich 15 sekund podzielonych przez 15. Zadania usługi Container Apps nie obsługują reguł skalowania HTTP.

W poniższym przykładzie poprawka jest skalowana w poziomie do pięciu replik i może być skalowana do zera. Właściwość skalowania jest ustawiona na 100 współbieżnych żądań na sekundę.

Przykład

Sekcja http definiuje regułę skalowania HTTP.

Właściwość skalowania	opis	Domyślna wartość	Wartość minimalna	Wartość maksymalna
`concurrentRequests`	Gdy liczba żądań HTTP przekracza tę wartość, dodawana jest inna replika. Repliki nadal dodawają do puli maksymalnie `maxReplicas` tę ilość.	10	1	nie dotyczy

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

Uwaga

properties.configuration.activeRevisionsMode Ustaw właściwość aplikacji kontenera na singlewartość , jeśli używasz reguł skalowania zdarzeń innych niż HTTP.

Zdefiniuj regułę skalowania HTTP przy użyciu parametru --scale-rule-http-concurrency create w poleceniach lub update .

Parametr interfejsu wiersza polecenia	opis	Domyślna wartość	Wartość minimalna	Wartość maksymalna
`--scale-rule-http-concurrency`	Gdy liczba współbieżnych żądań HTTP przekroczy tę wartość, dodawana jest inna replika. Repliki nadal dodawają do puli maksymalnie `max-replicas` tę ilość.	10	1	nie dotyczy

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

Przejdź do aplikacji kontenera w witrynie Azure Portal
Wybierz pozycję Skaluj.
Wybierz pozycję Edytuj i wdróż.
Wybierz kartę Skala .
Wybierz minimalny i maksymalny zakres replik.
Wybierz Dodaj.
W polu Nazwa reguły wprowadź nazwę reguły.
Z listy rozwijanej Typ wybierz pozycję Skalowanie HTTP.
W polu Współbieżne żądania wprowadź żądaną liczbę współbieżnych żądań dla aplikacji kontenera.

TCP

Za pomocą reguły skalowania TCP masz kontrolę nad progiem współbieżnych połączeń TCP, które określają sposób skalowania aplikacji. Co 15 sekund liczba połączeń współbieżnych jest obliczana jako liczba połączeń w ciągu ostatnich 15 sekund podzielonych przez 15. Zadania usługi Container Apps nie obsługują reguł skalowania TCP.

W poniższym przykładzie poprawka aplikacji kontenera jest skalowana w poziomie do pięciu replik i może być skalowana do zera. Próg skalowania jest ustawiony na 100 połączeń współbieżnych na sekundę.

Przykład

Sekcja tcp definiuje regułę skalowania TCP.

Właściwość skalowania	opis	Domyślna wartość	Wartość minimalna	Wartość maksymalna
`concurrentConnections`	Gdy liczba współbieżnych połączeń TCP przekroczy tę wartość, dodawana jest inna replika. Repliki nadal są dodawane do `maxReplicas` tej ilości w miarę wzrostu liczby współbieżnych połączeń.	10	1	nie dotyczy

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

Zdefiniuj regułę skalowania TCP przy użyciu parametru --scale-rule-tcp-concurrency create w poleceniach lub update .

Parametr interfejsu wiersza polecenia	opis	Domyślna wartość	Wartość minimalna	Wartość maksymalna
`--scale-rule-tcp-concurrency`	Gdy liczba współbieżnych połączeń TCP przekroczy tę wartość, dodawana jest inna replika. Repliki nadal są dodawane do `max-replicas` tej ilości w miarę wzrostu liczby współbieżnych połączeń.	10	1	nie dotyczy

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

Nieobsługiwane w witrynie Azure Portal. Użyj interfejsu wiersza polecenia platformy Azure lub usługi Azure Resource Manager, aby skonfigurować regułę skalowania TCP.

Niestandardowy

Możesz utworzyć niestandardową regułę skalowania usługi Container Apps na podstawie dowolnego modułu skalowania KEDA opartego na obiekcie ScaledObject z następującymi wartościami domyślnymi:

Defaults	Sekundy
Interwał sondowania	30
Okres schładzania	300

W przypadku zadań usługi Container Apps opartych na zdarzeniach można utworzyć niestandardową regułę skalowania na podstawie dowolnych skalowania KEDA opartych na skalowanych obiektach Job.

W poniższym przykładzie pokazano, jak utworzyć niestandardową regułę skalowania.

Przykład

W tym przykładzie pokazano, jak przekonwertować narzędzie skalowania usługi Azure Service Bus na regułę skalowania usługi Container Apps, ale używasz tego samego procesu dla dowolnej innej specyfikacji narzędzia skalowania KEDA opartej na usłudze ScaledObject.

W przypadku uwierzytelniania parametry uwierzytelniania modułu skalowania KEDA przyjmują wpisy tajne usługi Container Apps lub tożsamość zarządzaną.

Poniższa procedura przedstawia sposób konwertowania narzędzia skalowania KEDA na regułę skalowania aplikacji kontenera. Ten fragment kodu jest fragmentem szablonu usługi ARM, który pokazuje, gdzie każda sekcja mieści się w kontekście ogólnego szablonu.

{
  ...
  "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>"
                  }
                ]
              }
            }
          ]
        }
      }
    }
  }
}

Zapoznaj się z tym fragmentem, aby zapoznać się z kontekstem dotyczącym sposobu dopasowania poniższych przykładów do szablonu usługi ARM.

Najpierw należy zdefiniować typ i metadane reguły skalowania.

W specyfikacji narzędzia skalowania KEDA znajdź type wartość.

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

W szablonie usługi ARM wprowadź wartość narzędzia scaler type we custom.type właściwości reguły skalowania.

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

W specyfikacji narzędzia skalowania KEDA znajdź metadata wartości.

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

W szablonie usługi ARM dodaj wszystkie wartości metadanych do custom.metadata sekcji reguły skalowania.

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

Uwierzytelnianie

Reguły skalowania usługi Container Apps obsługują uwierzytelnianie oparte na wpisach tajnych. Reguły skalowania zasobów platformy Azure, w tym usługi Azure Queue Storage, Azure Service Bus i Azure Event Hubs, obsługują również tożsamość zarządzaną. Jeśli to możliwe, użyj uwierzytelniania tożsamości zarządzanej, aby uniknąć przechowywania wpisów tajnych w aplikacji.

Używanie wpisów tajnych

Aby używać wpisów tajnych do uwierzytelniania, należy utworzyć wpis tajny w tablicy aplikacji kontenera secrets . Wartość wpisu tajnego auth jest używana w tablicy reguły skalowania.

Narzędzia skalowania KEDA mogą używać wpisów tajnych w elemencie authenticationRef TriggerAuthentication, do którego odwołuje się właściwość . Obiekt TriggerAuthentication można mapować na regułę skalowania usługi Container Apps.

TriggerAuthentication Znajdź obiekt, do których odwołuje się specyfikacja KEDAScaledObject.

TriggerAuthentication W obiekcie znajdź każdy secretTargetRef i skojarzony z nim wpis tajny.

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

W szablonie usługi ARM dla każdego wpisu tajnego:

Dodaj wpis tajny do tablicy aplikacji kontenera secrets zawierającej nazwę i wartość wpisu tajnego.
Dodaj wpis do auth tablicy reguły skalowania.
1. Ustaw wartość triggerParameter właściwości na wartość secretTargetRefwłaściwości .s parameter .
2. Ustaw wartość secretRef właściwości na nazwę secretTargetRefwłaściwości .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"
                  }
                ]
              }
            }
          ]
        }
      }
    }
  }
}

Niektóre narzędzia skalowania obsługują metadane z sufiksem FromEnv , aby odwoływać się do wartości w zmiennej środowiskowej. Usługa Container Apps analizuje pierwszy kontener wymieniony w szablonie usługi ARM dla zmiennej środowiskowej.

Zapoznaj się z sekcją zagadnień, aby uzyskać więcej informacji związanych z zabezpieczeniami.

Korzystanie z tożsamości zarządzanej

Reguły skalowania usługi Container Apps mogą używać tożsamości zarządzanej do uwierzytelniania za pomocą usług platformy Azure. Poniższy szablon usługi ARM przekazuje tożsamość zarządzaną opartą na systemie w celu uwierzytelniania w usłudze Azure Queue Scaler.

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

Aby dowiedzieć się więcej na temat używania tożsamości zarządzanej z regułami skalowania, zobacz Tożsamość zarządzana.

W specyfikacji narzędzia skalowania KEDA znajdź type wartość.

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

W poleceniu interfejsu wiersza polecenia ustaw --scale-rule-type parametr na wartość specyfikacji 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"

W specyfikacji narzędzia skalowania KEDA znajdź metadata wartości.

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

W poleceniu interfejsu wiersza polecenia ustaw --scale-rule-metadata parametr na wartości metadanych.

Musisz przekształcić wartości z formatu YAML na parę klucz/wartość do użycia w wierszu polecenia. Oddziel każdą parę klucz/wartość spacją.

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"

Uwierzytelnianie

Używanie wpisów tajnych

Aby skonfigurować uwierzytelnianie oparte na wpisach tajnych dla reguły skalowania usługi Container Apps, należy skonfigurować wpisy tajne w aplikacji kontenera i odwoływać się do nich w regule skalowania.

Narzędzie skalowania KEDA obsługuje wpisy tajne w elemencie TriggerAuthentication , którego authenticationRef właściwość używa do odwołania. Obiekt można mapować TriggerAuthentication na regułę skalowania usługi Container Apps.

TriggerAuthentication Znajdź obiekt, do których odwołuje się specyfikacja KEDAScaledObject. Zidentyfikuj TriggerAuthentication każdy secretTargetRef obiekt.

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

W aplikacji kontenera utwórz wpisy tajne zgodne z właściwościami secretTargetRef .

W poleceniu interfejsu wiersza polecenia ustaw parametry dla każdego secretTargetRef wpisu.

Utwórz wpis tajny z parametrem --secrets . Jeśli istnieje wiele wpisów tajnych, oddziel je spacją.
Utwórz wpis uwierzytelniania za pomocą parametru --scale-rule-auth . Jeśli istnieje wiele wpisów, oddziel je spacją.

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"

Korzystanie z tożsamości zarządzanej

Reguły skalowania usługi Container Apps mogą używać tożsamości zarządzanej do uwierzytelniania za pomocą usług platformy Azure. Poniższe polecenie tworzy aplikację kontenera z tożsamością zarządzaną przypisaną przez użytkownika i używa jej do uwierzytelniania w usłudze Azure Queue Scaler.

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>

Zastąp symbole zastępcze wartościami.

Przejdź do aplikacji kontenera w witrynie Azure Portal.
Wybierz pozycję Skaluj.
Wybierz pozycję Edytuj i wdróż.
Wybierz kartę Skalowanie i repliki .
Wybierz minimalny i maksymalny zakres replik.
Wybierz Dodaj.
W polu Nazwa reguły wprowadź nazwę reguły.
Z listy rozwijanej Typ wybierz pozycję Niestandardowe.

W specyfikacji narzędzia skalowania KEDA znajdź type wartość.

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

W polu Typ reguły niestandardowej wprowadź wartość modułu type skalowania.

W specyfikacji narzędzia skalowania KEDA znajdź metadata wartości.

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

W portalu znajdź sekcję Metadane i wybierz pozycję Dodaj. Wprowadź nazwę i wartość dla każdego elementu w sekcji metadanych specyfikacji KEDA ScaledObject .

Uwierzytelnianie

Używanie wpisów tajnych

W aplikacji kontenera utwórz wpisy tajne, do których chcesz się odwołać.

TriggerAuthentication Znajdź obiekt, do których odwołuje się specyfikacja KEDAScaledObject. Zidentyfikuj TriggerAuthentication każdy secretTargetRef obiekt.

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

W sekcji Uwierzytelnianie wybierz pozycję Dodaj, aby utworzyć wpis dla każdego parametru KEDAsecretTargetRef.

Korzystanie z tożsamości zarządzanej

Uwierzytelnianie tożsamości zarządzanej nie jest obsługiwane w witrynie Azure Portal. Użyj interfejsu wiersza polecenia platformy Azure lub usługi Azure Resource Manager do uwierzytelniania przy użyciu tożsamości zarządzanej.

Domyślna reguła skalowania

Jeśli nie utworzysz reguły skalowania, domyślna reguła skalowania zostanie zastosowana do aplikacji kontenera.

Wyzwalacz	Minimalna liczba replik	Maksymalna liczba replik
HTTP	0	10

Ważne

Upewnij się, że utworzono regułę skalowania lub ustawiono wartość minReplicas 1 lub więcej, jeśli nie włączysz ruchu przychodzącego. Jeśli ruch przychodzący jest wyłączony i nie zdefiniujesz minReplicas reguły skalowania niestandardowego, aplikacja kontenera będzie skalować do zera i nie ma możliwości uruchamiania kopii zapasowej.

Zachowanie skalowania

Zachowanie skalowania ma następujące wartości domyślne:

Parametr	Wartość
Interwał sondowania	30 sekund
Okres schładzania	300 sekund
Skalowanie w górę okna stabilizacji	0 sekund
Skalowanie w dół okna stabilizacji	300 sekund
Krok skalowania w górę	1, 4, 100% bieżącej
Krok skalowania w dół	100% bieżącej
Algorytm skalowania	`desiredReplicas = ceil(currentMetricValue / targetMetricValue)`

Interwał sondowania to częstotliwość wykonywania zapytań dotyczących źródeł zdarzeń przez usługę KEDA. Ta wartość nie ma zastosowania do reguł skalowania HTTP i TCP.
Okres schładzania to czas, o ile po wystąpieniu ostatniego zdarzenia aplikacja przeskaluje w dół do minimalnej liczby replik.
Okno stabilizacji skalowania w górę to czas oczekiwania przed wykonaniem decyzji skalowania w górę po spełnieniu warunków skalowania w górę.
Okno stabilizacji skalowania w dół to czas oczekiwania przed podjęciem decyzji o skalowaniu w dół po spełnieniu warunków skalowania w dół.
Krok skalowania w górę to szybkość dodawania nowych wystąpień. Zaczyna się od 1, 4, 8, 16, 32, ... maksymalnie skonfigurowana maksymalna liczba replik.
Krok skalowania w dół to szybkość usuwania replik. Domyślnie 100% replik, które muszą zostać zamknięte, są usuwane.
Algorytm skalowania to formuła używana do obliczania bieżącej żądanej liczby replik.

Przykład

Dla następującej reguły skalowania:

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

W miarę zwiększania skali aplikacji usługa KEDA zaczyna się od pustej kolejki i wykonuje następujące kroki:

Sprawdź my-queue co 30 sekund.
Jeśli długość kolejki wynosi 0, wróć do (1).
Jeśli długość kolejki wynosi > 0, przeprowadź skalowanie aplikacji do 1.
Jeśli długość kolejki wynosi 50, oblicz wartość desiredReplicas = ceil(50/5) = 10.
Skalowanie aplikacji do min(maxReplicaCount, desiredReplicas, max(4, 2*currentReplicaCount))
Wróć do (1).

Jeśli aplikacja została przeskalowana do maksymalnej liczby replik 20, skalowanie przechodzi przez te same poprzednie kroki. Skalowanie w dół ma miejsce tylko wtedy, gdy warunek został spełniony przez 300 sekund (okno stabilizacji skalowania w dół). Gdy długość kolejki wynosi 0, KEDA czeka na 300 sekund (okres schładzania) przed skalowaniem aplikacji do 0.

Kwestie wymagające rozważenia

W trybie "wiele poprawek" dodanie nowego wyzwalacza skalowania spowoduje utworzenie nowej poprawki aplikacji, ale stara wersja pozostaje dostępna ze starymi regułami skalowania. Użyj strony zarządzania poprawkami, aby zarządzać alokacjami ruchu.
W przypadku skalowania aplikacji do zera nie są naliczane żadne opłaty za użycie. Aby uzyskać więcej informacji o cenach, zobacz Rozliczenia w usłudze Azure Container Apps.
Musisz włączyć ochronę danych dla wszystkich aplikacji platformy .NET w usłudze Azure Container Apps. Aby uzyskać szczegółowe informacje, zobacz Wdrażanie i skalowanie aplikacji ASP.NET Core w usłudze Azure Container Apps .

Znane ograniczenia

Skalowanie w pionie nie jest obsługiwane.
Ilości repliki to kwota docelowa, a nie gwarancja.
Jeśli używasz aktorów Języka Dapr do zarządzania stanami, pamiętaj, że skalowanie do zera nie jest obsługiwane. Język Dapr używa aktorów wirtualnych do zarządzania wywołaniami asynchronicznymi, co oznacza, że ich reprezentacja w pamięci nie jest powiązana z tożsamością ani okresem istnienia.

Następne kroki

Zarządzanie wpisami tajnymi

Udostępnij za pośrednictwem

Ustawianie reguł skalowania w usłudze Azure Container Apps

Definicja skalowania

Reguły skalowania

HTTP

Przykład

TCP

Przykład

Niestandardowy

Przykład

Uwierzytelnianie

Używanie wpisów tajnych

Korzystanie z tożsamości zarządzanej

Uwierzytelnianie

Używanie wpisów tajnych

Korzystanie z tożsamości zarządzanej

Uwierzytelnianie

Używanie wpisów tajnych

Korzystanie z tożsamości zarządzanej

Domyślna reguła skalowania

Zachowanie skalowania

Przykład

Kwestie wymagające rozważenia

Znane ograniczenia

Następne kroki

Opinia

Dodatkowe zasoby