Zadania w usłudze Azure Container Apps

Artykuł
04/05/2024

Zadania usługi Azure Container Apps umożliwiają uruchamianie konteneryzowanych zadań wykonywanych przez skończony czas trwania i zakończenie. Za pomocą zadań można wykonywać zadania, takie jak przetwarzanie danych, uczenie maszynowe lub dowolny scenariusz, w którym wymagane jest przetwarzanie na żądanie.

Aplikacje kontenerów i zadania są uruchamiane w tym samym środowisku, co umożliwia udostępnianie możliwości, takich jak sieć i rejestrowanie.

Porównanie aplikacji i zadań kontenera

Istnieją dwa typy zasobów obliczeniowych w usłudze Azure Container Apps: aplikacje i zadania.

Aplikacje to usługi, które działają w sposób ciągły. Jeśli kontener w aplikacji zakończy się niepowodzeniem, zostanie on automatycznie uruchomiony ponownie. Przykładami aplikacji są interfejsy API HTTP, aplikacje internetowe i usługi w tle, które stale przetwarzają dane wejściowe.

Zadania to zadania, które są uruchamiane, uruchamiane przez skończony czas trwania i kończą się po zakończeniu. Każde wykonanie zadania zwykle wykonuje jedną jednostkę pracy. Wykonania zadań są uruchamiane ręcznie, zgodnie z harmonogramem lub w odpowiedzi na zdarzenia. Przykłady zadań obejmują procesy wsadowe uruchamiane na żądanie i zaplanowane zadania.

Przykładowe scenariusze

W poniższej tabeli porównaliśmy typowe scenariusze dotyczące aplikacji i zadań:

Kontener	Zasób obliczeniowy	Uwagi
Serwer HTTP obsługujący zawartość internetową i żądania interfejsu API	Aplikacja	Skonfiguruj regułę skalowania HTTP.
Proces, który generuje raporty finansowe w nocy	Zadanie	Użyj typu zadania Harmonogram i skonfiguruj wyrażenie cron.
Stale uruchomiona usługa, która przetwarza komunikaty z kolejki usługi Azure Service Bus	Aplikacja	Skonfiguruj niestandardową regułę skalowania.
Zadanie, które przetwarza pojedynczy komunikat lub małą partię komunikatów z kolejki platformy Azure i kończy działanie	Zadanie	Użyj typu zadania zdarzenia i skonfiguruj niestandardową regułę skalowania, aby wyzwolić wykonywanie zadań w przypadku komunikatów w kolejce.
Zadanie w tle, które jest wyzwalane na żądanie i kończy działanie po zakończeniu	Zadanie	Użyj typu zadania ręcznego i rozpocznij wykonywanie ręcznie lub programowo przy użyciu interfejsu API.
Własnego modułu uruchamiającego akcje GitHub Actions lub agenta usługi Azure Pipelines	Zadanie	Użyj typu zadania zdarzenia i skonfiguruj funkcję GitHub Actions lub regułę skalowania usługi Azure Pipelines.
Aplikacja usługi Azure Functions	Aplikacja	Wdrażanie usługi Azure Functions w usłudze Container Apps.
Aplikacja sterowana zdarzeniami przy użyciu zestawu SDK usługi Azure WebJobs	Aplikacja	Skonfiguruj regułę skalowania dla każdego źródła zdarzeń.

Pojęcia

Środowisko Container Apps to bezpieczna granica wokół co najmniej jednej aplikacji i zadań kontenera. Zadania obejmują kilka kluczowych pojęć:

Zadanie: Zadanie definiuje konfigurację domyślną używaną dla każdego wykonania zadania. Konfiguracja obejmuje obraz kontenera do użycia, zasoby do przydzielenia i polecenie do uruchomienia.
Wykonanie zadania: wykonanie zadania to pojedyncze uruchomienie zadania wyzwalanego ręcznie, zgodnie z harmonogramem lub w odpowiedzi na zdarzenie.
Replika zadania: typowe wykonanie zadania uruchamia jedną replikę zdefiniowaną przez konfigurację zadania. W zaawansowanych scenariuszach wykonywanie zadania może uruchamiać wiele replik.

Omówienie zadań usługi Azure Container Apps.

Typy wyzwalaczy zadań

Typ wyzwalacza zadania określa sposób uruchamiania zadania. Dostępne są następujące typy wyzwalaczy:

