Container Apps - Update

Usługa:

Azure Container Apps

Wersja interfejsu API:

2024-03-01

Aktualizowanie właściwości aplikacji kontenera
Poprawia aplikację kontenera przy użyciu poprawki scalanej JSON

PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.App/containerApps/{containerAppName}?api-version=2024-03-01

Parametry identyfikatora URI

Nazwa	W	Wymagane	Typ	Opis
containerAppName	path	True	string	Nazwa aplikacji kontenera.
resourceGroupName	path	True	string	Nazwa grupy zasobów. W nazwie jest uwzględniana wielkość liter.
subscriptionId	path	True	string	Identyfikator subskrypcji docelowej.
api-version	query	True	string	Wersja interfejsu API do użycia dla tej operacji.

Treść żądania

Nazwa	Wymagane	Typ	Opis
location	True	string	Lokalizacja geograficzna, w której znajduje się zasób
extendedLocation		ExtendedLocation	Typ złożony lokalizacji rozszerzonej.
identity		ManagedServiceIdentity	tożsamości zarządzane dla aplikacji kontenera umożliwiające interakcję z innymi usługami platformy Azure bez konieczności obsługi wpisów tajnych ani poświadczeń w kodzie.
managedBy		string	W pełni kwalifikowany identyfikator zasobu, który zarządza tym zasobem. Wskazuje, czy ten zasób jest zarządzany przez inny zasób platformy Azure. Jeśli jest to obecne, wdrożenie w trybie pełnym nie usunie zasobu, jeśli zostanie on usunięty z szablonu, ponieważ jest on zarządzany przez inny zasób.
properties.configuration		Configuration	Nieobsługiwane właściwości konfiguracji aplikacji kontenera.
properties.environmentId		string	Identyfikator zasobu środowiska.
properties.managedEnvironmentId		string	Przestarzałe. Identyfikator zasobu środowiska aplikacji kontenera.
properties.template		Template	Definicja aplikacji kontenera w wersji.
properties.workloadProfileName		string	Nazwa profilu obciążenia do przypięcia na potrzeby wykonywania aplikacji kontenera.
tags		object	Tagi zasobów.

Odpowiedzi

Nazwa	Typ	Opis
200 OK	ContainerApp	Ok
202 Accepted		Operacja stosowania poprawek jest w toku. Nagłówki Location: string
Other Status Codes	DefaultErrorResponse	Typowa odpowiedź na błąd.

Zabezpieczenia

azure_auth

Przepływ OAuth2 usługi Azure Active Directory

Typ: oauth2
Flow: implicit
Adres URL autoryzacji: https://login.microsoftonline.com/common/oauth2/authorize

Zakresy

Nazwa	Opis
user_impersonation	personifikacja konta użytkownika

Przykłady

Patch Container App

Przykładowe żądanie

HTTP

PATCH https://management.azure.com/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/testcontainerapp0?api-version=2024-03-01

{
  "location": "East US",
  "tags": {
    "tag1": "value1",
    "tag2": "value2"
  },
  "properties": {
    "configuration": {
      "ingress": {
        "external": true,
        "targetPort": 3000,
        "customDomains": [
          {
            "name": "www.my-name.com",
            "bindingType": "SniEnabled",
            "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"
          },
          {
            "name": "www.my-other-name.com",
            "bindingType": "SniEnabled",
            "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com"
          }
        ],
        "traffic": [
          {
            "weight": 100,
            "revisionName": "testcontainerapp0-ab1234",
            "label": "production"
          }
        ],
        "ipSecurityRestrictions": [
          {
            "name": "Allow work IP A subnet",
            "description": "Allowing all IP's within the subnet below to access containerapp",
            "ipAddressRange": "192.168.1.1/32",
            "action": "Allow"
          },
          {
            "name": "Allow work IP B subnet",
            "description": "Allowing all IP's within the subnet below to access containerapp",
            "ipAddressRange": "192.168.1.1/8",
            "action": "Allow"
          }
        ],
        "stickySessions": {
          "affinity": "sticky"
        }
      },
      "dapr": {
        "enabled": true,
        "appPort": 3000,
        "appProtocol": "http",
        "httpReadBufferSize": 30,
        "httpMaxRequestSize": 10,
        "logLevel": "debug",
        "enableApiLogging": true
      },
      "maxInactiveRevisions": 10,
      "service": {
        "type": "redis"
      }
    },
    "template": {
      "containers": [
        {
          "image": "repo/testcontainerapp0:v1",
          "name": "testcontainerapp0",
          "probes": [
            {
              "type": "Liveness",
              "httpGet": {
                "path": "/health",
                "port": 8080,
                "httpHeaders": [
                  {
                    "name": "Custom-Header",
                    "value": "Awesome"
                  }
                ]
              },
              "initialDelaySeconds": 3,
              "periodSeconds": 3
            }
          ]
        }
      ],
      "initContainers": [
        {
          "image": "repo/testcontainerapp0:v4",
          "name": "testinitcontainerApp0",
          "resources": {
            "cpu": 0.5,
            "memory": "1Gi"
          }
        }
      ],
      "scale": {
        "minReplicas": 1,
        "maxReplicas": 5,
        "rules": [
          {
            "name": "httpscalingrule",
            "custom": {
              "type": "http",
              "metadata": {
                "concurrentRequests": "50"
              }
            }
          }
        ]
      },
      "serviceBinds": [
        {
          "serviceId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service",
          "name": "service"
        }
      ]
    }
  }
}

Java

