Fleet Managed Namespaces - Create Or Update

Služba:

Fleet

Verze rozhraní API:

2026-02-01-preview

Vytvořte FleetManagedNamespace

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerService/fleets/{fleetName}/managedNamespaces/{managedNamespaceName}?api-version=2026-02-01-preview

Parametry identifikátoru URI

Name	V	Vyžadováno	Typ	Description
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Název prostředku Fleet.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Název zdroje spravovaného jmenného prostoru flotily.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Název skupiny prostředků. Název nerozlišuje malá a velká písmena.
subscriptionId	path	True	string (uuid)	ID cílového předplatného. Hodnota musí být UUID.
api-version	query	True	string minLength: 1	Verze rozhraní API, která se má použít pro tuto operaci.

Hlavička požadavku

Name	Vyžadováno	Typ	Description
If-Match		string	Požadavek by měl pokračovat pouze v případě, že entita odpovídá tomuto řetězci.
If-None-Match		string	Požadavek by měl pokračovat pouze v případě, že žádná entita neodpovídá tomuto řetězci.

Text požadavku

Name	Vyžadováno	Typ	Description
location	True	string	Geografické umístění, ve kterém se nachází zdroj
properties		FleetManagedNamespaceProperties	Vlastnosti specifické pro prostředek pro tento prostředek.
tags		object	Značky prostředků

Odpovědi

Name	Typ	Description
200 OK	FleetManagedNamespace	Aktualizace zdroje 'FleetManagedNamespace' byla úspěšná
201 Created	FleetManagedNamespace	Zdroj 'FleetManagedNamespace' vytvořil operaci úspěšnou Hlavičky Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Neočekávaná chybová odpověď

Zabezpečení

azure_auth

Azure Active Directory OAuth2 Flow.

Typ: oauth2
Tok: implicit
URL autorizace: https://login.microsoftonline.com/common/oauth2/authorize

Rozsahy

Name	Description
user_impersonation	zosobnění uživatelského účtu

Příklady

FleetManagedNamespaces_CreateOrUpdate

Ukázkový požadavek

HTTP

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rgfleets/providers/Microsoft.ContainerService/fleets/fleet1/managedNamespaces/namespace1?api-version=2026-02-01-preview