Ręczne: zadania ręczne są wyzwalane na żądanie.
Harmonogram: Zaplanowane zadania są wyzwalane w określonych godzinach i mogą być uruchamiane wielokrotnie.
Zdarzenie: Zadania sterowane zdarzeniami są wyzwalane przez zdarzenia, takie jak komunikat przychodzący do kolejki.

Zadania ręczne

Zadania ręczne są wyzwalane na żądanie przy użyciu interfejsu wiersza polecenia platformy Azure, witryny Azure Portal lub żądania do interfejsu API usługi Azure Resource Manager.

Przykłady zadań ręcznych obejmują:

Jednokrotne przetwarzanie zadań, takich jak migrowanie danych z jednego systemu do innego.
Witryna handlu elektronicznego uruchomiona jako aplikacja kontenera uruchamia wykonywanie zadania w celu przetworzenia spisu po złożeniu zamówienia.

Aby utworzyć zadanie ręczne, użyj typu Manualzadania .

Aby utworzyć zadanie ręczne przy użyciu interfejsu wiersza polecenia platformy Azure, użyj az containerapp job create polecenia . Poniższy przykład tworzy zadanie ręczne o nazwie my-job w grupie zasobów o nazwie i środowisku usługi Container Apps o nazwie my-environmentmy-resource-group :

az containerapp job create \
    --name "my-job" --resource-group "my-resource-group"  --environment "my-environment" \
    --trigger-type "Manual" \
    --replica-timeout 1800 \
    --image "mcr.microsoft.com/k8se/quickstart-jobs:latest" \
    --cpu "0.25" --memory "0.5Gi"

Poniższy przykładowy szablon usługi Azure Resource Manager tworzy zadanie ręczne o nazwie w grupie zasobów o my-job nazwie i środowisku usługi Container Apps o nazwie my-resource-groupmy-environment:

{
    "location": "North Central US",
    "name": "my-job",
    "properties": {
        "configuration": {
            "manualTriggerConfig": {
                "parallelism": 1,
                "replicaCompletionCount": 1
            },
            "replicaRetryLimit": 0,
            "replicaTimeout": 1800,
            "triggerType": "Manual"
        },
        "environmentId": "/subscriptions/<subscription_id>/resourceGroups/my-resource-group/providers/Microsoft.App/managedEnvironments/my-environment",
        "template": {
            "containers": [
                {
                    "image": "mcr.microsoft.com/k8se/quickstart-jobs:latest",
                    "name": "main",
                    "resources": {
                        "cpu": 0.25,
                        "memory": "0.5Gi"
                    }
                }
            ]
        }
    }
}

Aby utworzyć zadanie ręczne przy użyciu witryny Azure Portal, wyszukaj pozycję Zadania aplikacji kontenera w witrynie Azure Portal i wybierz pozycję Utwórz. Określ wartość Manual (Ręczne ) jako typ wyzwalacza.

Wprowadź następujące wartości na karcie Kontenery, aby użyć przykładowego obrazu kontenera.

Ustawienie	Wartość
Nazwisko	main
Źródło obrazu	Usługa Docker Hub lub inne rejestry
Typ obrazu	Public
Serwer logowania rejestru	mcr.microsoft.com
Obraz i tag	k8se/quickstart-jobs:latest
Procesor i pamięć	0,25 rdzeni procesora CPU, 0,5 Gi pamięci lub nowszej

mcr.microsoft.com/k8se/quickstart-jobs:latest Obraz to publiczny przykładowy obraz kontenera, który uruchamia zadanie, które czeka kilka sekund, wyświetla komunikat do konsoli, a następnie kończy działanie. Aby uwierzytelnić się i użyć prywatnego obrazu kontenera, zobacz Kontenery.

Powyższe polecenie tworzy tylko zadanie. Aby rozpocząć wykonywanie zadania, zobacz Uruchamianie wykonywania zadania na żądanie.

Zaplanowane zadania

Aby utworzyć zaplanowane zadanie, użyj typu Schedulezadania .

Zadania usługi Container Apps używają wyrażeń cron do definiowania harmonogramów. Obsługuje standardowy format wyrażenia cron z pięcioma polami minut, godziny, dnia miesiąca, miesiąca i dnia tygodnia. Poniżej przedstawiono przykłady wyrażeń cron:

Expression	opis
`/5 * * *`	Uruchamiany co 5 minut.
`0 /2 * *`	Uruchamiany co dwie godziny.
`0 0 * * *`	Działa codziennie o północy.
`0 0 * * 0`	Uruchamiany w każdą niedzielę o północy.
`0 0 1 * *`	Uruchamiany w pierwszym dniu każdego miesiąca o północy.