import com.azure.resourcemanager.appcontainers.models.Action;
import com.azure.resourcemanager.appcontainers.models.Affinity;
import com.azure.resourcemanager.appcontainers.models.AppProtocol;
import com.azure.resourcemanager.appcontainers.models.BindingType;
import com.azure.resourcemanager.appcontainers.models.Configuration;
import com.azure.resourcemanager.appcontainers.models.Container;
import com.azure.resourcemanager.appcontainers.models.ContainerApp;
import com.azure.resourcemanager.appcontainers.models.ContainerAppProbe;
import com.azure.resourcemanager.appcontainers.models.ContainerAppProbeHttpGet;
import com.azure.resourcemanager.appcontainers.models.ContainerAppProbeHttpGetHttpHeadersItem;
import com.azure.resourcemanager.appcontainers.models.ContainerResources;
import com.azure.resourcemanager.appcontainers.models.CustomDomain;
import com.azure.resourcemanager.appcontainers.models.CustomScaleRule;
import com.azure.resourcemanager.appcontainers.models.Dapr;
import com.azure.resourcemanager.appcontainers.models.Ingress;
import com.azure.resourcemanager.appcontainers.models.IngressStickySessions;
import com.azure.resourcemanager.appcontainers.models.InitContainer;
import com.azure.resourcemanager.appcontainers.models.IpSecurityRestrictionRule;
import com.azure.resourcemanager.appcontainers.models.LogLevel;
import com.azure.resourcemanager.appcontainers.models.Scale;
import com.azure.resourcemanager.appcontainers.models.ScaleRule;
import com.azure.resourcemanager.appcontainers.models.Service;
import com.azure.resourcemanager.appcontainers.models.ServiceBind;
import com.azure.resourcemanager.appcontainers.models.Template;
import com.azure.resourcemanager.appcontainers.models.TrafficWeight;
import com.azure.resourcemanager.appcontainers.models.Type;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for ContainerApps Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/app/resource-manager/Microsoft.App/stable/2024-03-01/examples/ContainerApps_Patch.json
     */
    /**
     * Sample code: Patch Container App.
     * 
     * @param manager Entry point to ContainerAppsApiManager.
     */
    public static void patchContainerApp(com.azure.resourcemanager.appcontainers.ContainerAppsApiManager manager) {
        ContainerApp resource = manager.containerApps()
            .getByResourceGroupWithResponse("rg", "testcontainerapp0", com.azure.core.util.Context.NONE).getValue();
        resource
            .update().withTags(
                mapOf("tag1", "value1", "tag2", "value2"))
            .withConfiguration(new Configuration().withIngress(new Ingress().withExternal(true).withTargetPort(3000)
                .withTraffic(Arrays.asList(new TrafficWeight().withRevisionName("testcontainerapp0-ab1234")
                    .withWeight(100).withLabel("production")))
                .withCustomDomains(Arrays.asList(new CustomDomain().withName("www.my-name.com")
                    .withBindingType(BindingType.SNI_ENABLED).withCertificateId(
                        "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"),
                    new CustomDomain().withName("www.my-other-name.com").withBindingType(BindingType.SNI_ENABLED)
                        .withCertificateId(
                            "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com")))
                .withIpSecurityRestrictions(Arrays.asList(
                    new IpSecurityRestrictionRule().withName("Allow work IP A subnet")
                        .withDescription("Allowing all IP's within the subnet below to access containerapp")
                        .withIpAddressRange("192.168.1.1/32").withAction(Action.ALLOW),
                    new IpSecurityRestrictionRule().withName("Allow work IP B subnet")
                        .withDescription("Allowing all IP's within the subnet below to access containerapp")
                        .withIpAddressRange("192.168.1.1/8").withAction(Action.ALLOW)))
                .withStickySessions(new IngressStickySessions().withAffinity(Affinity.STICKY)))
                .withDapr(new Dapr().withEnabled(true).withAppProtocol(AppProtocol.HTTP).withAppPort(3000)
                    .withHttpReadBufferSize(30).withHttpMaxRequestSize(10).withLogLevel(LogLevel.DEBUG)
                    .withEnableApiLogging(true))
                .withMaxInactiveRevisions(10).withService(new Service().withType("redis")))
            .withTemplate(
                new Template()
                    .withInitContainers(Arrays.asList(
                        new InitContainer().withImage("repo/testcontainerapp0:v4").withName("testinitcontainerApp0")
                            .withResources(new ContainerResources().withCpu(0.5D).withMemory("1Gi"))))
                    .withContainers(Arrays.asList(new Container().withImage("repo/testcontainerapp0:v1")
                        .withName("testcontainerapp0").withProbes(Arrays.asList(new ContainerAppProbe()
                            .withHttpGet(new ContainerAppProbeHttpGet()
                                .withHttpHeaders(Arrays.asList(new ContainerAppProbeHttpGetHttpHeadersItem()
                                    .withName("Custom-Header").withValue("Awesome")))
                                .withPath("/health").withPort(8080))
                            .withInitialDelaySeconds(3).withPeriodSeconds(3).withType(Type.LIVENESS)))))
                    .withScale(new Scale().withMinReplicas(1).withMaxReplicas(5)
                        .withRules(Arrays.asList(new ScaleRule().withName("httpscalingrule").withCustom(
                            new CustomScaleRule().withType("http").withMetadata(mapOf("concurrentRequests", "50"))))))
                    .withServiceBinds(Arrays.asList(new ServiceBind().withServiceId(
                        "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service")
                        .withName("service"))))
            .apply();
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from typing import Any, IO, Union

from azure.identity import DefaultAzureCredential

from azure.mgmt.appcontainers import ContainerAppsAPIClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-appcontainers
# USAGE
    python container_apps_patch.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = ContainerAppsAPIClient(
        credential=DefaultAzureCredential(),
        subscription_id="34adfa4f-cedf-4dc0-ba29-b6d1a69ab345",
    )

    response = client.container_apps.begin_update(
        resource_group_name="rg",
        container_app_name="testcontainerapp0",
        container_app_envelope={
            "location": "East US",
            "properties": {
                "configuration": {
                    "dapr": {
                        "appPort": 3000,
                        "appProtocol": "http",
                        "enableApiLogging": True,
                        "enabled": True,
                        "httpMaxRequestSize": 10,
                        "httpReadBufferSize": 30,
                        "logLevel": "debug",
                    },
                    "ingress": {
                        "customDomains": [
                            {
                                "bindingType": "SniEnabled",
                                "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com",
                                "name": "www.my-name.com",
                            },
                            {
                                "bindingType": "SniEnabled",
                                "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com",
                                "name": "www.my-other-name.com",
                            },
                        ],
                        "external": True,
                        "ipSecurityRestrictions": [
                            {
                                "action": "Allow",
                                "description": "Allowing all IP's within the subnet below to access containerapp",
                                "ipAddressRange": "192.168.1.1/32",
                                "name": "Allow work IP A subnet",
                            },
                            {
                                "action": "Allow",
                                "description": "Allowing all IP's within the subnet below to access containerapp",
                                "ipAddressRange": "192.168.1.1/8",
                                "name": "Allow work IP B subnet",
                            },
                        ],
                        "stickySessions": {"affinity": "sticky"},
                        "targetPort": 3000,
                        "traffic": [{"label": "production", "revisionName": "testcontainerapp0-ab1234", "weight": 100}],
                    },
                    "maxInactiveRevisions": 10,
                    "service": {"type": "redis"},
                },
                "template": {
                    "containers": [
                        {
                            "image": "repo/testcontainerapp0:v1",
                            "name": "testcontainerapp0",
                            "probes": [
                                {
                                    "httpGet": {
                                        "httpHeaders": [{"name": "Custom-Header", "value": "Awesome"}],
                                        "path": "/health",
                                        "port": 8080,
                                    },
                                    "initialDelaySeconds": 3,
                                    "periodSeconds": 3,
                                    "type": "Liveness",
                                }
                            ],
                        }
                    ],
                    "initContainers": [
                        {
                            "image": "repo/testcontainerapp0:v4",
                            "name": "testinitcontainerApp0",
                            "resources": {"cpu": 0.5, "memory": "1Gi"},
                        }
                    ],
                    "scale": {
                        "maxReplicas": 5,
                        "minReplicas": 1,
                        "rules": [
                            {
                                "custom": {"metadata": {"concurrentRequests": "50"}, "type": "http"},
                                "name": "httpscalingrule",
                            }
                        ],
                    },
                    "serviceBinds": [
                        {
                            "name": "service",
                            "serviceId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service",
                        }
                    ],
                },
            },
            "tags": {"tag1": "value1", "tag2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/app/resource-manager/Microsoft.App/stable/2024-03-01/examples/ContainerApps_Patch.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armappcontainers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/appcontainers/armappcontainers/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/edf14cc0a577f6b9c4e3ce018cec0c383e64b7b0/specification/app/resource-manager/Microsoft.App/stable/2024-03-01/examples/ContainerApps_Patch.json
func ExampleContainerAppsClient_BeginUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armappcontainers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewContainerAppsClient().BeginUpdate(ctx, "rg", "testcontainerapp0", armappcontainers.ContainerApp{
		Location: to.Ptr("East US"),
		Tags: map[string]*string{
			"tag1": to.Ptr("value1"),
			"tag2": to.Ptr("value2"),
		},
		Properties: &armappcontainers.ContainerAppProperties{
			Configuration: &armappcontainers.Configuration{
				Dapr: &armappcontainers.Dapr{
					AppPort:            to.Ptr[int32](3000),
					AppProtocol:        to.Ptr(armappcontainers.AppProtocolHTTP),
					EnableAPILogging:   to.Ptr(true),
					Enabled:            to.Ptr(true),
					HTTPMaxRequestSize: to.Ptr[int32](10),
					HTTPReadBufferSize: to.Ptr[int32](30),
					LogLevel:           to.Ptr(armappcontainers.LogLevelDebug),
				},
				Ingress: &armappcontainers.Ingress{
					CustomDomains: []*armappcontainers.CustomDomain{
						{
							Name:          to.Ptr("www.my-name.com"),
							BindingType:   to.Ptr(armappcontainers.BindingTypeSniEnabled),
							CertificateID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"),
						},
						{
							Name:          to.Ptr("www.my-other-name.com"),
							BindingType:   to.Ptr(armappcontainers.BindingTypeSniEnabled),
							CertificateID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com"),
						}},
					External: to.Ptr(true),
					IPSecurityRestrictions: []*armappcontainers.IPSecurityRestrictionRule{
						{
							Name:           to.Ptr("Allow work IP A subnet"),
							Description:    to.Ptr("Allowing all IP's within the subnet below to access containerapp"),
							Action:         to.Ptr(armappcontainers.ActionAllow),
							IPAddressRange: to.Ptr("192.168.1.1/32"),
						},
						{
							Name:           to.Ptr("Allow work IP B subnet"),
							Description:    to.Ptr("Allowing all IP's within the subnet below to access containerapp"),
							Action:         to.Ptr(armappcontainers.ActionAllow),
							IPAddressRange: to.Ptr("192.168.1.1/8"),
						}},
					StickySessions: &armappcontainers.IngressStickySessions{
						Affinity: to.Ptr(armappcontainers.AffinitySticky),
					},
					TargetPort: to.Ptr[int32](3000),
					Traffic: []*armappcontainers.TrafficWeight{
						{
							Label:        to.Ptr("production"),
							RevisionName: to.Ptr("testcontainerapp0-ab1234"),
							Weight:       to.Ptr[int32](100),
						}},
				},
				MaxInactiveRevisions: to.Ptr[int32](10),
				Service: &armappcontainers.Service{
					Type: to.Ptr("redis"),
				},
			},
			Template: &armappcontainers.Template{
				Containers: []*armappcontainers.Container{
					{
						Name:  to.Ptr("testcontainerapp0"),
						Image: to.Ptr("repo/testcontainerapp0:v1"),
						Probes: []*armappcontainers.ContainerAppProbe{
							{
								Type: to.Ptr(armappcontainers.TypeLiveness),
								HTTPGet: &armappcontainers.ContainerAppProbeHTTPGet{
									Path: to.Ptr("/health"),
									HTTPHeaders: []*armappcontainers.ContainerAppProbeHTTPGetHTTPHeadersItem{
										{
											Name:  to.Ptr("Custom-Header"),
											Value: to.Ptr("Awesome"),
										}},
									Port: to.Ptr[int32](8080),
								},
								InitialDelaySeconds: to.Ptr[int32](3),
								PeriodSeconds:       to.Ptr[int32](3),
							}},
					}},
				InitContainers: []*armappcontainers.InitContainer{
					{
						Name:  to.Ptr("testinitcontainerApp0"),
						Image: to.Ptr("repo/testcontainerapp0:v4"),
						Resources: &armappcontainers.ContainerResources{
							CPU:    to.Ptr[float64](0.5),
							Memory: to.Ptr("1Gi"),
						},
					}},
				Scale: &armappcontainers.Scale{
					MaxReplicas: to.Ptr[int32](5),
					MinReplicas: to.Ptr[int32](1),
					Rules: []*armappcontainers.ScaleRule{
						{
							Name: to.Ptr("httpscalingrule"),
							Custom: &armappcontainers.CustomScaleRule{
								Type: to.Ptr("http"),
								Metadata: map[string]*string{
									"concurrentRequests": to.Ptr("50"),
								},
							},
						}},
				},
				ServiceBinds: []*armappcontainers.ServiceBind{
					{
						Name:      to.Ptr("service"),
						ServiceID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service"),
					}},
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ContainerApp = armappcontainers.ContainerApp{
	// 	Name: to.Ptr("testcontainerapp0"),
	// 	Type: to.Ptr("Microsoft.App/containerApps"),
	// 	ID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/testcontainerapp0"),
	// 	Location: to.Ptr("East US"),
	// 	Properties: &armappcontainers.ContainerAppProperties{
	// 		Configuration: &armappcontainers.Configuration{
	// 			Dapr: &armappcontainers.Dapr{
	// 				AppPort: to.Ptr[int32](3000),
	// 				AppProtocol: to.Ptr(armappcontainers.AppProtocolHTTP),
	// 				EnableAPILogging: to.Ptr(true),
	// 				Enabled: to.Ptr(true),
	// 				HTTPMaxRequestSize: to.Ptr[int32](10),
	// 				HTTPReadBufferSize: to.Ptr[int32](30),
	// 				LogLevel: to.Ptr(armappcontainers.LogLevelDebug),
	// 			},
	// 			Ingress: &armappcontainers.Ingress{
	// 				CustomDomains: []*armappcontainers.CustomDomain{
	// 					{
	// 						Name: to.Ptr("www.my-name.com"),
	// 						BindingType: to.Ptr(armappcontainers.BindingTypeSniEnabled),
	// 						CertificateID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"),
	// 					},
	// 					{
	// 						Name: to.Ptr("www.my--other-name.com"),
	// 						BindingType: to.Ptr(armappcontainers.BindingTypeSniEnabled),
	// 						CertificateID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com"),
	// 				}},
	// 				External: to.Ptr(true),
	// 				Fqdn: to.Ptr("testcontainerapp0.demokube-t24clv0g.eastus.containerApps.k4apps.io"),
	// 				IPSecurityRestrictions: []*armappcontainers.IPSecurityRestrictionRule{
	// 					{
	// 						Name: to.Ptr("Allow work IP A subnet"),
	// 						Description: to.Ptr("Allowing all IP's within the subnet below to access containerapp"),
	// 						Action: to.Ptr(armappcontainers.ActionAllow),
	// 						IPAddressRange: to.Ptr("192.168.1.1/32"),
	// 					},
	// 					{
	// 						Name: to.Ptr("Allow work IP B subnet"),
	// 						Description: to.Ptr("Allowing all IP's within the subnet below to access containerapp"),
	// 						Action: to.Ptr(armappcontainers.ActionAllow),
	// 						IPAddressRange: to.Ptr("192.168.1.1/8"),
	// 				}},
	// 				TargetPort: to.Ptr[int32](3000),
	// 				Traffic: []*armappcontainers.TrafficWeight{
	// 					{
	// 						RevisionName: to.Ptr("testcontainerapp0-ab1234"),
	// 						Weight: to.Ptr[int32](80),
	// 					},
	// 					{
	// 						Label: to.Ptr("staging"),
	// 						RevisionName: to.Ptr("testcontainerapp0-ab4321"),
	// 						Weight: to.Ptr[int32](20),
	// 				}},
	// 				Transport: to.Ptr(armappcontainers.IngressTransportMethodAuto),
	// 			},
	// 			MaxInactiveRevisions: to.Ptr[int32](10),
	// 		},
	// 		EventStreamEndpoint: to.Ptr("testEndpoint"),
	// 		LatestReadyRevisionName: to.Ptr("testcontainerapp0-pjxhsye"),
	// 		LatestRevisionFqdn: to.Ptr("testcontainerapp0-pjxhsye.demokube-t24clv0g.eastus.containerApps.k4apps.io"),
	// 		ManagedEnvironmentID: to.Ptr("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube"),
	// 		ProvisioningState: to.Ptr(armappcontainers.ContainerAppProvisioningStateSucceeded),
	// 		Template: &armappcontainers.Template{
	// 			Containers: []*armappcontainers.Container{
	// 				{
	// 					Name: to.Ptr("testcontainerapp0"),
	// 					Image: to.Ptr("repo/testcontainerapp0:v4"),
	// 					Resources: &armappcontainers.ContainerResources{
	// 						CPU: to.Ptr[float64](0.5),
	// 						Memory: to.Ptr("1Gi"),
	// 					},
	// 			}},
	// 			InitContainers: []*armappcontainers.InitContainer{
	// 				{
	// 					Name: to.Ptr("testinitcontainerApp0"),
	// 					Image: to.Ptr("repo/testcontainerapp0:v4"),
	// 					Resources: &armappcontainers.ContainerResources{
	// 						CPU: to.Ptr[float64](0.5),
	// 						Memory: to.Ptr("1Gi"),
	// 					},
	// 			}},
	// 			Scale: &armappcontainers.Scale{
	// 				MaxReplicas: to.Ptr[int32](5),
	// 				MinReplicas: to.Ptr[int32](1),
	// 				Rules: []*armappcontainers.ScaleRule{
	// 					{
	// 						Name: to.Ptr("httpscalingrule"),
	// 						HTTP: &armappcontainers.HTTPScaleRule{
	// 							Metadata: map[string]*string{
	// 								"concurrentRequests": to.Ptr("50"),
	// 							},
	// 						},
	// 				}},
	// 			},
	// 		},
	// 		WorkloadProfileName: to.Ptr("My-GP-01"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { ContainerAppsAPIClient } = require("@azure/arm-appcontainers");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Patches a Container App using JSON Merge Patch
 *
 * @summary Patches a Container App using JSON Merge Patch
 * x-ms-original-file: specification/app/resource-manager/Microsoft.App/stable/2024-03-01/examples/ContainerApps_Patch.json
 */
async function patchContainerApp() {
  const subscriptionId =
    process.env["APPCONTAINERS_SUBSCRIPTION_ID"] || "34adfa4f-cedf-4dc0-ba29-b6d1a69ab345";
  const resourceGroupName = process.env["APPCONTAINERS_RESOURCE_GROUP"] || "rg";
  const containerAppName = "testcontainerapp0";
  const containerAppEnvelope = {
    configuration: {
      dapr: {
        appPort: 3000,
        appProtocol: "http",
        enableApiLogging: true,
        enabled: true,
        httpMaxRequestSize: 10,
        httpReadBufferSize: 30,
        logLevel: "debug",
      },
      ingress: {
        customDomains: [
          {
            name: "www.my-name.com",
            bindingType: "SniEnabled",
            certificateId:
              "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com",
          },
          {
            name: "www.my-other-name.com",
            bindingType: "SniEnabled",
            certificateId:
              "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com",
          },
        ],
        external: true,
        ipSecurityRestrictions: [
          {
            name: "Allow work IP A subnet",
            description: "Allowing all IP's within the subnet below to access containerapp",
            action: "Allow",
            ipAddressRange: "192.168.1.1/32",
          },
          {
            name: "Allow work IP B subnet",
            description: "Allowing all IP's within the subnet below to access containerapp",
            action: "Allow",
            ipAddressRange: "192.168.1.1/8",
          },
        ],
        stickySessions: { affinity: "sticky" },
        targetPort: 3000,
        traffic: [
          {
            label: "production",
            revisionName: "testcontainerapp0-ab1234",
            weight: 100,
          },
        ],
      },
      maxInactiveRevisions: 10,
      service: { type: "redis" },
    },
    location: "East US",
    tags: { tag1: "value1", tag2: "value2" },
    template: {
      containers: [
        {
          name: "testcontainerapp0",
          image: "repo/testcontainerapp0:v1",
          probes: [
            {
              type: "Liveness",
              httpGet: {
                path: "/health",
                httpHeaders: [{ name: "Custom-Header", value: "Awesome" }],
                port: 8080,
              },
              initialDelaySeconds: 3,
              periodSeconds: 3,
            },
          ],
        },
      ],
      initContainers: [
        {
          name: "testinitcontainerApp0",
          image: "repo/testcontainerapp0:v4",
          resources: { cpu: 0.5, memory: "1Gi" },
        },
      ],
      scale: {
        maxReplicas: 5,
        minReplicas: 1,
        rules: [
          {
            name: "httpscalingrule",
            custom: { type: "http", metadata: { concurrentRequests: "50" } },
          },
        ],
      },
      serviceBinds: [
        {
          name: "service",
          serviceId:
            "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service",
        },
      ],
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new ContainerAppsAPIClient(credential, subscriptionId);
  const result = await client.containerApps.beginUpdateAndWait(
    resourceGroupName,
    containerAppName,
    containerAppEnvelope,
  );
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.AppContainers.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.AppContainers;

// Generated from example definition: specification/app/resource-manager/Microsoft.App/stable/2024-03-01/examples/ContainerApps_Patch.json
// this example is just showing the usage of "ContainerApps_Update" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ContainerAppResource created on azure
// for more information of creating ContainerAppResource, please refer to the document of ContainerAppResource
string subscriptionId = "34adfa4f-cedf-4dc0-ba29-b6d1a69ab345";
string resourceGroupName = "rg";
string containerAppName = "testcontainerapp0";
ResourceIdentifier containerAppResourceId = ContainerAppResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, containerAppName);
ContainerAppResource containerApp = client.GetContainerAppResource(containerAppResourceId);

// invoke the operation
ContainerAppData data = new ContainerAppData(new AzureLocation("East US"))
{
    Configuration = new ContainerAppConfiguration()
    {
        Ingress = new ContainerAppIngressConfiguration()
        {
            External = true,
            TargetPort = 3000,
            Traffic =
            {
            new ContainerAppRevisionTrafficWeight()
            {
            RevisionName = "testcontainerapp0-ab1234",
            Weight = 100,
            Label = "production",
            }
            },
            CustomDomains =
            {
            new ContainerAppCustomDomain("www.my-name.com")
            {
            BindingType = ContainerAppCustomDomainBindingType.SniEnabled,
            CertificateId = new ResourceIdentifier("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"),
            },new ContainerAppCustomDomain("www.my-other-name.com")
            {
            BindingType = ContainerAppCustomDomainBindingType.SniEnabled,
            CertificateId = new ResourceIdentifier("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com"),
            }
            },
            IPSecurityRestrictions =
            {
            new ContainerAppIPSecurityRestrictionRule("Allow work IP A subnet","192.168.1.1/32",ContainerAppIPRuleAction.Allow)
            {
            Description = "Allowing all IP's within the subnet below to access containerapp",
            },new ContainerAppIPSecurityRestrictionRule("Allow work IP B subnet","192.168.1.1/8",ContainerAppIPRuleAction.Allow)
            {
            Description = "Allowing all IP's within the subnet below to access containerapp",
            }
            },
            StickySessionsAffinity = Affinity.Sticky,
        },
        Dapr = new ContainerAppDaprConfiguration()
        {
            IsEnabled = true,
            AppProtocol = ContainerAppProtocol.Http,
            AppPort = 3000,
            HttpReadBufferSize = 30,
            HttpMaxRequestSize = 10,
            LogLevel = ContainerAppDaprLogLevel.Debug,
            IsApiLoggingEnabled = true,
        },
        MaxInactiveRevisions = 10,
        ServiceType = "redis",
    },
    Template = new ContainerAppTemplate()
    {
        InitContainers =
        {
        new ContainerAppInitContainer()
        {
        Image = "repo/testcontainerapp0:v4",
        Name = "testinitcontainerApp0",
        Resources = new AppContainerResources()
        {
        Cpu = 0.5,
        Memory = "1Gi",
        },
        }
        },
        Containers =
        {
        new ContainerAppContainer()
        {
        Probes =
        {
        new ContainerAppProbe()
        {
        HttpGet = new ContainerAppHttpRequestInfo(8080)
        {
        HttpHeaders =
        {
        new ContainerAppHttpHeaderInfo("Custom-Header","Awesome")
        },
        Path = "/health",
        },
        InitialDelaySeconds = 3,
        PeriodSeconds = 3,
        ProbeType = ContainerAppProbeType.Liveness,
        }
        },
        Image = "repo/testcontainerapp0:v1",
        Name = "testcontainerapp0",
        }
        },
        Scale = new ContainerAppScale()
        {
            MinReplicas = 1,
            MaxReplicas = 5,
            Rules =
            {
            new ContainerAppScaleRule()
            {
            Name = "httpscalingrule",
            Custom = new ContainerAppCustomScaleRule()
            {
            CustomScaleRuleType = "http",
            Metadata =
            {
            ["concurrentRequests"] = "50",
            },
            },
            }
            },
        },
        ServiceBinds =
        {
        new ContainerAppServiceBind()
        {
        ServiceId = new ResourceIdentifier("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/service"),
        Name = "service",
        }
        },
    },
    Tags =
    {
    ["tag1"] = "value1",
    ["tag2"] = "value2",
    },
};
ArmOperation<ContainerAppResource> lro = await containerApp.UpdateAsync(WaitUntil.Completed, data);
ContainerAppResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
ContainerAppData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Przykładowa odpowiedź

Kod stanu:

200

{
  "id": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/containerApps/testcontainerapp0",
  "name": "testcontainerapp0",
  "type": "Microsoft.App/containerApps",
  "location": "East US",
  "properties": {
    "provisioningState": "Succeeded",
    "managedEnvironmentId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube",
    "workloadProfileName": "My-GP-01",
    "latestRevisionFqdn": "testcontainerapp0-pjxhsye.demokube-t24clv0g.eastus.containerApps.k4apps.io",
    "latestReadyRevisionName": "testcontainerapp0-pjxhsye",
    "configuration": {
      "ingress": {
        "fqdn": "testcontainerapp0.demokube-t24clv0g.eastus.containerApps.k4apps.io",
        "external": true,
        "targetPort": 3000,
        "transport": "auto",
        "customDomains": [
          {
            "name": "www.my-name.com",
            "bindingType": "SniEnabled",
            "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-name-dot-com"
          },
          {
            "name": "www.my--other-name.com",
            "bindingType": "SniEnabled",
            "certificateId": "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourceGroups/rg/providers/Microsoft.App/managedEnvironments/demokube/certificates/my-certificate-for-my-other-name-dot-com"
          }
        ],
        "traffic": [
          {
            "weight": 80,
            "revisionName": "testcontainerapp0-ab1234"
          },
          {
            "weight": 20,
            "revisionName": "testcontainerapp0-ab4321",
            "label": "staging"
          }
        ],
        "ipSecurityRestrictions": [
          {
            "name": "Allow work IP A subnet",
            "description": "Allowing all IP's within the subnet below to access containerapp",
            "ipAddressRange": "192.168.1.1/32",
            "action": "Allow"
          },
          {
            "name": "Allow work IP B subnet",
            "description": "Allowing all IP's within the subnet below to access containerapp",
            "ipAddressRange": "192.168.1.1/8",
            "action": "Allow"
          }
        ]
      },
      "dapr": {
        "enabled": true,
        "appPort": 3000,
        "appProtocol": "http",
        "httpReadBufferSize": 30,
        "httpMaxRequestSize": 10,
        "logLevel": "debug",
        "enableApiLogging": true
      },
      "maxInactiveRevisions": 10
    },
    "template": {
      "containers": [
        {
          "image": "repo/testcontainerapp0:v4",
          "name": "testcontainerapp0",
          "resources": {
            "cpu": 0.5,
            "memory": "1Gi"
          }
        }
      ],
      "initContainers": [
        {
          "image": "repo/testcontainerapp0:v4",
          "name": "testinitcontainerApp0",
          "resources": {
            "cpu": 0.5,
            "memory": "1Gi"
          }
        }
      ],
      "scale": {
        "minReplicas": 1,
        "maxReplicas": 5,
        "rules": [
          {
            "name": "httpscalingrule",
            "http": {
              "metadata": {
                "concurrentRequests": "50"
              }
            }
          }
        ]
      }
    },
    "eventStreamEndpoint": "testEndpoint"
  }
}

Kod stanu:

202

azure-asyncoperation: https://management.azure.com/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/providers/Microsoft.App/locations/eastus/containerappOperationResults/62e4d893-d233-4005-988e-a428d9f77076?api-version=2024-03-01

Definicje

Nazwa	Opis
action	Zezwalaj na reguły zezwalania lub odmawiania określania dla przychodzącego adresu IP. Uwaga: Reguły mogą składać się tylko ze wszystkich dozwolonych lub WSZYSTKICH odmów
ActiveRevisionsMode	Tryb ActiveRevisionsMode określa sposób obsługi aktywnych poprawek dla aplikacji kontenera: wiele: wiele wersji może być aktywnych.Pojedynczy: tylko jedna poprawka może być aktywna jednocześnie. Wagi poprawek nie mogą być używane w tym trybie. Jeśli nie podano żadnej wartości, jest to wartość domyślna.
affinity	Koligacja sesji sticky
appProtocol	Informuje dapr, którego protokołu używa aplikacja. Prawidłowe opcje to http i grpc. Wartość domyślna to http
bindingType	Custom Domain typ powiązania.
Configuration	Nieobsługiwane właściwości konfiguracji aplikacji kontenera definiujące ustawienia modyfikowalne aplikacji kontenera
Container	Definicja kontenera aplikacji kontenera
ContainerApp	Aplikacja kontenera.
ContainerAppProbe	Sonda opisuje kontrolę kondycji, która ma być wykonywana względem kontenera w celu określenia, czy jest ona aktywna, czy gotowa do odbierania ruchu.
ContainerAppProvisioningState	Stan aprowizacji aplikacji kontenera.
ContainerResources	Wymagania dotyczące zasobów kontenera aplikacji kontenera.
CorsPolicy	Zasady współużytkowania zasobów między źródłami
createdByType	Typ tożsamości, która utworzyła zasób.
CustomDomain	Custom Domain aplikacji kontenera
CustomScaleRule	Niestandardowa reguła skalowania kontenera aplikacji kontenera.
Dapr	Konfiguracja języka Dapr aplikacji kontenera.
DefaultErrorResponse	App Service odpowiedź na błąd.
Details	Szczegóły lub błąd
EnvironmentVar	Zmienna środowiskowa kontenera aplikacji kontenera.
Error	Model błędu.
ExtendedLocation	Typ złożony lokalizacji rozszerzonej.
ExtendedLocationTypes	Typ lokalizacji rozszerzonej.
HttpGet	HttpGet określa żądanie http do wykonania.
HttpHeaders	Nagłówki niestandardowe do ustawienia w żądaniu. Protokół HTTP umożliwia powtarzające się nagłówki.
HttpScaleRule	Reguła skalowania HTTP kontenera aplikacji kontenera.
Ingress	Konfiguracja ruchu przychodzącego aplikacji kontenera.
IngressClientCertificateMode	Tryb certyfikatu klienta na potrzeby uwierzytelniania mTLS. Ignoruj wskazuje, że serwer odrzuca certyfikat klienta podczas przekazywania dalej. Pozycja Accept wskazuje, że serwer przekazuje certyfikat klienta, ale nie wymaga certyfikatu klienta. Pozycja Wymagaj wskazuje, że serwer wymaga certyfikatu klienta.
IngressPortMapping	Mapowania portów ruchu przychodzącego aplikacji kontenera
IngressTransportMethod	Protokół transportu ruchu przychodzącego
InitContainer	Definicja kontenera init aplikacji kontenera
IpSecurityRestrictionRule	Reguła ograniczania przychodzącego adresu IP.
logLevel	Ustawia poziom dziennika dla przyczepki Dapr. Dozwolone wartości to debugowanie, informacje, ostrzeganie, błąd. Wartość domyślna to informacje.
ManagedServiceIdentity	Tożsamość usługi zarządzanej (tożsamości przypisane przez system i/lub przypisane przez użytkownika)
ManagedServiceIdentityType	Typ tożsamości usługi zarządzanej (gdzie dozwolone są typy SystemAssigned i UserAssigned).
QueueScaleRule	Reguła skalowania oparta na kolejce na podstawie kontenera aplikacji kontenera platformy Azure.
RegistryCredentials	Rejestr prywatny aplikacji kontenera
Scale	Konfiguracje skalowania aplikacji kontenera.
ScaleRule	Reguła skalowania kontenera aplikacji kontenera.
ScaleRuleAuth	Wpisy tajne uwierzytelniania dla reguły skalowania
Scheme	Schemat używany do nawiązywania połączenia z hostem. Wartość domyślna to HTTP.
Secret	Definicja wpisu tajnego.
SecretVolumeItem	Wpis tajny do dodania do woluminu.
Service	Aplikacja kontenera, która ma być usługą dewelopera
ServiceBind	Konfiguracja powiązania aplikacji ContainerApp z usługą Dev ContainerApp Service
StickySessions	Sesje sticky dla trybu pojedynczej poprawki
StorageType	Typ magazynu woluminu. Jeśli nie podano, użyj wartości EmptyDir.
systemData	Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.
TcpScaleRule	Reguła skalowania tcp kontenera aplikacji kontenera.
TcpSocket	TcpSocket określa akcję obejmującą port TCP. Punkty zaczepienia TCP nie są jeszcze obsługiwane.
Template	Definicja aplikacji kontenera w wersji. Definiuje żądany stan niezmiennej poprawki. Wszelkie zmiany w tej sekcji spowodują utworzenie nowej poprawki
TrafficWeight	Waga ruchu przypisana do poprawki
Type	Typ sondy.
UserAssignedIdentity	Właściwości tożsamości przypisanej przez użytkownika
Volume	Definicje woluminów dla aplikacji kontenera.
VolumeMount	Instalacja woluminu dla aplikacji kontenera.

action

Zezwalaj na reguły zezwalania lub odmawiania określania dla przychodzącego adresu IP. Uwaga: Reguły mogą składać się tylko ze wszystkich dozwolonych lub WSZYSTKICH odmów

Nazwa	Typ	Opis
Allow	string
Deny	string

ActiveRevisionsMode

Tryb ActiveRevisionsMode określa sposób obsługi aktywnych poprawek dla aplikacji kontenera: wiele: wiele wersji może być aktywnych.Pojedynczy: tylko jedna poprawka może być aktywna jednocześnie. Wagi poprawek nie mogą być używane w tym trybie. Jeśli nie podano żadnej wartości, jest to wartość domyślna.

Nazwa	Typ	Opis
Multiple	string
Single	string

affinity

Koligacja sesji sticky

Nazwa	Typ	Opis
none	string
sticky	string

appProtocol

Informuje dapr, którego protokołu używa aplikacja. Prawidłowe opcje to http i grpc. Wartość domyślna to http

Nazwa	Typ	Opis
grpc	string
http	string

bindingType

Custom Domain typ powiązania.

Nazwa	Typ	Opis
Disabled	string
SniEnabled	string

Configuration

Nieobsługiwane właściwości konfiguracji aplikacji kontenera definiujące ustawienia modyfikowalne aplikacji kontenera

Nazwa	Typ	Domyślna wartość	Opis
activeRevisionsMode	ActiveRevisionsMode	Single	Tryb ActiveRevisionsMode określa sposób obsługi aktywnych poprawek dla aplikacji kontenera: wiele: wiele wersji może być aktywnych.Pojedynczy: tylko jedna poprawka może być aktywna jednocześnie. Wagi poprawek nie mogą być używane w tym trybie. Jeśli nie podano żadnej wartości, jest to wartość domyślna.
dapr	Dapr		Konfiguracja języka Dapr dla aplikacji kontenera.
ingress	Ingress		Konfiguracje ruchu przychodzącego.
maxInactiveRevisions	integer		Opcjonalny. Maksymalna liczba nieaktywnych poprawek, które może mieć aplikacja kontenera.
registries	RegistryCredentials[]		Kolekcja prywatnych poświadczeń rejestru kontenerów dla kontenerów używanych przez aplikację kontenerów
secrets	Secret[]		Zbieranie wpisów tajnych używanych przez aplikację kontenera
service	Service		Aplikacja kontenera, która ma być deweloperem App Service kontenera

Container

Definicja kontenera aplikacji kontenera

Nazwa	Typ	Opis
args	string[]	Argumenty polecenia uruchamiania kontenera.
command	string[]	Polecenie uruchamiania kontenera.
env	EnvironmentVar[]	Zmienne środowiskowe kontenera.
image	string	Tag obrazu kontenera.
name	string	Niestandardowa nazwa kontenera.
probes	ContainerAppProbe[]	Lista sond dla kontenera.
resources	ContainerResources	Wymagania dotyczące zasobów kontenera.
volumeMounts	VolumeMount[]	Instalacja woluminu kontenera.

ContainerApp

Aplikacja kontenera.

Nazwa	Typ	Opis
extendedLocation	ExtendedLocation	Typ złożony lokalizacji rozszerzonej.
id	string	W pełni kwalifikowany identyfikator zasobu dla zasobu. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
identity	ManagedServiceIdentity	tożsamości zarządzane dla aplikacji kontenera umożliwiające interakcję z innymi usługami platformy Azure bez konieczności obsługi wpisów tajnych ani poświadczeń w kodzie.
location	string	Lokalizacja geograficzna, w której znajduje się zasób
managedBy	string	W pełni kwalifikowany identyfikator zasobu, który zarządza tym zasobem. Wskazuje, czy ten zasób jest zarządzany przez inny zasób platformy Azure. Jeśli jest to obecne, wdrożenie w trybie pełnym nie usunie zasobu, jeśli zostanie on usunięty z szablonu, ponieważ jest on zarządzany przez inny zasób.
name	string	Nazwa zasobu
properties.configuration	Configuration	Nieobsługiwane właściwości konfiguracji aplikacji kontenera.
properties.customDomainVerificationId	string	Identyfikator używany do weryfikowania własności nazwy domeny
properties.environmentId	string	Identyfikator zasobu środowiska.
properties.eventStreamEndpoint	string	Punkt końcowy strumienia zdarzeń aplikacji kontenera.
properties.latestReadyRevisionName	string	Nazwa najnowszej gotowej wersji aplikacji kontenera.
properties.latestRevisionFqdn	string	W pełni kwalifikowana nazwa domeny najnowszej wersji aplikacji kontenera.
properties.latestRevisionName	string	Nazwa najnowszej wersji aplikacji kontenera.
properties.managedEnvironmentId	string	Przestarzałe. Identyfikator zasobu środowiska aplikacji kontenera.
properties.outboundIpAddresses	string[]	Wychodzące adresy IP dla aplikacji kontenera.
properties.provisioningState	ContainerAppProvisioningState	Stan aprowizacji aplikacji kontenera.
properties.template	Template	Definicja aplikacji kontenera w wersji.
properties.workloadProfileName	string	Nazwa profilu obciążenia do przypięcia na potrzeby wykonywania aplikacji kontenera.
systemData	systemData	Metadane usługi Azure Resource Manager zawierające informacje createdBy i modifiedBy.
tags	object	Tagi zasobów.
type	string	Typ zasobu. Np. "Microsoft.Compute/virtualMachines" lub "Microsoft.Storage/storageAccounts"

ContainerAppProbe

Sonda opisuje kontrolę kondycji, która ma być wykonywana względem kontenera w celu określenia, czy jest ona aktywna, czy gotowa do odbierania ruchu.

Nazwa	Typ	Opis
failureThreshold	integer	Minimalna liczba kolejnych niepowodzeń dla sondy, które mają zostać uznane za zakończone niepowodzeniem po pomyślnym zakończeniu. Wartość domyślna to 3. Wartość minimalna to 1. Maksymalna wartość to 10.
httpGet	HttpGet	HttpGet określa żądanie http do wykonania.
initialDelaySeconds	integer	Liczba sekund po uruchomieniu kontenera przed zainicjowanymi sondami aktualności. Wartość minimalna to 1. Maksymalna wartość to 60.
periodSeconds	integer	Jak często (w sekundach) wykonać sondę. Wartość domyślna to 10 sekund. Wartość minimalna to 1. Maksymalna wartość to 240.
successThreshold	integer	Minimalna liczba kolejnych sukcesów dla sondy, która ma zostać uznana za pomyślną po nieudanej awarii. Wartość domyślna to 1. Musi być 1 dla utrzymania i uruchamiania. Wartość minimalna to 1. Maksymalna wartość to 10.
tcpSocket	TcpSocket	TcpSocket określa akcję obejmującą port TCP. Punkty zaczepienia TCP nie są jeszcze obsługiwane.
terminationGracePeriodSeconds	integer	Opcjonalny czas trwania w sekundach zasobnika musi zakończyć się bezproblemowo po awarii sondy. Okres prolongaty to czas trwania w sekundach po wysłaniu sygnału zakończenia procesów uruchomionych w zasobniku i czasie, w którym procesy są wymuszone zatrzymane za pomocą sygnału zabijania. Ustaw tę wartość dłużej niż oczekiwany czas oczyszczania procesu. Jeśli ta wartość jest zerowa, zostanie użyte zakończenie zasobnikaGracePeriodSeconds. W przeciwnym razie ta wartość zastępuje wartość podaną przez specyfikację zasobnika. Wartość musi być nie ujemną liczbą całkowitą. Wartość zero wskazuje, że zatrzymaj się natychmiast za pośrednictwem sygnału zabijania (brak możliwości zamknięcia). Jest to pole alfa i wymaga włączenia bramki funkcji ProbeTerminationGracePeriod. Maksymalna wartość to 3600 sekund (1 godzina)
timeoutSeconds	integer	Liczba sekund, po których sonda upłynął limit czasu. Wartość domyślna to 1 sekunda. Wartość minimalna to 1. Maksymalna wartość to 240.
type	Type	Typ sondy.

ContainerAppProvisioningState

Stan aprowizacji aplikacji kontenera.

Nazwa	Typ	Opis
Canceled	string
Deleting	string
Failed	string
InProgress	string
Succeeded	string

ContainerResources

Wymagania dotyczące zasobów kontenera aplikacji kontenera.

Nazwa	Typ	Opis
cpu	number	Wymagany procesor CPU w rdzeniach, np. 0,5
ephemeralStorage	string	Efemeryczny magazyn, np. "1Gi"
memory	string	Wymagana pamięć, np. "250 Mb"

CorsPolicy

Zasady współużytkowania zasobów między źródłami

Nazwa	Typ	Opis
allowCredentials	boolean	Określa, czy zasób zezwala na poświadczenia
allowedHeaders	string[]	Określa zawartość nagłówka access-control-allow-headers
allowedMethods	string[]	Określa zawartość nagłówka access-control-allow-methods
allowedOrigins	string[]	Określa zawartość nagłówka access-control-allow-origins
exposeHeaders	string[]	Określa zawartość nagłówka access-control-expose-headers
maxAge	integer	Określa zawartość nagłówka access-control-max-age

createdByType

Typ tożsamości, która utworzyła zasób.

Nazwa	Typ	Opis
Application	string
Key	string
ManagedIdentity	string
User	string

CustomDomain

Custom Domain aplikacji kontenera

Nazwa	Typ	Opis
bindingType	bindingType	Custom Domain typ powiązania.
certificateId	string	Identyfikator zasobu certyfikatu, który ma być powiązany z tą nazwą hosta. Musi istnieć w środowisku zarządzanym.
name	string	Nazwa hosta.

CustomScaleRule

Niestandardowa reguła skalowania kontenera aplikacji kontenera.

Nazwa	Typ	Opis
auth	ScaleRuleAuth[]	Wpisy tajne uwierzytelniania dla reguły skalowania niestandardowego.
metadata	object	Właściwości metadanych opisujące niestandardową regułę skalowania.
type	string	Typ niestandardowej reguły skalowania, np. azure-servicebus, redis itp.

Dapr

Konfiguracja języka Dapr aplikacji kontenera.

Nazwa	Typ	Domyślna wartość	Opis
appId	string		Identyfikator aplikacji języka Dapr
appPort	integer		Informuje dapr, na którym porcie nasłuchuje aplikacja
appProtocol	appProtocol	http	Informuje dapr, którego protokołu używa aplikacja. Prawidłowe opcje to http i grpc. Wartość domyślna to http
enableApiLogging	boolean		Włącza rejestrowanie interfejsu API dla przyczepki Dapr
enabled	boolean	False	Wartość logiczna wskazująca, czy samochód boczny Dapr jest włączony
httpMaxRequestSize	integer		Zwiększenie maksymalnego rozmiaru treści żądania http i grpc server parametru w MB do obsługi przekazywania dużych plików. Wartość domyślna to 4 MB.
httpReadBufferSize	integer		Maksymalny rozmiar buforu odczytu nagłówka HTTP w bazie wiedzy dapr do obsługi podczas wysyłania nagłówków z wieloma kb. Wartość domyślna to 65 KB.
logLevel	logLevel		Ustawia poziom dziennika dla przyczepki Dapr. Dozwolone wartości to debugowanie, informacje, ostrzeganie, błąd. Wartość domyślna to informacje.

DefaultErrorResponse

App Service odpowiedź na błąd.

Nazwa	Typ	Opis
error	Error	Model błędu.

Details

Szczegóły lub błąd

Nazwa	Typ	Opis
code	string	Ustandaryzowany ciąg w celu programowego identyfikowania błędu.
message	string	Szczegółowy opis błędu i informacje o debugowaniu.
target	string	Szczegółowy opis błędu i informacje o debugowaniu.

EnvironmentVar

Zmienna środowiskowa kontenera aplikacji kontenera.

Nazwa	Typ	Opis
name	string	Nazwa zmiennej środowiskowej.
secretRef	string	Nazwa wpisu tajnego aplikacji kontenera, z którego ma być pobierana wartość zmiennej środowiskowej.
value	string	Wartość zmiennej środowiskowej bez wpisu tajnego.

Error

Model błędu.

Nazwa	Typ	Opis
code	string	Ustandaryzowany ciąg w celu programowego identyfikowania błędu.
details	Details[]	Szczegóły lub błąd
innererror	string	Więcej informacji na temat debugowania błędu.
message	string	Szczegółowy opis błędu i informacje o debugowaniu.
target	string	Szczegółowy opis błędu i informacje o debugowaniu.

ExtendedLocation

Typ złożony lokalizacji rozszerzonej.

Nazwa	Typ	Opis
name	string	Nazwa lokalizacji rozszerzonej.
type	ExtendedLocationTypes	Typ lokalizacji rozszerzonej.

ExtendedLocationTypes

Typ lokalizacji rozszerzonej.

Nazwa	Typ	Opis
CustomLocation	string

HttpGet

HttpGet określa żądanie http do wykonania.

Nazwa	Typ	Opis
host	string	Nazwa hosta, z którymi ma nawiązać połączenie, domyślnie jest to adres IP zasobnika. Prawdopodobnie chcesz ustawić wartość "Host" w elementach httpHeaders.
httpHeaders	HttpHeaders[]	Nagłówki niestandardowe do ustawienia w żądaniu. Protokół HTTP zezwala na powtarzające się nagłówki.
path	string	Ścieżka dostępu do serwera HTTP.
port	integer	Nazwa lub numer portu do uzyskania dostępu do kontenera. Liczba musi należeć do zakresu od 1 do 65535. Nazwa musi być IANA_SVC_NAME.
scheme	Scheme	Schemat używany do nawiązywania połączenia z hostem. Wartość domyślna to HTTP.

HttpHeaders

Nagłówki niestandardowe do ustawienia w żądaniu. Protokół HTTP umożliwia powtarzające się nagłówki.

Nazwa	Typ	Opis
name	string	Nazwa pola nagłówka
value	string	Wartość pola nagłówka

HttpScaleRule

Reguła skalowania HTTP kontenera aplikacji kontenera.

Nazwa	Typ	Opis
auth	ScaleRuleAuth[]	Wpisy tajne uwierzytelniania dla reguły skalowania niestandardowego.
metadata	object	Właściwości metadanych opisujące regułę skalowania http.

Ingress

Konfiguracja ruchu przychodzącego aplikacji kontenera.

Nazwa	Typ	Domyślna wartość	Opis
additionalPortMappings	IngressPortMapping[]		Ustawienia umożliwiające uwidocznienie dodatkowych portów w aplikacji kontenera
allowInsecure	boolean	False	Wartość logiczna wskazująca, czy połączenia HTTP z są dozwolone. W przypadku ustawienia wartości false połączeń HTTP są automatycznie przekierowywane do połączeń HTTPS
clientCertificateMode	IngressClientCertificateMode		Tryb certyfikatu klienta na potrzeby uwierzytelniania mTLS. Ignoruj wskazuje, że serwer odrzuca certyfikat klienta podczas przekazywania dalej. Pozycja Accept wskazuje, że serwer przekazuje certyfikat klienta, ale nie wymaga certyfikatu klienta. Pozycja Wymagaj wskazuje, że serwer wymaga certyfikatu klienta.
corsPolicy	CorsPolicy		Zasady CORS dla aplikacji kontenera
customDomains	CustomDomain[]		niestandardowe powiązania domeny dla nazw hostów usługi Container Apps.
exposedPort	integer		Uwidoczniony port w kontenerach dla ruchu TCP z ruchu przychodzącego
external	boolean	False	Wartość logiczna wskazująca, czy aplikacja uwidacznia zewnętrzny punkt końcowy HTTP
fqdn	string		Nazwa hosta.
ipSecurityRestrictions	IpSecurityRestrictionRule[]		Reguły ograniczania przychodzącego adresu IP.
stickySessions	StickySessions		Sesje sticky dla trybu pojedynczej poprawki
targetPort	integer		Docelowy port w kontenerach dla ruchu przychodzącego
traffic	TrafficWeight[]		Wagi ruchu dla wersji aplikacji
transport	IngressTransportMethod	auto	Protokół transportu ruchu przychodzącego

IngressClientCertificateMode

Tryb certyfikatu klienta na potrzeby uwierzytelniania mTLS. Ignoruj wskazuje, że serwer odrzuca certyfikat klienta podczas przekazywania dalej. Pozycja Accept wskazuje, że serwer przekazuje certyfikat klienta, ale nie wymaga certyfikatu klienta. Pozycja Wymagaj wskazuje, że serwer wymaga certyfikatu klienta.

Nazwa	Typ	Opis
accept	string
ignore	string
require	string

IngressPortMapping

Mapowania portów ruchu przychodzącego aplikacji kontenera

Nazwa	Typ	Opis
exposedPort	integer	Określa uwidoczniony port dla portu docelowego. Jeśli nie zostanie określony, domyślnie jest to port docelowy
external	boolean	Określa, czy port aplikacji jest dostępny poza środowiskiem
targetPort	integer	Określa nasłuchuje kontenera użytkownika portu

IngressTransportMethod

Protokół transportu ruchu przychodzącego

Nazwa	Typ	Opis
auto	string
http	string
http2	string
tcp	string

InitContainer

Definicja kontenera init aplikacji kontenera

Nazwa	Typ	Opis
args	string[]	Argumenty polecenia uruchamiania kontenera.
command	string[]	Polecenie uruchamiania kontenera.
env	EnvironmentVar[]	Zmienne środowiskowe kontenera.
image	string	Tag obrazu kontenera.
name	string	Niestandardowa nazwa kontenera.
resources	ContainerResources	Wymagania dotyczące zasobów kontenera.
volumeMounts	VolumeMount[]	Instalacja woluminu kontenera.

IpSecurityRestrictionRule

Reguła ograniczania przychodzącego adresu IP.

Nazwa	Typ	Opis
action	action	Zezwalaj na reguły zezwalania lub odmowy w celu określenia dla przychodzącego adresu IP. Uwaga: Reguły mogą składać się tylko ze wszystkich dozwolonych lub WSZYSTKICH odmów
description	string	Opisz regułę ograniczeń adresów IP, która jest wysyłana do kontenera-app. Jest to pole opcjonalne.
ipAddressRange	string	Notacja CIDR zgodna z przychodzącym adresem IP
name	string	Nazwa reguły ograniczeń adresów IP.

logLevel

Ustawia poziom dziennika dla przyczepki Dapr. Dozwolone wartości to debugowanie, informacje, ostrzeganie, błąd. Wartość domyślna to informacje.

Nazwa	Typ	Opis
debug	string
error	string
info	string
warn	string

ManagedServiceIdentity

Tożsamość usługi zarządzanej (tożsamości przypisane przez system i/lub przypisane przez użytkownika)

Nazwa	Typ	Opis
principalId	string	Identyfikator jednostki usługi tożsamości przypisanej przez system. Ta właściwość zostanie udostępniona tylko dla tożsamości przypisanej przez system.
tenantId	string	Identyfikator dzierżawy tożsamości przypisanej przez system. Ta właściwość zostanie udostępniona tylko dla tożsamości przypisanej przez system.
type	ManagedServiceIdentityType	Typ tożsamości usługi zarządzanej (gdzie dozwolone są typy SystemAssigned i UserAssigned).
userAssignedIdentities	<string,  UserAssignedIdentity>	tożsamości User-Assigned Zestaw tożsamości przypisanych przez użytkownika skojarzonych z zasobem. Klucze słownika userAssignedIdentities będą identyfikatorami zasobów usługi ARM w postaci: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}. Wartości słownika mogą być pustymi obiektami ({}) w żądaniach.

ManagedServiceIdentityType

Typ tożsamości usługi zarządzanej (gdzie dozwolone są typy SystemAssigned i UserAssigned).

Nazwa	Typ	Opis
None	string
SystemAssigned	string
SystemAssigned,UserAssigned	string
UserAssigned	string

QueueScaleRule

Reguła skalowania oparta na kolejce na podstawie kontenera aplikacji kontenera platformy Azure.

Nazwa	Typ	Opis
auth	ScaleRuleAuth[]	Wpisy tajne uwierzytelniania dla reguły skalowania kolejek.
queueLength	integer	Długość kolejki.
queueName	string	Nazwa kolejki.

RegistryCredentials

Rejestr prywatny aplikacji kontenera

Nazwa	Typ	Opis
identity	string	Tożsamość zarządzana używana do uwierzytelniania za pomocą Azure Container Registry. W przypadku tożsamości przypisanych przez użytkownika użyj pełnego identyfikatora zasobu tożsamości przypisanej przez użytkownika. W przypadku tożsamości przypisanych przez system użyj polecenia "system"
passwordSecretRef	string	Nazwa wpisu tajnego zawierającego hasło logowania rejestru
server	string	Serwer usługi Container Registry
username	string	Nazwa użytkownika usługi Container Registry

Scale

Konfiguracje skalowania aplikacji kontenera.

Nazwa	Typ	Domyślna wartość	Opis
maxReplicas	integer	10	Opcjonalny. Maksymalna liczba replik kontenerów. Wartość domyślna to 10, jeśli nie jest ustawiona.
minReplicas	integer		Opcjonalny. Minimalna liczba replik kontenerów.
rules	ScaleRule[]		Reguły skalowania.

ScaleRule

Reguła skalowania kontenera aplikacji kontenera.

Nazwa	Typ	Opis
azureQueue	QueueScaleRule	Skalowanie oparte na kolejce platformy Azure.
custom	CustomScaleRule	Niestandardowa reguła skalowania.
http	HttpScaleRule	Skalowanie na podstawie żądań HTTP.
name	string	Nazwa reguły skalowania
tcp	TcpScaleRule	Skalowanie oparte na żądaniach TCP.

ScaleRuleAuth

Wpisy tajne uwierzytelniania dla reguły skalowania

Nazwa	Typ	Opis
secretRef	string	Nazwa wpisu tajnego, z którego mają być pobierane parametry uwierzytelniania.
triggerParameter	string	Parametr wyzwalacza, który używa wpisu tajnego

Scheme

Schemat używany do nawiązywania połączenia z hostem. Wartość domyślna to HTTP.

Nazwa	Typ	Opis
HTTP	string
HTTPS	string

Secret

Definicja wpisu tajnego.

Nazwa	Typ	Opis
identity	string	Identyfikator zasobu tożsamości zarządzanej do uwierzytelniania za pomocą usługi Azure Key Vault lub system do używania tożsamości przypisanej przez system.
keyVaultUrl	string	Adres URL usługi Azure Key Vault wskazujący wpis tajny przywołyny przez aplikację kontenera.
name	string	Nazwa wpisu tajnego.
value	string	Wartość wpisu tajnego.

SecretVolumeItem

Wpis tajny do dodania do woluminu.

Nazwa	Typ	Opis
path	string	Ścieżka do wpisu tajnego projektu. Jeśli nie podano żadnej ścieżki, ścieżka jest domyślnie określana jako nazwa wpisu tajnego wymienionego w elemecie secretRef.
secretRef	string	Nazwa wpisu tajnego aplikacji kontenera, z którego ma być pobierana wartość wpisu tajnego.

Service

Aplikacja kontenera, która ma być usługą dewelopera

Nazwa	Typ	Opis
type	string	Typ usługi Dev ContainerApp

ServiceBind

Konfiguracja powiązania aplikacji ContainerApp z usługą Dev ContainerApp Service

Nazwa	Typ	Opis
name	string	Nazwa powiązania usługi
serviceId	string	Identyfikator zasobu usługi docelowej

StickySessions

Sesje sticky dla trybu pojedynczej poprawki

Nazwa	Typ	Opis
affinity	affinity	Koligacja sesji sticky

StorageType

Typ magazynu woluminu. Jeśli nie podano, użyj wartości EmptyDir.

Nazwa	Typ	Opis
AzureFile	string
EmptyDir	string
Secret	string

systemData

Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.

Nazwa	Typ	Opis
createdAt	string	Sygnatura czasowa tworzenia zasobów (UTC).
createdBy	string	Tożsamość, która utworzyła zasób.
createdByType	createdByType	Typ tożsamości, która utworzyła zasób.
lastModifiedAt	string	Sygnatura czasowa ostatniej modyfikacji zasobu (UTC)
lastModifiedBy	string	Tożsamość, która ostatnio zmodyfikowała zasób.
lastModifiedByType	createdByType	Typ tożsamości, która ostatnio zmodyfikowała zasób.

TcpScaleRule

Reguła skalowania tcp kontenera aplikacji kontenera.

Nazwa	Typ	Opis
auth	ScaleRuleAuth[]	Wpisy tajne uwierzytelniania dla reguły skalowania tcp.
metadata	object	Właściwości metadanych opisujące regułę skalowania tcp.

TcpSocket

TcpSocket określa akcję obejmującą port TCP. Punkty zaczepienia TCP nie są jeszcze obsługiwane.

Nazwa	Typ	Opis
host	string	Opcjonalnie: nazwa hosta do nawiązania połączenia domyślnie z adresem IP zasobnika.
port	integer	Numer lub nazwa portu w celu uzyskania dostępu do kontenera. Liczba musi należeć do zakresu od 1 do 65535. Nazwa musi być IANA_SVC_NAME.

Template

Definicja aplikacji kontenera w wersji. Definiuje żądany stan niezmiennej poprawki. Wszelkie zmiany w tej sekcji spowodują utworzenie nowej poprawki

Nazwa	Typ	Opis
containers	Container[]	Lista definicji kontenerów dla aplikacji kontenera.
initContainers	InitContainer[]	Lista wyspecjalizowanych kontenerów uruchamianych przed kontenerami aplikacji.
revisionSuffix	string	Sufiks przyjazny dla użytkownika, który jest dołączany do nazwy poprawki
scale	Scale	Właściwości skalowania dla aplikacji kontenera.
serviceBinds	ServiceBind[]	Lista usług app services kontenera powiązanych z aplikacją
terminationGracePeriodSeconds	integer	Opcjonalny czas trwania w sekundach, przez który wystąpienie aplikacji kontenera musi zostać bezpiecznie zakończone. Wartość musi być nieujemną liczbą całkowitą. Wartość zero wskazuje zatrzymać się natychmiast za pośrednictwem sygnału zabicia (brak możliwości zamknięcia). Jeśli ta wartość jest zerowa, zostanie użyty domyślny okres prolongaty. Ustaw tę wartość dłużej niż oczekiwany czas oczyszczania dla procesu. Wartość domyślna to 30 sekund.
volumes	Volume[]	Lista definicji woluminów dla aplikacji kontenera.

TrafficWeight

Waga ruchu przypisana do poprawki

Nazwa	Typ	Domyślna wartość	Opis
label	string		Kojarzy etykietę ruchu z poprawką
latestRevision	boolean	False	Wskazuje, że waga ruchu należy do najnowszej stabilnej wersji
revisionName	string		Nazwa poprawki
weight	integer		Waga ruchu przypisana do poprawki

Type

Typ sondy.

Nazwa	Typ	Opis
Liveness	string
Readiness	string
Startup	string

UserAssignedIdentity

Właściwości tożsamości przypisanej przez użytkownika

Nazwa	Typ	Opis
clientId	string	Identyfikator klienta przypisanej tożsamości.
principalId	string	Identyfikator podmiotu zabezpieczeń przypisanej tożsamości.

Volume

Definicje woluminów dla aplikacji kontenera.

Nazwa	Typ	Opis
mountOptions	string	Opcje instalacji używane podczas instalowania pliku AzureFile. Musi być ciągiem rozdzielanym przecinkami.
name	string	Nazwa woluminu.
secrets	SecretVolumeItem[]	Lista wpisów tajnych do dodania w woluminie. Jeśli nie podano żadnych wpisów tajnych, wszystkie wpisy tajne w kolekcji zostaną dodane do woluminu.
storageName	string	Nazwa zasobu magazynu. Nie trzeba podawać wartości EmptyDir i Secret.
storageType	StorageType	Typ magazynu dla woluminu. Jeśli nie zostanie podana, użyj wartości EmptyDir.

VolumeMount

Instalacja woluminu dla aplikacji kontenera.

Nazwa	Typ	Opis
mountPath	string	Ścieżka w kontenerze, w którym należy zamontować wolumin. Nie może zawierać elementu ":".
subPath	string	Ścieżka w woluminie, z którego należy zamontować wolumin kontenera. Wartość domyślna to "" (katalog główny woluminu).
volumeName	string	Musi to być zgodne z nazwą woluminu.