{
  "properties": {
    "managedNamespaceProperties": {
      "labels": {
        "key1": "value1"
      },
      "annotations": {
        "key2": "value2"
      },
      "defaultResourceQuota": {
        "cpuRequest": "1",
        "cpuLimit": "1",
        "memoryRequest": "10Gi",
        "memoryLimit": "32Gi"
      },
      "defaultNetworkPolicy": {
        "ingress": "AllowSameNamespace",
        "egress": "AllowAll"
      }
    },
    "adoptionPolicy": "Never",
    "deletePolicy": "Keep",
    "propagationPolicy": {
      "type": "Placement",
      "placementProfile": {
        "defaultClusterResourcePlacement": {
          "policy": {
            "placementType": "PickAll",
            "affinity": {
              "clusterAffinity": {
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "clusterSelectorTerms": [
                    {
                      "labelSelector": {
                        "matchLabels": {
                          "gpu": "true"
                        },
                        "matchExpressions": [
                          {
                            "key": "region",
                            "operator": "In",
                            "values": [
                              "production1",
                              "production2"
                            ]
                          }
                        ]
                      },
                      "propertySelector": {
                        "matchExpressions": [
                          {
                            "name": "zones",
                            "operator": "Gt",
                            "values": [
                              "1"
                            ]
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            },
            "tolerations": [
              {
                "key": "AIWorkloadOnly",
                "operator": "Exists",
                "value": "true",
                "effect": "NoSchedule"
              }
            ]
          }
        }
      }
    },
    "status": {
      "lastOperationError": {}
    }
  },
  "location": "eastus"
}

Java

import com.azure.resourcemanager.containerservicefleet.models.AdoptionPolicy;
import com.azure.resourcemanager.containerservicefleet.models.Affinity;
import com.azure.resourcemanager.containerservicefleet.models.ClusterAffinity;
import com.azure.resourcemanager.containerservicefleet.models.ClusterResourcePlacementSpec;
import com.azure.resourcemanager.containerservicefleet.models.ClusterSelector;
import com.azure.resourcemanager.containerservicefleet.models.ClusterSelectorTerm;
import com.azure.resourcemanager.containerservicefleet.models.DeletePolicy;
import com.azure.resourcemanager.containerservicefleet.models.LabelSelector;
import com.azure.resourcemanager.containerservicefleet.models.LabelSelectorOperator;
import com.azure.resourcemanager.containerservicefleet.models.LabelSelectorRequirement;
import com.azure.resourcemanager.containerservicefleet.models.ManagedNamespaceProperties;
import com.azure.resourcemanager.containerservicefleet.models.NetworkPolicy;
import com.azure.resourcemanager.containerservicefleet.models.PlacementPolicy;
import com.azure.resourcemanager.containerservicefleet.models.PlacementProfile;
import com.azure.resourcemanager.containerservicefleet.models.PlacementType;
import com.azure.resourcemanager.containerservicefleet.models.PolicyRule;
import com.azure.resourcemanager.containerservicefleet.models.PropagationPolicy;
import com.azure.resourcemanager.containerservicefleet.models.PropagationType;
import com.azure.resourcemanager.containerservicefleet.models.PropertySelector;
import com.azure.resourcemanager.containerservicefleet.models.PropertySelectorOperator;
import com.azure.resourcemanager.containerservicefleet.models.PropertySelectorRequirement;
import com.azure.resourcemanager.containerservicefleet.models.ResourceQuota;
import com.azure.resourcemanager.containerservicefleet.models.TaintEffect;
import com.azure.resourcemanager.containerservicefleet.models.Toleration;
import com.azure.resourcemanager.containerservicefleet.models.TolerationOperator;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for FleetManagedNamespaces CreateOrUpdate.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_CreateOrUpdate.json
     */
    /**
     * Sample code: FleetManagedNamespaces_CreateOrUpdate.
     * 
     * @param manager Entry point to ContainerServiceFleetManager.
     */
    public static void fleetManagedNamespacesCreateOrUpdate(
        com.azure.resourcemanager.containerservicefleet.ContainerServiceFleetManager manager) {
        manager.fleetManagedNamespaces().define("namespace1").withRegion("eastus")
            .withExistingFleet("rgfleets", "fleet1")
            .withManagedNamespaceProperties(new ManagedNamespaceProperties()
                .withLabels(mapOf("key1", "fakeTokenPlaceholder"))
                .withAnnotations(mapOf("key2", "fakeTokenPlaceholder"))
                .withDefaultResourceQuota(new ResourceQuota().withCpuRequest("1").withCpuLimit("1")
                    .withMemoryRequest("10Gi").withMemoryLimit("32Gi"))
                .withDefaultNetworkPolicy(
                    new NetworkPolicy().withIngress(PolicyRule.ALLOW_SAME_NAMESPACE).withEgress(PolicyRule.ALLOW_ALL)))
            .withAdoptionPolicy(AdoptionPolicy.NEVER).withDeletePolicy(DeletePolicy.KEEP)
            .withPropagationPolicy(new PropagationPolicy().withType(PropagationType.PLACEMENT).withPlacementProfile(
                new PlacementProfile().withDefaultClusterResourcePlacement(new ClusterResourcePlacementSpec()
                    .withPolicy(new PlacementPolicy().withPlacementType(PlacementType.PICK_ALL)
                        .withAffinity(new Affinity().withClusterAffinity(
                            new ClusterAffinity().withRequiredDuringSchedulingIgnoredDuringExecution(
                                new ClusterSelector().withClusterSelectorTerms(Arrays.asList(new ClusterSelectorTerm()
                                    .withLabelSelector(new LabelSelector().withMatchLabels(mapOf("gpu", "true"))
                                        .withMatchExpressions(Arrays.asList(new LabelSelectorRequirement()
                                            .withKey("fakeTokenPlaceholder").withOperator(LabelSelectorOperator.IN)
                                            .withValues(Arrays.asList("production1", "production2")))))
                                    .withPropertySelector(new PropertySelector()
                                        .withMatchExpressions(Arrays.asList(new PropertySelectorRequirement()
                                            .withName("zones").withOperator(PropertySelectorOperator.GT)
                                            .withValues(Arrays.asList("1"))))))))))
                        .withTolerations(Arrays.asList(
                            new Toleration().withKey("fakeTokenPlaceholder").withOperator(TolerationOperator.EXISTS)
                                .withValue("true").withEffect(TaintEffect.NO_SCHEDULE)))))))
            .create();
    }

    // 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 azure.identity import DefaultAzureCredential

from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-containerservicefleet
# USAGE
    python fleet_managed_namespaces_create_or_update.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 = ContainerServiceFleetMgmtClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.fleet_managed_namespaces.begin_create_or_update(
        resource_group_name="rgfleets",
        fleet_name="fleet1",
        managed_namespace_name="namespace1",
        resource={
            "location": "eastus",
            "properties": {
                "adoptionPolicy": "Never",
                "deletePolicy": "Keep",
                "managedNamespaceProperties": {
                    "annotations": {"key2": "value2"},
                    "defaultNetworkPolicy": {"egress": "AllowAll", "ingress": "AllowSameNamespace"},
                    "defaultResourceQuota": {
                        "cpuLimit": "1",
                        "cpuRequest": "1",
                        "memoryLimit": "32Gi",
                        "memoryRequest": "10Gi",
                    },
                    "labels": {"key1": "value1"},
                },
                "propagationPolicy": {
                    "placementProfile": {
                        "defaultClusterResourcePlacement": {
                            "policy": {
                                "affinity": {
                                    "clusterAffinity": {
                                        "requiredDuringSchedulingIgnoredDuringExecution": {
                                            "clusterSelectorTerms": [
                                                {
                                                    "labelSelector": {
                                                        "matchExpressions": [
                                                            {
                                                                "key": "region",
                                                                "operator": "In",
                                                                "values": ["production1", "production2"],
                                                            }
                                                        ],
                                                        "matchLabels": {"gpu": "true"},
                                                    },
                                                    "propertySelector": {
                                                        "matchExpressions": [
                                                            {"name": "zones", "operator": "Gt", "values": ["1"]}
                                                        ]
                                                    },
                                                }
                                            ]
                                        }
                                    }
                                },
                                "placementType": "PickAll",
                                "tolerations": [
                                    {
                                        "effect": "NoSchedule",
                                        "key": "AIWorkloadOnly",
                                        "operator": "Exists",
                                        "value": "true",
                                    }
                                ],
                            }
                        }
                    },
                    "type": "Placement",
                },
                "status": {"lastOperationError": {}},
            },
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_CreateOrUpdate.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 armcontainerservicefleet_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/containerservicefleet/armcontainerservicefleet/v3"
)

// Generated from example definition: 2026-02-01-preview/FleetManagedNamespaces_CreateOrUpdate.json
func ExampleFleetManagedNamespacesClient_BeginCreateOrUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcontainerservicefleet.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewFleetManagedNamespacesClient().BeginCreateOrUpdate(ctx, "rgfleets", "fleet1", "namespace1", armcontainerservicefleet.FleetManagedNamespace{
		Properties: &armcontainerservicefleet.FleetManagedNamespaceProperties{
			ManagedNamespaceProperties: &armcontainerservicefleet.ManagedNamespaceProperties{
				Labels: map[string]*string{
					"key1": to.Ptr("value1"),
				},
				Annotations: map[string]*string{
					"key2": to.Ptr("value2"),
				},
				DefaultResourceQuota: &armcontainerservicefleet.ResourceQuota{
					CPURequest:    to.Ptr("1"),
					CPULimit:      to.Ptr("1"),
					MemoryRequest: to.Ptr("10Gi"),
					MemoryLimit:   to.Ptr("32Gi"),
				},
				DefaultNetworkPolicy: &armcontainerservicefleet.NetworkPolicy{
					Ingress: to.Ptr(armcontainerservicefleet.PolicyRuleAllowSameNamespace),
					Egress:  to.Ptr(armcontainerservicefleet.PolicyRuleAllowAll),
				},
			},
			AdoptionPolicy: to.Ptr(armcontainerservicefleet.AdoptionPolicyNever),
			DeletePolicy:   to.Ptr(armcontainerservicefleet.DeletePolicyKeep),
			PropagationPolicy: &armcontainerservicefleet.PropagationPolicy{
				Type: to.Ptr(armcontainerservicefleet.PropagationTypePlacement),
				PlacementProfile: &armcontainerservicefleet.PlacementProfile{
					DefaultClusterResourcePlacement: &armcontainerservicefleet.ClusterResourcePlacementSpec{
						Policy: &armcontainerservicefleet.PlacementPolicy{
							PlacementType: to.Ptr(armcontainerservicefleet.PlacementTypePickAll),
							Affinity: &armcontainerservicefleet.Affinity{
								ClusterAffinity: &armcontainerservicefleet.ClusterAffinity{
									RequiredDuringSchedulingIgnoredDuringExecution: &armcontainerservicefleet.ClusterSelector{
										ClusterSelectorTerms: []*armcontainerservicefleet.ClusterSelectorTerm{
											{
												LabelSelector: &armcontainerservicefleet.LabelSelector{
													MatchLabels: map[string]*string{
														"gpu": to.Ptr("true"),
													},
													MatchExpressions: []*armcontainerservicefleet.LabelSelectorRequirement{
														{
															Key:      to.Ptr("region"),
															Operator: to.Ptr(armcontainerservicefleet.LabelSelectorOperatorIn),
															Values: []*string{
																to.Ptr("production1"),
																to.Ptr("production2"),
															},
														},
													},
												},
												PropertySelector: &armcontainerservicefleet.PropertySelector{
													MatchExpressions: []*armcontainerservicefleet.PropertySelectorRequirement{
														{
															Name:     to.Ptr("zones"),
															Operator: to.Ptr(armcontainerservicefleet.PropertySelectorOperatorGt),
															Values: []*string{
																to.Ptr("1"),
															},
														},
													},
												},
											},
										},
									},
								},
							},
							Tolerations: []*armcontainerservicefleet.Toleration{
								{
									Key:      to.Ptr("AIWorkloadOnly"),
									Operator: to.Ptr(armcontainerservicefleet.TolerationOperatorExists),
									Value:    to.Ptr("true"),
									Effect:   to.Ptr(armcontainerservicefleet.TaintEffectNoSchedule),
								},
							},
						},
					},
				},
			},
			Status: &armcontainerservicefleet.FleetManagedNamespaceStatus{
				LastOperationError: &armcontainerservicefleet.ErrorDetail{},
			},
		},
		Location: to.Ptr("eastus"),
	}, 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 = armcontainerservicefleet.FleetManagedNamespacesClientCreateOrUpdateResponse{
	// 	FleetManagedNamespace: &armcontainerservicefleet.FleetManagedNamespace{
	// 		Properties: &armcontainerservicefleet.FleetManagedNamespaceProperties{
	// 			ManagedNamespaceProperties: &armcontainerservicefleet.ManagedNamespaceProperties{
	// 				Labels: map[string]*string{
	// 					"key1": to.Ptr("value1"),
	// 				},
	// 				Annotations: map[string]*string{
	// 					"key2": to.Ptr("value2"),
	// 				},
	// 				DefaultResourceQuota: &armcontainerservicefleet.ResourceQuota{
	// 					CPURequest: to.Ptr("1"),
	// 					CPULimit: to.Ptr("1"),
	// 					MemoryRequest: to.Ptr("10Gi"),
	// 					MemoryLimit: to.Ptr("32Gi"),
	// 				},
	// 				DefaultNetworkPolicy: &armcontainerservicefleet.NetworkPolicy{
	// 					Ingress: to.Ptr(armcontainerservicefleet.PolicyRuleAllowSameNamespace),
	// 					Egress: to.Ptr(armcontainerservicefleet.PolicyRuleAllowAll),
	// 				},
	// 			},
	// 			AdoptionPolicy: to.Ptr(armcontainerservicefleet.AdoptionPolicyNever),
	// 			DeletePolicy: to.Ptr(armcontainerservicefleet.DeletePolicyKeep),
	// 			PropagationPolicy: &armcontainerservicefleet.PropagationPolicy{
	// 				Type: to.Ptr(armcontainerservicefleet.PropagationTypePlacement),
	// 				PlacementProfile: &armcontainerservicefleet.PlacementProfile{
	// 					DefaultClusterResourcePlacement: &armcontainerservicefleet.ClusterResourcePlacementSpec{
	// 						Policy: &armcontainerservicefleet.PlacementPolicy{
	// 							PlacementType: to.Ptr(armcontainerservicefleet.PlacementTypePickAll),
	// 							Affinity: &armcontainerservicefleet.Affinity{
	// 								ClusterAffinity: &armcontainerservicefleet.ClusterAffinity{
	// 									RequiredDuringSchedulingIgnoredDuringExecution: &armcontainerservicefleet.ClusterSelector{
	// 										ClusterSelectorTerms: []*armcontainerservicefleet.ClusterSelectorTerm{
	// 											{
	// 												LabelSelector: &armcontainerservicefleet.LabelSelector{
	// 													MatchLabels: map[string]*string{
	// 														"gpu": to.Ptr("true"),
	// 													},
	// 													MatchExpressions: []*armcontainerservicefleet.LabelSelectorRequirement{
	// 														{
	// 															Key: to.Ptr("region"),
	// 															Operator: to.Ptr(armcontainerservicefleet.LabelSelectorOperatorIn),
	// 															Values: []*string{
	// 																to.Ptr("production1"),
	// 																to.Ptr("production2"),
	// 															},
	// 														},
	// 													},
	// 												},
	// 												PropertySelector: &armcontainerservicefleet.PropertySelector{
	// 													MatchExpressions: []*armcontainerservicefleet.PropertySelectorRequirement{
	// 														{
	// 															Name: to.Ptr("zones"),
	// 															Operator: to.Ptr(armcontainerservicefleet.PropertySelectorOperatorGt),
	// 															Values: []*string{
	// 																to.Ptr("1"),
	// 															},
	// 														},
	// 													},
	// 												},
	// 											},
	// 										},
	// 									},
	// 								},
	// 							},
	// 							Tolerations: []*armcontainerservicefleet.Toleration{
	// 								{
	// 									Key: to.Ptr("AIWorkloadOnly"),
	// 									Operator: to.Ptr(armcontainerservicefleet.TolerationOperatorExists),
	// 									Value: to.Ptr("true"),
	// 									Effect: to.Ptr(armcontainerservicefleet.TaintEffectNoSchedule),
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 			},
	// 			Status: &armcontainerservicefleet.FleetManagedNamespaceStatus{
	// 				LastOperationError: &armcontainerservicefleet.ErrorDetail{
	// 				},
	// 			},
	// 		},
	// 		ETag: to.Ptr("\"EtagValue\""),
	// 		Location: to.Ptr("eastus"),
	// 		ID: to.Ptr("/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.ContainerService/fleets/fleet1/managedNamespaces/namespace1"),
	// 		Name: to.Ptr("namespace1"),
	// 		Type: to.Ptr("Microsoft.ContainerService/fleets/managedNamespaces"),
	// 		SystemData: &armcontainerservicefleet.SystemData{
	// 			CreatedBy: to.Ptr("someUser"),
	// 			CreatedByType: to.Ptr(armcontainerservicefleet.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-08-23T05:40:40.657Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("someOtherUser"),
	// 			LastModifiedByType: to.Ptr(armcontainerservicefleet.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2025-08-23T05:40:40.657Z"); return t}()),
	// 		},
	// 	},
	// }
}

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 { ContainerServiceFleetClient } = require("@azure/arm-containerservicefleet");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to create a FleetManagedNamespace
 *
 * @summary create a FleetManagedNamespace
 * x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_CreateOrUpdate.json
 */
async function fleetManagedNamespacesCreateOrUpdate() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new ContainerServiceFleetClient(credential, subscriptionId);
  const result = await client.fleetManagedNamespaces.createOrUpdate(
    "rgfleets",
    "fleet1",
    "namespace1",
    {
      managedNamespaceProperties: {
        labels: { key1: "value1" },
        annotations: { key2: "value2" },
        defaultResourceQuota: {
          cpuRequest: "1",
          cpuLimit: "1",
          memoryRequest: "10Gi",
          memoryLimit: "32Gi",
        },
        defaultNetworkPolicy: { ingress: "AllowSameNamespace", egress: "AllowAll" },
      },
      adoptionPolicy: "Never",
      deletePolicy: "Keep",
      propagationPolicy: {
        type: "Placement",
        placementProfile: {
          defaultClusterResourcePlacement: {
            policy: {
              placementType: "PickAll",
              affinity: {
                clusterAffinity: {
                  requiredDuringSchedulingIgnoredDuringExecution: {
                    clusterSelectorTerms: [
                      {
                        labelSelector: {
                          matchLabels: { gpu: "true" },
                          matchExpressions: [
                            {
                              key: "region",
                              operator: "In",
                              values: ["production1", "production2"],
                            },
                          ],
                        },
                        propertySelector: {
                          matchExpressions: [{ name: "zones", operator: "Gt", values: ["1"] }],
                        },
                      },
                    ],
                  },
                },
              },
              tolerations: [
                { key: "AIWorkloadOnly", operator: "Exists", value: "true", effect: "NoSchedule" },
              ],
            },
          },
        },
      },
      location: "eastus",
    },
  );
  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

Ukázková odpověď

Stavový kód:

200

{
  "properties": {
    "managedNamespaceProperties": {
      "labels": {
        "key1": "value1"
      },
      "annotations": {
        "key2": "value2"
      },
      "defaultResourceQuota": {
        "cpuRequest": "1",
        "cpuLimit": "1",
        "memoryRequest": "10Gi",
        "memoryLimit": "32Gi"
      },
      "defaultNetworkPolicy": {
        "ingress": "AllowSameNamespace",
        "egress": "AllowAll"
      }
    },
    "adoptionPolicy": "Never",
    "deletePolicy": "Keep",
    "propagationPolicy": {
      "type": "Placement",
      "placementProfile": {
        "defaultClusterResourcePlacement": {
          "policy": {
            "placementType": "PickAll",
            "affinity": {
              "clusterAffinity": {
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "clusterSelectorTerms": [
                    {
                      "labelSelector": {
                        "matchLabels": {
                          "gpu": "true"
                        },
                        "matchExpressions": [
                          {
                            "key": "region",
                            "operator": "In",
                            "values": [
                              "production1",
                              "production2"
                            ]
                          }
                        ]
                      },
                      "propertySelector": {
                        "matchExpressions": [
                          {
                            "name": "zones",
                            "operator": "Gt",
                            "values": [
                              "1"
                            ]
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            },
            "tolerations": [
              {
                "key": "AIWorkloadOnly",
                "operator": "Exists",
                "value": "true",
                "effect": "NoSchedule"
              }
            ]
          }
        }
      }
    },
    "status": {
      "lastOperationError": {}
    }
  },
  "eTag": "\"EtagValue\"",
  "location": "eastus",
  "id": "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.ContainerService/fleets/fleet1/managedNamespaces/namespace1",
  "name": "namespace1",
  "type": "Microsoft.ContainerService/fleets/managedNamespaces",
  "systemData": {
    "createdBy": "someUser",
    "createdByType": "User",
    "createdAt": "2025-08-23T05:40:40.657Z",
    "lastModifiedBy": "someOtherUser",
    "lastModifiedByType": "User",
    "lastModifiedAt": "2025-08-23T05:40:40.657Z"
  }
}

Stavový kód:

201

Azure-AsyncOperation: https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.ContainerService/locations/eastus/operationResults/00000000-0000-0000-0000-000000000000?api-version=2025-08-01

{
  "properties": {
    "provisioningState": "Succeeded",
    "managedNamespaceProperties": {
      "labels": {
        "key1": "value1"
      },
      "annotations": {
        "key2": "value2"
      },
      "defaultResourceQuota": {
        "cpuRequest": "1",
        "cpuLimit": "1",
        "memoryRequest": "10Gi",
        "memoryLimit": "32Gi"
      },
      "defaultNetworkPolicy": {
        "ingress": "AllowSameNamespace",
        "egress": "AllowAll"
      }
    },
    "adoptionPolicy": "Never",
    "deletePolicy": "Keep",
    "propagationPolicy": {
      "type": "Placement",
      "placementProfile": {
        "defaultClusterResourcePlacement": {
          "policy": {
            "placementType": "PickAll",
            "affinity": {
              "clusterAffinity": {
                "requiredDuringSchedulingIgnoredDuringExecution": {
                  "clusterSelectorTerms": [
                    {
                      "labelSelector": {
                        "matchLabels": {
                          "gpu": "true"
                        },
                        "matchExpressions": [
                          {
                            "key": "region",
                            "operator": "In",
                            "values": [
                              "production1",
                              "production2"
                            ]
                          }
                        ]
                      },
                      "propertySelector": {
                        "matchExpressions": [
                          {
                            "name": "zones",
                            "operator": "Gt",
                            "values": [
                              "1"
                            ]
                          }
                        ]
                      }
                    }
                  ]
                }
              }
            },
            "tolerations": [
              {
                "key": "AIWorkloadOnly",
                "operator": "Exists",
                "value": "true",
                "effect": "NoSchedule"
              }
            ]
          }
        }
      }
    },
    "status": {
      "lastOperationError": {}
    }
  },
  "eTag": "\"EtagValue\"",
  "tags": {
    "tag1": "tagValue1"
  },
  "location": "eastus",
  "id": "/subscriptions/subid1/resourcegroups/rg1/providers/Microsoft.ContainerService/fleets/fleet1/managedNamespaces/namespace1",
  "name": "namespace1",
  "type": "Microsoft.ContainerService/fleets/managedNamespaces",
  "systemData": {
    "createdBy": "someUser",
    "createdByType": "User",
    "createdAt": "2025-08-23T05:40:40.657Z",
    "lastModifiedBy": "someOtherUser",
    "lastModifiedByType": "User",
    "lastModifiedAt": "2025-08-23T05:40:40.657Z"
  }
}

Definice

Name	Description
AdoptionPolicy	Akce, pokud už existuje jmenný prostor se stejným názvem.
createdByType	Typ identity, která prostředek vytvořila.
DeletePolicy	Smazat možnosti pro spravovaný jmenný prostor ARM.
ErrorAdditionalInfo	Další informace o chybě správy prostředků
ErrorDetail	Podrobnosti o chybě.
ErrorResponse	Chybová odpověď
FleetManagedNamespace	Jmenný prostor spravovaný flotilou.
FleetManagedNamespaceProperties	Vlastnosti jmenného prostoru spravovaného flotily.
FleetManagedNamespaceProvisioningState	Stav provisioningu spravovaného jmenného prostoru flotily
FleetManagedNamespaceStatus	Informace o stavu pro jmenný prostor spravovaný flotilou.
LabelSelectorOperator	operátor představuje vztah klíče k sadě hodnot. Platné operátory jsou In, NotIn, Exists a DoesNotExist.
ManagedNamespaceProperties	Vlastnosti jmenného prostoru flotily spravovaly jmenný prostor.
Meta.V1.LabelSelector	Selektor popisků je dotaz popisku nad sadou prostředků. Výsledek matchLabels a matchExpressions jsou ANDed. Prázdný selektor popisku odpovídá všem objektům. Selektor popisků s hodnotou null neodpovídá žádným objektům.
Meta.V1.LabelSelectorRequirement	Požadavek selektoru popisků je selektor, který obsahuje hodnoty, klíč a operátor, který souvisí s klíčem a hodnotami.
NetworkPolicy	Síťová politika pro spravovaný jmenný prostor.
Placement.V1.Affinity	Afinita je skupina pravidel pro plánování afinity ke shluku. Ještě více k doplnění.
Placement.V1.ClusterAffinity	ClusterAffinity obsahuje pravidla pro plánování afinity clusterů pro vybrané zdroje.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec definuje požadovaný stav ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy obsahuje pravidla pro výběr cílových členských klastrů, které umístí vybrané zdroje. Všimněte si, že budou vybrány pouze shluky, které jsou zároveň spojené a splňují pravidla. Můžete specifikovat maximálně jedno ze dvou polí: ClusterNames a Affinity. Pokud není žádný specifikován, jsou vybrány všechny spojené shluky.
Placement.V1.PropertySelector	PropertySelector pomáhá uživateli specifikovat požadavky na vlastnosti při výběru clusterů pro umístění zdrojů.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement je specifický požadavek na vlastnosti při výběru clusterů pro umístění zdrojů.
Placement.V1.Toleration	Tolerance umožňuje ClusterResourcePlacement tolerovat jakýkoli znečištění, které odpovídá efektu <> trojitého klíče, hodnoty, pomocí odpovídajícího <operátoru>.
PlacementProfile	Konfigurační profil pro výchozí ClusterResourcePlacement pro umístění.
PlacementType	Typ umístění. Může to být "PickAll", "PickN" nebo "PickFixed". Výchozí je PickAll.
PolicyRule	Možné hodnoty představují různá pravidla síťové politiky.
PropagationPolicy	Propagace se používá k provisionování jmenného prostoru mezi flotilou.
PropagationType	Jak bude jmenný prostor rozdělen mezi členy flotily.
PropertySelectorOperator	Operátor specifikuje vztah mezi pozorovanou hodnotou specifikované vlastnosti clusteru a hodnotami uvedenými v požadavku.
ResourceQuota	Kvóta zdrojů pro spravovaný jmenný prostor.
systemData	Metadata týkající se vytvoření a poslední změny prostředku.
TaintEffect	Efekt označuje, že efekt kontaminace odpovídá shodě. Prázdné znamená shodu se všemi efekty znečištění. Pokud je specifikováno, povolenou hodnotou je pouze NoSchedule.
TolerationOperator	Operátor představuje vztah klíče k hodnotě. Platné operátory jsou Exists a Equal. Výchozí nastavení je rovné. Exists je ekvivalentní žolíku pro hodnotu, takže ClusterResourcePlacement může tolerovat všechny znečištění určité kategorie.

AdoptionPolicy

Výčet

Akce, pokud už existuje jmenný prostor se stejným názvem.

Hodnota	Description
Never	Pokud jmenný prostor již existuje, nepřebírejte stávající jmenný prostor k správě ARM.
IfIdentical	Pokud existuje identický jmenný prostor, převezměte stávající jmenný prostor spravovaný ARM.
Always	Vždy převezměte stávající jmenný prostor a bude spravován ARM, i když není totožný.

createdByType

Výčet

Typ identity, která prostředek vytvořila.

Hodnota	Description
User
Application
ManagedIdentity
Key

DeletePolicy

Výčet

Smazat možnosti pro spravovaný jmenný prostor ARM.

Hodnota	Description
Keep	Smažte ARM zdroj, ale jmenný prostor si ponecháte.
Delete	Smažte jak ARM zdroje, tak jmenný prostor.

ErrorAdditionalInfo

Objekt

Další informace o chybě správy prostředků

Name	Typ	Description
info	object	Další informace.
type	string	Další typ informací.

ErrorDetail

Objekt

Podrobnosti o chybě.

Name	Typ	Description
additionalInfo	ErrorAdditionalInfo[]	Další informace o chybě.
code	string	Kód chyby.
details	ErrorDetail[]	Podrobnosti o chybě.
message	string	Chybová zpráva.
target	string	Cíl chyby.

ErrorResponse

Objekt

Chybová odpověď

Name	Typ	Description
error	ErrorDetail	Objekt chyby.

FleetManagedNamespace

Objekt

Jmenný prostor spravovaný flotilou.

Name	Typ	Description
eTag	string	Pokud je v textu odpovědi uvedena značka eTag, může být také poskytována jako hlavička podle normální konvence značky etag. Značky entit se používají k porovnání dvou nebo více entit ze stejného požadovaného prostředku. HTTP/1.1 používá značky entit v etagu (oddíl 14.19), If-Match (oddíl 14.24), If-None-Match (oddíl 14.26) a If-Range (oddíl 14.27).
id	string (arm-id)	Plně kvalifikované ID prostředku pro prostředek. Např. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Geografické umístění, ve kterém se nachází zdroj
name	string	Název prostředku
properties	FleetManagedNamespaceProperties	Vlastnosti specifické pro prostředek pro tento prostředek.
systemData	systemData	Metadata služby Azure Resource Manager obsahující informace o tom, kdo jej vytvořil a upravil.
tags	object	Značky prostředků
type	string	Typ prostředku. Například Microsoft.Compute/virtualMachines nebo Microsoft.Storage/storageAccounts

FleetManagedNamespaceProperties

Objekt

Vlastnosti jmenného prostoru spravovaného flotily.

Name	Typ	Description
adoptionPolicy	AdoptionPolicy	Akce, pokud už existuje spravovaný jmenný prostor se stejným názvem. Výchozí je Nikdy.
deletePolicy	DeletePolicy	Smazat možnosti jmenného prostoru spravovaného flotilou. Výchozí je Nechať.
managedNamespaceProperties	ManagedNamespaceProperties	Vlastnosti jmenného prostoru flotily spravovaly jmenný prostor.
portalFqdn	string	Plně kvalifikovaný název domény webu Azure Portal centra Fleet.
propagationPolicy	PropagationPolicy	Profil propagace pro vytvoření jmenného prostoru.
provisioningState	FleetManagedNamespaceProvisioningState	Stav poslední operace.
status	FleetManagedNamespaceStatus	Informace o stavu poslední operace pro jmenný prostor spravovaný flotilou.

FleetManagedNamespaceProvisioningState

Výčet

Stav provisioningu spravovaného jmenného prostoru flotily

Hodnota	Description
Succeeded	Zdroj byl vytvořen.
Failed	Vytvoření zdroje se nezdařilo.
Canceled	Vytváření zdrojů bylo zrušeno.
Creating	Stav provisioningu ve vytváření jmenného prostoru spravovaného flotilou.
Updating	Stav provisioningu jmenného prostoru spravovaného flotilou se aktualizuje.
Deleting	Stav provisioningu spravovaného jmenného prostoru flotily byl smazán.

FleetManagedNamespaceStatus

Objekt

Informace o stavu pro jmenný prostor spravovaný flotilou.

Name	Typ	Description
lastOperationError	ErrorDetail	Poslední chyba provozu spravovaného jmenného prostoru flotily
lastOperationId	string	Poslední operační ID pro spravovaný jmenný prostor flotily

LabelSelectorOperator

Výčet

operátor představuje vztah klíče k sadě hodnot. Platné operátory jsou In, NotIn, Exists a DoesNotExist.

Hodnota	Description
In	Operátor výběru štítků Vstup
NotIn	Operátor výběru štítků NotIn
Exists	Existuje operátor výběru štítků
DoesNotExist	Operátor výběru štítků Neexistuje

ManagedNamespaceProperties

Objekt

Vlastnosti jmenného prostoru flotily spravovaly jmenný prostor.

Name	Typ	Description
annotations	object	Poznámky pro spravovaný jmenný prostor flotily.
defaultNetworkPolicy	NetworkPolicy	Výchozí síťová politika pro spravovaný jmenný prostor flotily.
defaultResourceQuota	ResourceQuota	Výchozí kvóta zdrojů pro spravovaný jmenný prostor flotily.
labels	object	Štítky pro spravovaný jmenný prostor flotily.

Meta.V1.LabelSelector

Objekt

Selektor popisků je dotaz popisku nad sadou prostředků. Výsledek matchLabels a matchExpressions jsou ANDed. Prázdný selektor popisku odpovídá všem objektům. Selektor popisků s hodnotou null neodpovídá žádným objektům.

Name	Typ	Description
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions je seznam požadavků selektoru popisků. Požadavky jsou ANDed.
matchLabels	object	matchLabels je zobrazení párů {key,value}. Jeden {klíč,value} v mapě matchLabels je ekvivalentní elementu matchExpressions, jehož pole klíče je "klíč", operátor je "In" a pole hodnot obsahuje pouze "value". Požadavky jsou ANDed.

Meta.V1.LabelSelectorRequirement

Objekt

Požadavek selektoru popisků je selektor, který obsahuje hodnoty, klíč a operátor, který souvisí s klíčem a hodnotami.

Name	Typ	Description
key	string	key je klávesa popisku, na kterou selektor vztahuje.
operator	LabelSelectorOperator	operátor představuje vztah klíče k sadě hodnot. Platné operátory jsou In, NotIn, Exists a DoesNotExist.
values	string[]	hodnoty jsou pole řetězcových hodnot. Pokud je operátor In nebo NotIn, musí být pole hodnot neprázdné. Pokud je operátor Exists nebo DoesNotExist, musí být pole hodnot prázdné. Toto pole se nahradí během strategické opravy sloučení.

NetworkPolicy

Objekt

Síťová politika pro spravovaný jmenný prostor.

Name	Typ	Description
egress	PolicyRule	Politika odchodu pro spravovaný jmenný prostor.
ingress	PolicyRule	Vstupní politika pro spravovaný jmenný prostor.

Placement.V1.Affinity

Objekt

Afinita je skupina pravidel pro plánování afinity ke shluku. Ještě více k doplnění.

Name	Typ	Description
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity obsahuje pravidla pro plánování afinity clusterů pro vybrané zdroje.

Placement.V1.ClusterAffinity

Objekt

ClusterAffinity obsahuje pravidla pro plánování afinity clusterů pro vybrané zdroje.

Name	Typ	Description
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Pokud nejsou požadavky na afinitu stanovené tímto polem splněny při plánování, zdroj nebude zařazen do clusteru. Pokud požadavky na afinitu stanovené tímto polem přestanou být po umístění splněny (například kvůli aktualizaci), systém se může, ale nemusí pokusit o odstranění zdroje z clusteru.

Placement.V1.ClusterResourcePlacementSpec

Objekt

ClusterResourcePlacementSpec definuje požadovaný stav ClusterResourcePlacement.

Name	Typ	Description
policy	Placement.V1.PlacementPolicy	Politika definuje, jak vybírat členské klastry pro umístění vybraných zdrojů. Pokud není specifikováno, jsou vybrány všechny spojené členské klastry.

Placement.V1.ClusterSelector

Objekt

ClusterSelector

Name	Typ	Description
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms je seznam pojmů pro výběr clusterů. Termíny jsou ORed.

Placement.V1.ClusterSelectorTerm

Objekt

ClusterSelectorTerm

Name	Typ	Description
labelSelector	Meta.V1.LabelSelector	LabelSelector je dotaz na štítky přes všechny spojené členské klastry. Jsou vybrány shluky odpovídající dotazu. Pokud v jednom termínu zadáte jak výběr štítků, tak vlastnosti, výsledky jsou AND'd.
propertySelector	Placement.V1.PropertySelector	PropertySelector je dotaz na vlastnosti nad všemi spojenými členskými klastry. Jsou vybrány shluky odpovídající dotazu. Pokud v jednom termínu zadáte jak výběr štítků, tak vlastnosti, výsledky jsou AND'd. V tuto chvíli lze PropertySelector používat pouze s affinity termíny RequiredDuringSchedulingIgnoredDuringExecution . Tento obor je na úrovni beta; Je určena pro funkci plánování založeného na vlastnostech a funguje pouze tehdy, když je v nasazení povolen poskytovatel vlastností.

Placement.V1.PlacementPolicy

Objekt

PlacementPolicy obsahuje pravidla pro výběr cílových členských klastrů, které umístí vybrané zdroje. Všimněte si, že budou vybrány pouze shluky, které jsou zároveň spojené a splňují pravidla. Můžete specifikovat maximálně jedno ze dvou polí: ClusterNames a Affinity. Pokud není žádný specifikován, jsou vybrány všechny spojené shluky.

Name	Typ	Description
affinity	Placement.V1.Affinity	Affinity obsahuje pravidla pro plánování afinity clusterů. Definuje, které členské klastry umístit vybrané zdroje. Platí pouze pokud je typ umístění "PickAll" nebo "PickN".
clusterNames	string[]	ClusterNames obsahuje seznam názvů MemberCluster pro umístění vybraných zdrojů. Platí pouze pokud je typ umístění "PickFixed"
placementType	PlacementType	Typ umístění. Může to být "PickAll", "PickN" nebo "PickFixed". Výchozí je PickAll.
tolerations	Placement.V1.Toleration[]	Pokud je specifikováno, tolerance ClusterResourcePlacement. Tolerance nelze aktualizovat ani mazat. Toto pole je na úrovni beta a je určeno pro funkce kontaminace a tolerance.

Placement.V1.PropertySelector

Objekt

PropertySelector pomáhá uživateli specifikovat požadavky na vlastnosti při výběru clusterů pro umístění zdrojů.

Name	Typ	Description
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions je pole požadavků PropertySelector. Požadavky jsou A splněné.

Placement.V1.PropertySelectorRequirement

Objekt

PropertySelectorRequirement je specifický požadavek na vlastnosti při výběru clusterů pro umístění zdrojů.

Name	Typ	Description
name	string	Název je název nemovitosti; mělo by to být jméno štítku Kubernetes.
operator	PropertySelectorOperator	Operátor specifikuje vztah mezi pozorovanou hodnotou specifikované vlastnosti clusteru a hodnotami uvedenými v požadavku.
values	string[]	Hodnoty jsou seznamem hodnot specifikované vlastnosti, které Fleet porovná s pozorovanými hodnotami jednotlivých členských klastrů v souladu s daným operátorem. V tuto chvíli by každá hodnota měla být Kubernetes veličina. Další informace najdete na webu https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Pokud je operátor Gt (větší než), Ge (větší nebo rovno), Lt (menší než), nebo Le (menší nebo rovno), Eq (rovno) nebo Ne (ne), musí být v seznamu uvedena přesně jedna hodnota.

Placement.V1.Toleration

Objekt

Tolerance umožňuje ClusterResourcePlacement tolerovat jakýkoli znečištění, které odpovídá efektu <> trojitého klíče, hodnoty, pomocí odpovídajícího <operátoru>.

Name	Typ	Description
effect	TaintEffect	Efekt označuje, že efekt kontaminace odpovídá shodě. Prázdné znamená shodu se všemi efekty znečištění. Pokud je specifikováno, povolenou hodnotou je pouze NoSchedule.
key	string	Klíčem je znečištěný klíč, na který se tolerance vztahuje. Empty znamená shodu se všemi taint klíči. Pokud je klíč prázdný, operátor musí být Exists; tato kombinace znamená shodu se všemi hodnotami a všemi klíči.
operator	TolerationOperator	Operátor představuje vztah klíče k hodnotě. Platné operátory jsou Exists a Equal. Výchozí nastavení je rovné. Exists je ekvivalentní žolíku pro hodnotu, takže ClusterResourcePlacement může tolerovat všechny znečištění určité kategorie.
value	string	Hodnota je znečištěná hodnota, které tolerance odpovídá. Pokud je operátor Exists, hodnota by měla být prázdná, jinak jen běžný řetězec.

PlacementProfile

Objekt

Konfigurační profil pro výchozí ClusterResourcePlacement pro umístění.

Name	Typ	Description
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	Výchozí konfigurace politiky ClusterResourcePlacement.

PlacementType

Výčet

Typ umístění. Může to být "PickAll", "PickN" nebo "PickFixed". Výchozí je PickAll.

Hodnota	Description
PickAll	PickAll vybírá všechny shluky, které splňují pravidla.
PickFixed	PickFixed vybírá pevnou sadu clusterů.

PolicyRule

Výčet

Možné hodnoty představují různá pravidla síťové politiky.

Hodnota	Description
AllowAll	Povolit veškerý síťový provoz.
DenyAll	Zakázat veškerý síťový provoz.
AllowSameNamespace	Povolí přenosy v rámci stejného oboru názvů.

PropagationPolicy

Objekt

Propagace se používá k provisionování jmenného prostoru mezi flotilou.

Name	Typ	Description
placementProfile	PlacementProfile	Profil určený pro šíření pomocí umístění.
type	PropagationType	Typ pojistky, která se má použít. Výchozí je umístění.

PropagationType

Výčet

Jak bude jmenný prostor rozdělen mezi členy flotily.

Hodnota	Description
Placement	Používám ClusterResourcePlacement.

PropertySelectorOperator

Výčet

Operátor specifikuje vztah mezi pozorovanou hodnotou specifikované vlastnosti clusteru a hodnotami uvedenými v požadavku.

Hodnota	Description
Gt	GT určuje flotile, aby vybrala cluster, pokud je jeho pozorovaná hodnota dané vlastnosti větší než hodnota specifikovaná v požadavku.
Ge	Ge určuje flotile, aby vybrala cluster, pokud je jeho pozorovaná hodnota dané vlastnosti větší nebo rovna hodnotě uvedené v požadavku.
Eq	Rovnice určuje Fleetu vybrat cluster, pokud je jeho pozorovaná hodnota dané vlastnosti rovna hodnotám uvedeným v požadavku.
Ne	Ne určuje Fleet, aby vybral cluster, pokud jeho pozorovaná hodnota dané vlastnosti není rovna hodnotám uvedeným v požadavku.
Lt	Lt určuje flotile, aby vybrala klastr, pokud je její pozorovaná hodnota dané vlastnosti menší než hodnota uvedená v požadavku.
Le	Le určuje Fleet, aby vybral cluster, pokud je jeho pozorovaná hodnota dané vlastnosti menší nebo rovna hodnotě uvedené v požadavku.

ResourceQuota

Objekt

Kvóta zdrojů pro spravovaný jmenný prostor.

Name	Typ	Description
cpuLimit	string	Limit CPU pro spravovaný jmenný prostor. Zobrazit více na adrese https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	CPU požaduje spravovaný jmenný prostor. Zobrazit více na adrese https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	Limit paměti pro spravovaný jmenný prostor. Zobrazit více na adrese https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	Požadavek na paměť pro spravovaný jmenný prostor. Zobrazit více na adrese https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Objekt

Metadata týkající se vytvoření a poslední změny prostředku.

Name	Typ	Description
createdAt	string (date-time)	Časové razítko vytvoření prostředku (UTC).
createdBy	string	Identita, která prostředek vytvořila.
createdByType	createdByType	Typ identity, která prostředek vytvořila.
lastModifiedAt	string (date-time)	Časové razítko poslední změny zdroje (UTC)
lastModifiedBy	string	Identita, která naposledy změnila prostředek.
lastModifiedByType	createdByType	Typ identity, která naposledy změnila prostředek.

TaintEffect

Výčet

Efekt označuje, že efekt kontaminace odpovídá shodě. Prázdné znamená shodu se všemi efekty znečištění. Pokud je specifikováno, povolenou hodnotou je pouze NoSchedule.

Hodnota	Description
NoSchedule	Nedovolte, aby se nové pody plánovaly na uzel, pokud netolerují kontaminaci, ale povolte všem podům zaslaným Kubeletu bez toho, aby procházely plánovačem, a všechny již běžící kapsle mohou pokračovat v provozu. Vynucováno plánovačem.

TolerationOperator

Výčet

Operátor představuje vztah klíče k hodnotě. Platné operátory jsou Exists a Equal. Výchozí nastavení je rovné. Exists je ekvivalentní žolíku pro hodnotu, takže ClusterResourcePlacement může tolerovat všechny znečištění určité kategorie.

Hodnota	Description
Exists	Existuje tolerantní operátor
Equal	Tolerantní operátor je rovný