Wyrażenia Cron w zaplanowanych zadaniach są oceniane w uniwersalnym czasie koordynowanym (UTC).

Aby utworzyć zaplanowane zadanie przy użyciu interfejsu wiersza polecenia platformy Azure, użyj az containerapp job create polecenia . Poniższy przykład umożliwia utworzenie zaplanowanego zadania o nazwie my-job w grupie zasobów o nazwie i środowisku usługi Container Apps o nazwie my-resource-groupmy-environment:

az containerapp job create \
    --name "my-job" --resource-group "my-resource-group"  --environment "my-environment" \
    --trigger-type "Schedule" \
    --replica-timeout 1800 \
    --image "mcr.microsoft.com/k8se/quickstart-jobs:latest" \
    --cpu "0.25" --memory "0.5Gi" \
    --cron-expression "*/1 * * * *"

{
    "location": "North Central US",
    "name": "my-job",
    "properties": {
        "configuration": {
            "scheduleTriggerConfig": {
                "cronExpression": "*/1 * * * *",
                "parallelism": 1,
                "replicaCompletionCount": 1
            },
            "replicaRetryLimit": 0,
            "replicaTimeout": 1800,
            "triggerType": "Schedule"
        },
        "environmentId": "/subscriptions/<subscription_id>/resourceGroups/my-resource-group/providers/Microsoft.App/managedEnvironments/my-environment",
        "template": {
            "containers": [
                {
                    "image": "mcr.microsoft.com/k8se/quickstart-jobs:latest",
                    "name": "main",
                    "resources": {
                        "cpu": 0.25,
                        "memory": "0.5Gi"
                    }
                }
            ]
        }
    }
}

Aby utworzyć zaplanowane zadanie przy użyciu witryny Azure Portal, wyszukaj pozycję Zadania aplikacji kontenera w witrynie Azure Portal i wybierz pozycję Utwórz. Określ harmonogram jako typ wyzwalacza i zdefiniuj harmonogram za pomocą wyrażenia cron, takiego jak */1 * * * * uruchamianie co minutę.

Wprowadź następujące wartości na karcie Kontenery, aby użyć przykładowego obrazu kontenera.

Ustawienie	Wartość
Nazwisko	main
Źródło obrazu	Usługa Docker Hub lub inne rejestry
Typ obrazu	Public
Serwer logowania rejestru	mcr.microsoft.com
Obraz i tag	k8se/quickstart-jobs:latest
Procesor i pamięć	0,25 rdzeni procesora CPU, 0,5 Gi pamięci lub nowszej

Wyrażenie */1 * * * * cron uruchamia zadanie co minutę.

Zadania sterowane zdarzeniami

Zadania sterowane zdarzeniami są wyzwalane przez zdarzenia z obsługiwanych niestandardowych modułów skalowania. Przykłady zadań sterowanych zdarzeniami obejmują:

Zadanie uruchamiane po dodaniu nowego komunikatu do kolejki, takiej jak Azure Service Bus, Kafka lub RabbitMQ.
Self-hosted GitHub Actions runner lub Azure DevOps agent , który jest uruchamiany, gdy nowe zadanie jest w kolejce w przepływie pracy lub potoku.

Aplikacje kontenerów i zadania sterowane zdarzeniami używają skalowania KEDA . Obaj oceniają reguły skalowania w interwale sondowania w celu mierzenia liczby zdarzeń dla źródła zdarzeń, ale sposób ich używania różni się.

W aplikacji każda replika stale przetwarza zdarzenia, a reguła skalowania określa liczbę replik do uruchomienia w celu spełnienia wymagań. W przypadku zadań sterowanych zdarzeniami każde wykonanie zadania zwykle przetwarza pojedyncze zdarzenie, a reguła skalowania określa liczbę wykonań zadań do uruchomienia.

Używaj zadań, gdy każde zdarzenie wymaga nowego wystąpienia kontenera z dedykowanymi zasobami lub musi działać przez długi czas. Zadania sterowane zdarzeniami są koncepcyjnie podobne do zadań skalowania KEDA.

Aby utworzyć zadanie sterowane zdarzeniami, użyj typu Eventzadania .

Aby utworzyć zadanie sterowane zdarzeniami przy użyciu interfejsu wiersza polecenia platformy Azure, użyj az containerapp job create polecenia . Poniższy przykład tworzy zadanie sterowane zdarzeniami o nazwie my-job w grupie zasobów o nazwie i środowisku usługi Container Apps o nazwie my-resource-groupmy-environment:

