Udostępnij za pośrednictwem


Ustawianie reguł skalowania w usłudze Azure Container Apps

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
  1. Przejdź do aplikacji kontenera w witrynie Azure Portal

  2. Wybierz pozycję Skaluj.

  3. Wybierz pozycję Edytuj i wdróż.

  4. Wybierz kartę Skala .

  5. Wybierz minimalny i maksymalny zakres replik.

    Zrzut ekranu przedstawiający suwak zakresu skalowania usługi Azure Container Apps.

  6. Wybierz Dodaj.

  7. W polu Nazwa reguły wprowadź nazwę reguły.

  8. Z listy rozwijanej Typ wybierz pozycję Skalowanie HTTP.

  9. 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.

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

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  2. 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"
          }
        }
      }
    ]
    ...
    
  3. W specyfikacji narzędzia skalowania KEDA znajdź metadata wartości.

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  4. 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.

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

  2. 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
    
  3. W szablonie usługi ARM dla każdego wpisu tajnego:

    1. Dodaj wpis tajny do tablicy aplikacji kontenera secrets zawierającej nazwę i wartość wpisu tajnego.

    2. 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.

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

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  2. 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"
    
  3. W specyfikacji narzędzia skalowania KEDA znajdź metadata wartości.

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  4. 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

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 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.

  1. 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
    
  2. W aplikacji kontenera utwórz wpisy tajne zgodne z właściwościami secretTargetRef .

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

    1. Utwórz wpis tajny z parametrem --secrets . Jeśli istnieje wiele wpisów tajnych, oddziel je spacją.

    2. 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.

  1. Przejdź do aplikacji kontenera w witrynie Azure Portal.

  2. Wybierz pozycję Skaluj.

  3. Wybierz pozycję Edytuj i wdróż.

  4. Wybierz kartę Skalowanie i repliki .

  5. Wybierz minimalny i maksymalny zakres replik.

    Zrzut ekranu przedstawiający suwak zakresu skalowania usługi Azure Container Apps.

  6. Wybierz Dodaj.

  7. W polu Nazwa reguły wprowadź nazwę reguły.

  8. Z listy rozwijanej Typ wybierz pozycję Niestandardowe.

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

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  10. W polu Typ reguły niestandardowej wprowadź wartość modułu type skalowania.

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

    triggers:
    - type: azure-servicebus
      metadata:
        queueName: my-queue
        namespace: service-bus-namespace
        messageCount: "5"
    
  12. W portalu znajdź sekcję Metadane i wybierz pozycję Dodaj. Wprowadź nazwę i wartość dla każdego elementu w sekcji metadanych specyfikacji KEDA ScaledObject .

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

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

  2. 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
    
  3. 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:

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