az containerapp job create \
    --name "my-job" --resource-group "my-resource-group"  --environment "my-environment" \
    --trigger-type "Event" \
    --replica-timeout 1800 \
    --image "docker.io/myuser/my-event-driven-job:latest" \
    --cpu "0.25" --memory "0.5Gi" \
    --min-executions "0" \
    --max-executions "10" \
    --scale-rule-name "queue" \
    --scale-rule-type "azure-queue" \
    --scale-rule-metadata "accountName=mystorage" "queueName=myqueue" "queueLength=1" \
    --scale-rule-auth "connection=connection-string-secret" \
    --secrets "connection-string-secret=<QUEUE_CONNECTION_STRING>"

W przykładzie skonfigurowana jest reguła skalowania kolejek usługi Azure Storage.

Poniższy przykładowy szablon usługi Azure Resource Manager tworzy zadanie sterowane zdarzeniami o nazwie my-job w grupie zasobów o nazwie i środowisku usługi Container Apps o nazwie my-resource-groupmy-environment:

{
    "location": "North Central US",
    "name": "my-job",
    "properties": {
        "configuration": {
            "eventTriggerConfig": {
                "scale": {
                    "maxExecutions": 10,
                    "minExecutions": 0,
                    "pollingInterval": 15,
                    "rules": [
                        {
                            "auth": [
                                {
                                    "triggerParameter": "connection",
                                    "secretRef": "connection-string-secret"
                                }
                            ],
                            "metadata": {
                                "accountName": "mystorage",
                                "queueLength": 1,
                                "queueName": "myqueue"
                            },
                            "name": "queue",
                            "type": "azure-queue"
                        }
                    ]
                }
            },
            "replicaRetryLimit": 0,
            "replicaTimeout": 1800,
            "triggerType": "Event",
            "secrets": [
                {
                    "name": "connection-string-secret",
                    "value": "<QUEUE_CONNECTION_STRING>"
                }
            ]
        },
        "environmentId": "/subscriptions/<subscription_id>/resourceGroups/my-resource-group/providers/Microsoft.App/managedEnvironments/my-environment",
        "template": {
            "containers": [
                {
                    "image": "docker.io/myuser/my-event-driven-job:latest",
                    "name": "main",
                    "resources": {
                        "cpu": 0.25,
                        "memory": "0.5Gi"
                    }
                }
            ]
        }
    }
}

W przykładzie skonfigurowana jest reguła skalowania kolejek usługi Azure Storage.

Aby zapoznać się z kompletnym samouczkiem, zobacz Wdrażanie zadania sterowanego zdarzeniami.

Uruchamianie wykonywania zadania na żądanie

W przypadku dowolnego typu zadania można uruchomić wykonywanie zadania na żądanie.

Aby rozpocząć wykonywanie zadania przy użyciu interfejsu wiersza polecenia platformy az containerapp job start Azure, użyj polecenia . Poniższy przykład rozpoczyna wykonywanie zadania o nazwie my-job w grupie zasobów o nazwie my-resource-group:

az containerapp job start --name "my-job" --resource-group "my-resource-group"

Aby rozpocząć wykonywanie zadania przy użyciu interfejsu API REST usługi Azure Resource Manager, prześlij POST żądanie do operacji zadania start .

Poniższy przykład rozpoczyna wykonywanie zadania o nazwie my-job w grupie zasobów o nazwie my-resource-group:

POST https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/my-resource-group/providers/Microsoft.App/jobs/my-job/start?api-version=2023-05-01
Authorization: Bearer <TOKEN>

Zastąp <SUBSCRIPTION_ID> ciąg identyfikatorem subskrypcji.

Aby uwierzytelnić żądanie, zastąp <TOKEN> element w nagłówku Authorization prawidłowym tokenem elementu nośnego. Tożsamość używana do generowania tokenu musi mieć Contributor uprawnienia do zasobu zadania Usługi Container Apps. Aby uzyskać więcej informacji, zobacz Dokumentacja interfejsu API REST platformy Azure.

Po uruchomieniu wykonywania zadania możesz zastąpić konfigurację zadania. Można na przykład zastąpić zmienną środowiskową lub polecenie uruchamiania, aby uruchomić to samo zadanie z różnymi danymi wejściowymi. Przesłonięć konfigurację jest używana tylko do bieżącego wykonywania i nie zmienia konfiguracji zadania.

Ważne

Podczas zastępowania konfiguracji cała konfiguracja szablonu zadania jest zastępowana nową konfiguracją. Upewnij się, że nowa konfiguracja zawiera wszystkie wymagane ustawienia.

Aby zastąpić konfigurację zadania podczas uruchamiania wykonywania, użyj az containerapp job start polecenia i przekaż plik YAML zawierający szablon do użycia do wykonania. Poniższy przykład rozpoczyna wykonywanie zadania o nazwie my-job w grupie zasobów o nazwie my-resource-group.

Pobierz bieżącą konfigurację zadania za az containerapp job show pomocą polecenia i zapisz szablon w pliku o nazwie my-job-template.yaml:

az containerapp job show --name "my-job" --resource-group "my-resource-group" --query "properties.template" --output yaml > my-job-template.yaml

Opcja --query "properties.template" zwraca tylko konfigurację szablonu zadania.

Edytuj plik, my-job-template.yaml aby zastąpić konfigurację zadania. Aby na przykład zastąpić zmienne środowiskowe, zmodyfikuj sekcję env :

containers:
- name: print-hello
  image: ubuntu
  resources:
    cpu: 1
    memory: 2Gi
  env:
  - name: MY_NAME
    value: Azure Container Apps jobs
  args:
  - /bin/bash
  - -c
  - echo "Hello, $MY_NAME!"

Uruchom zadanie przy użyciu szablonu:

az containerapp job start --name "my-job" --resource-group "my-resource-group" \
    --yaml my-job-template.yaml

Aby zastąpić konfigurację zadania, dołącz szablon do treści żądania. Poniższy przykład zastępuje polecenie uruchamiania, aby uruchomić inne polecenie:

POST https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/my-resource-group/providers/Microsoft.App/jobs/my-job/start?api-version=2023-05-01
Content-Type: application/json
Authorization: Bearer <TOKEN>

{
    "template": {
        "containers": [
            {
                "image": "mcr.microsoft.com/k8se/quickstart-jobs:latest",
                "name": "main",
                "resources": {
                    "cpu": 0.25,
                    "memory": "0.5Gi"
                },
                "command": [
                    "echo",
                    "Hello, Azure Container Apps jobs!"
                ]
            }
        ]
    }
}

Zastąp <SUBSCRIPTION_ID> ciąg identyfikatorem subskrypcji i <TOKEN> w nagłówku Authorization prawidłowym tokenem elementu nośnego. Tożsamość używana do generowania tokenu musi mieć Contributor uprawnienia do zasobu zadania Usługi Container Apps. Aby uzyskać więcej informacji, zobacz Dokumentacja interfejsu API REST platformy Azure.

Pobieranie historii wykonywania zadania

Każde zadanie usługi Container Apps przechowuje historię ostatnich wykonań zadań.

Aby uzyskać stan wykonywania zadań przy użyciu interfejsu wiersza polecenia platformy Azure, użyj az containerapp job execution list polecenia . Poniższy przykład zwraca stan ostatniego wykonania zadania o nazwie w grupie zasobów o nazwie my-jobmy-resource-group:

az containerapp job execution list --name "my-job" --resource-group "my-resource-group"

Aby uzyskać stan wykonań zadań przy użyciu interfejsu API REST usługi Azure Resource Manager, prześlij GET żądanie do operacji zadania executions . Poniższy przykład zwraca stan ostatniego wykonania zadania o nazwie w grupie zasobów o nazwie my-jobmy-resource-group:

GET https://management.azure.com/subscriptions/<SUBSCRIPTION_ID>/resourceGroups/my-resource-group/providers/Microsoft.App/jobs/my-job/executions?api-version=2023-05-01

Zastąp <SUBSCRIPTION_ID> ciąg identyfikatorem subskrypcji.

Aby uwierzytelnić żądanie, dodaj Authorization nagłówek z prawidłowym tokenem elementu nośnego. Aby uzyskać więcej informacji, zobacz Dokumentacja interfejsu API REST platformy Azure.

Historia wykonywania zaplanowanych i opartych na zdarzeniach zadań jest ograniczona do ostatnich 100 zakończonych pomyślnie i zakończonych niepowodzeniem wykonań zadań.

Aby wyświetlić listę wszystkich wykonań zadania lub uzyskać szczegółowe dane wyjściowe z zadania, wykonaj zapytanie o dostawcę dzienników skonfigurowanego dla środowiska usługi Container Apps.

Konfiguracja zadania zaawansowanego

Zadania usługi Container Apps obsługują zaawansowane opcje konfiguracji, takie jak ustawienia kontenera, ponawianie prób, przekroczenia limitu czasu i równoległość.

Ustawienia kontenerów

Ustawienia kontenera definiują kontenery do uruchomienia w każdej repliki wykonywania zadania. Obejmują one zmienne środowiskowe, wpisy tajne i limity zasobów. Aby uzyskać więcej informacji, zobacz Kontenery. Uruchamianie wielu kontenerów w jednym zadaniu jest zaawansowanym scenariuszem. Większość zadań uruchamia pojedynczy kontener.

Ustawienia zadania

Poniższa tabela zawiera ustawienia zadania, które można skonfigurować:

Ustawienie	Właściwość usługi Azure Resource Manager	Parametr interfejsu wiersza polecenia	opis
Typ zadania	`triggerType`	`--trigger-type`	Typ zadania. (`Manual`, `Schedule`, lub `Event`)
Limit czasu repliki	`replicaTimeout`	`--replica-timeout`	Maksymalny czas w sekundach oczekiwania na ukończenie repliki.
Interwał sondowania	`pollingInterval`	`--polling-interval`	Czas oczekiwania w sekundach między sondowaniem zdarzeń. Wartość domyślna to 30 sekund.
Limit ponawiania prób repliki	`replicaRetryLimit`	`--replica-retry-limit`	Maksymalna liczba ponownych prób ponawiania próby repliki, która zakończyła się niepowodzeniem. Aby zakończyć się niepowodzeniem repliki bez ponawiania próby, ustaw wartość na `0`.
Równoległość	`parallelism`	`--parallelism`	Liczba replik do uruchomienia na wykonanie. W przypadku większości zadań ustaw wartość na `1`.
Liczba uzupełniania repliki	`replicaCompletionCount`	`--replica-completion-count`	Liczba replik, które mają zakończyć się pomyślnie, aby wykonanie zakończyło się pomyślnie. Większość jest równa lub mniejsza niż równoległość. W przypadku większości zadań ustaw wartość na `1`.

Przykład

Poniższy przykład tworzy zadanie z zaawansowanymi opcjami konfiguracji:

az containerapp job create \
    --name "my-job" --resource-group "my-resource-group"  --environment "my-environment" \
    --trigger-type "Schedule" \
    --replica-timeout 1800 --replica-retry-limit 3 --replica-completion-count 5 --parallelism 5 \
    --image "myregistry.azurecr.io/quickstart-jobs:latest" \
    --cpu "0.25" --memory "0.5Gi" \
    --command "/startup.sh" \
    --env-vars "MY_ENV_VAR=my-value" \
    --cron-expression "0 0 * * *"  \
    --registry-server "myregistry.azurecr.io" \
    --registry-username "myregistry" \
    --registry-password "myregistrypassword"

Poniższy przykładowy szablon usługi Azure Resource Manager tworzy zadanie z zaawansowanymi opcjami konfiguracji:

{
    "location": "North Central US",
    "name": "my-job",
    "properties": {
        "configuration": {
            "scheduleTriggerConfig": {
                "cronExpression": "0 0 * * *",
                "parallelism": 5,
                "replicaCompletionCount": 5
            },
            "replicaRetryLimit": 3,
            "replicaTimeout": 1800,
            "triggerType": "Schedule",
            "secrets": [
                {
                    "name": "registry-password",
                    "value": "myregistrypassword"
                }
            ]
            "registries": [
                {
                    "server": "myregistry.azurecr.io",
                    "username": "myregistry",
                    "passwordSecretRef": "registry-password"
                }
            ]
        },
        "environmentId": "/subscriptions/<subscription_id>/resourceGroups/my-resource-group/providers/Microsoft.App/managedEnvironments/my-environment",
        "template": {
            "containers": [
                {
                    "command": [
                        "/startup.sh"
                    ],
                    "cpu": 0.25,
                    "envVars": [
                        {
                            "name": "MY_ENV_VAR",
                            "value": "my-value"
                        }
                    ],
                    "image": "myregistry.azurecr.io/quickstart-jobs:latest",
                    "memory": "0.5Gi",
                    "name": "main",
                    "resources": {
                        "cpu": 0.25,
                        "memory": "0.5Gi"
                    }
                }
            ]
        }
    }
}

Ograniczenia zadań

Następujące funkcje nie są obsługiwane:

Dapr
Ruch przychodzący i powiązane funkcje, takie jak domeny niestandardowe i certyfikaty SSL

Następne kroki

Tworzenie zadania za pomocą usługi Azure Container Apps

Share via