Fleet Managed Namespaces - Create Or Update

Usługa:

Fleet

Wersja interfejsu API:

2026-02-01-preview

Stwórz przestrzeń nazw zarządzaną flotą

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

Parametry identyfikatora URI

Nazwa	W	Wymagane	Typ	Opis
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Nazwa zasobu Fleet.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Nazwa zasobów przestrzeni nazw zarządzanych flotą.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Nazwa grupy zasobów. Nazwa jest niewrażliwa na wielkość liter.
subscriptionId	path	True	string (uuid)	Identyfikator subskrypcji docelowej. Wartość musi być identyfikatorem UUID.
api-version	query	True	string minLength: 1	Wersja interfejsu API do użycia dla tej operacji.

Nagłówek żądania

Nazwa	Wymagane	Typ	Opis
If-Match		string	Żądanie powinno być kontynuowane tylko wtedy, gdy jednostka pasuje do tego ciągu.
If-None-Match		string	Żądanie powinno być kontynuowane tylko wtedy, gdy żadna jednostka nie pasuje do tego ciągu.

Treść żądania

Nazwa	Wymagane	Typ	Opis
location	True	string	Lokalizacja geograficzna, w której znajduje się zasób
properties		FleetManagedNamespaceProperties	Właściwości specyficzne dla zasobu dla tego zasobu.
tags		object	Tagi zasobów.

Odpowiedzi

Nazwa	Typ	Opis
200 OK	FleetManagedNamespace	Aktualizacja zasobu 'FleetManagedNamespace' zakończyła się sukcesem
201 Created	FleetManagedNamespace	Zasób 'FleetManagedNamespace' utworzenie operacji zakończyło się sukcesem Nagłówki Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Nieoczekiwana odpowiedź na błąd.

Zabezpieczenia

azure_auth

Przepływ protokołu 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

FleetManagedNamespaces_CreateOrUpdate

Przykładowe żądanie

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

Przykładowa odpowiedź

Kod stanu:

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"
  }
}

Kod stanu:

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"
  }
}

Definicje

Nazwa	Opis
AdoptionPolicy	Działaj, jeśli przestrzeń nazw o tej samej nazwie już istnieje.
createdByType	Typ tożsamości, która utworzyła zasób.
DeletePolicy	Usuń opcje dla zarządzanej przestrzeni nazw ARM.
ErrorAdditionalInfo	Dodatkowe informacje o błędzie zarządzania zasobami.
ErrorDetail	Szczegóły błędu.
ErrorResponse	Odpowiedź na błąd
FleetManagedNamespace	Przestrzeń nazw zarządzana flotą.
FleetManagedNamespaceProperties	Właściwości przestrzeni nazw zarządzanej flotą.
FleetManagedNamespaceProvisioningState	Stan udostępniania zasobów przestrzeni nazw zarządzanej floty
FleetManagedNamespaceStatus	Informacje o statusie przestrzeni nazw zarządzanej flotą.
LabelSelectorOperator	operator reprezentuje relację klucza z zestawem wartości. Prawidłowe operatory to In, NotIn, Exists i DoesNotExist.
ManagedNamespaceProperties	Właściwości przestrzeni nazw floty były zarządzane przestrzenią nazw.
Meta.V1.LabelSelector	Selektor etykiet to zapytanie etykiety dotyczące zestawu zasobów. Wynik matchLabels i matchExpressions są ANDed. Pusty selektor etykiet pasuje do wszystkich obiektów. Selektor etykiet o wartości null nie pasuje do żadnych obiektów.
Meta.V1.LabelSelectorRequirement	Wymaganie selektora etykiet to selektor zawierający wartości, klucz i operator, który wiąże klucz i wartości.
NetworkPolicy	Polityka sieciowa dla zarządzanej przestrzeni nazw.
Placement.V1.Affinity	Powinowactwa to grupa reguł harmonogramowania powinowactwa klastrowego. Więcej do dodania.
Placement.V1.ClusterAffinity	ClusterAffinity zawiera reguły harmonogramowania powinowactwa klastrów dla wybranych zasobów.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec definiuje pożądany stan ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy zawiera reguły wyboru docelowych klastrów członkowskich do umieszczenia wybranych zasobów. Należy zauważyć, że wybierane będą tylko klastry, które są połączone i spełniają reguły. Możesz określić maksymalnie jedno z dwóch pól: ClusterNames i Affinity. Jeśli nie jest określona żadna, wybierane są wszystkie połączone klastry.
Placement.V1.PropertySelector	PropertySelector pomaga użytkownikowi określić wymagania dotyczące właściwości przy wyborze klastrów do rozmieszczenia zasobów.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement to specyficzne wymagania właściwości przy wyborze klastrów do rozmieszczenia zasobów.
Placement.V1.Toleration	Tolerancja pozwala ClusterResourcePlacement tolerować dowolne zanieczyszczenie odpowiadające efektowi <> potrójnego klucza, wartości, przy użyciu operatora< dopasowanego>.
PlacementProfile	Profil konfiguracji dla domyślnego ClusterResourcePlacement dla umieszczenia.
PlacementType	Rodzaj umiejscowienia. Może to być "PickAll", "PickN" lub "PickFixed". Domyślnie jest PickAll.
PolicyRule	Możliwe wartości reprezentujące różne reguły polityki sieciowej.
PropagationPolicy	Propagacja ma być użyta do udostępniania przestrzeni nazw w ramach floty.
PropagationType	Jak przestrzeń nazw będzie rozmieszczona wśród członków floty.
PropertySelectorOperator	Operator określa zależność między obserwowaną wartością określonej właściwości klastra a wartościami podanymi w wymaganiach.
ResourceQuota	Kwota zasobów dla zarządzanej przestrzeni nazw.
systemData	Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.
TaintEffect	Efekt wskazuje, że efekt skażenia jest zgodny. Puste oznacza, że pasują do wszystkich efektów skażenia. Gdy jest to określone, jedyną dozwoloną wartością jest NoSchedule.
TolerationOperator	Operator reprezentuje relację klucza do wartości. Poprawne operatory to Istnieje i Równe. Domyślnie jest równy. Exists jest równoważny dzikiemu znakowi wartości (wildcard) dla wartości, dzięki czemu ClusterResourcePlacement może tolerować wszystkie zaskażenia danej kategorii.

AdoptionPolicy

Wyliczenie

Działaj, jeśli przestrzeń nazw o tej samej nazwie już istnieje.

Wartość	Opis
Never	Jeśli przestrzeń nazw już istnieje, nie przejmuj istniejącej przestrzeni nazw, którą będzie zarządzał ARM.
IfIdentical	Jeśli istnieje identyczna przestrzeń nazw, przejmij istniejącą przestrzeń nazw do zarządzania przez ARM.
Always	Zawsze przejmuj istniejącą przestrzeń nazw, którą obsługuje ARM, nawet jeśli nie jest identyczna.

createdByType

Wyliczenie

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

Wartość	Opis
User
Application
ManagedIdentity
Key

DeletePolicy

Wyliczenie

Usuń opcje dla zarządzanej przestrzeni nazw ARM.

Wartość	Opis
Keep	Usuń zasób ARM, ale zachowaj przestrzeń nazw.
Delete	Usuń zarówno zasób ARM, jak i przestrzeń nazw.

ErrorAdditionalInfo

Objekt

Dodatkowe informacje o błędzie zarządzania zasobami.

Nazwa	Typ	Opis
info	object	Dodatkowe informacje.
type	string	Dodatkowy typ informacji.

ErrorDetail

Objekt

Szczegóły błędu.

Nazwa	Typ	Opis
additionalInfo	ErrorAdditionalInfo[]	Dodatkowe informacje o błędzie.
code	string	Kod błędu.
details	ErrorDetail[]	Szczegóły błędu.
message	string	Komunikat o błędzie.
target	string	Cel błędu.

ErrorResponse

Objekt

Odpowiedź na błąd

Nazwa	Typ	Opis
error	ErrorDetail	Obiekt błędu.

FleetManagedNamespace

Objekt

Przestrzeń nazw zarządzana flotą.

Nazwa	Typ	Opis
eTag	string	Jeśli element eTag jest podany w treści odpowiedzi, może być również podany jako nagłówek zgodnie z normalną konwencją etag. Tagi jednostek są używane do porównywania co najmniej dwóch jednostek z tego samego żądanego zasobu. Protokół HTTP/1.1 używa tagów jednostek w elemecie etag (sekcja 14.19), If-Match (sekcja 14.24), if-None-Match (sekcja 14.26) i If-Range (sekcja 14.27) pól nagłówka.
id	string (arm-id)	W pełni kwalifikowany identyfikator zasobu dla zasobu. Np. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Lokalizacja geograficzna, w której znajduje się zasób
name	string	Nazwa zasobu
properties	FleetManagedNamespaceProperties	Właściwości specyficzne dla zasobu dla tego zasobu.
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"

FleetManagedNamespaceProperties

Objekt

Właściwości przestrzeni nazw zarządzanej flotą.

Nazwa	Typ	Opis
adoptionPolicy	AdoptionPolicy	Działaj, jeśli zarządzana przestrzeń nazw o tej samej nazwie już istnieje. Domyślnie to Nigdy.
deletePolicy	DeletePolicy	Usuń opcje przestrzeni nazw zarządzanej przez flotę. Domyślnie to Zachowaj.
managedNamespaceProperties	ManagedNamespaceProperties	Właściwości przestrzeni nazw floty były zarządzane przestrzenią nazw.
portalFqdn	string	Nazwa FQDN witryny Azure Portal centrum Floty.
propagationPolicy	PropagationPolicy	Profil propagacji do utworzenia przestrzeni nazw.
provisioningState	FleetManagedNamespaceProvisioningState	Stan ostatniej operacji.
status	FleetManagedNamespaceStatus	Informacje o statusie ostatniej operacji dla przestrzeni nazw zarządzanej flotą.

FleetManagedNamespaceProvisioningState

Wyliczenie

Stan udostępniania zasobów przestrzeni nazw zarządzanej floty

Wartość	Opis
Succeeded	Zasób został utworzony.
Failed	Tworzenie zasobu nie powiodło się.
Canceled	Tworzenie zasobu zostało anulowane.
Creating	Stan udostępniania tworzonej przestrzeni nazw zarządzanej flotą.
Updating	Aktualizowany jest stan udostępniania przestrzeni nazw zarządzanej flotą.
Deleting	Stan udostępniania przestrzeni nazw zarządzanej flotą jest usuwany.

FleetManagedNamespaceStatus

Objekt

Informacje o statusie przestrzeni nazw zarządzanej flotą.

Nazwa	Typ	Opis
lastOperationError	ErrorDetail	Ostatni błąd operacyjny przestrzeni nazw zarządzanej floty
lastOperationId	string	Ostatni identyfikator operacji dla zarządzanej przestrzeni nazw floty

LabelSelectorOperator

Wyliczenie

operator reprezentuje relację klucza z zestawem wartości. Prawidłowe operatory to In, NotIn, Exists i DoesNotExist.

Wartość	Opis
In	Operator selektora etykiety Wchodzi
NotIn	Operator selektora etykiet NotIn
Exists	Istnieje operator selektora etykiet
DoesNotExist	Operator selektora etykiet NieIstnieje

ManagedNamespaceProperties

Objekt

Właściwości przestrzeni nazw floty były zarządzane przestrzenią nazw.

Nazwa	Typ	Opis
annotations	object	Adnotacje dla przestrzeni nazw zarządzanej flotą.
defaultNetworkPolicy	NetworkPolicy	Domyślna polityka sieciowa dla zarządzanej przestrzeni nazw floty.
defaultResourceQuota	ResourceQuota	Domyślna kwota zasobów dla przestrzeni nazw zarządzanej flotą.
labels	object	Etykiety dla przestrzeni nazw zarządzanych flotą.

Meta.V1.LabelSelector

Objekt

Selektor etykiet to zapytanie etykiety dotyczące zestawu zasobów. Wynik matchLabels i matchExpressions są ANDed. Pusty selektor etykiet pasuje do wszystkich obiektów. Selektor etykiet o wartości null nie pasuje do żadnych obiektów.

Nazwa	Typ	Opis
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions to lista wymagań selektora etykiet. Wymagania są anded.
matchLabels	object	matchLabels to mapa par {key,value}. Pojedynczy element {key,value} na mapie matchLabels jest odpowiednikiem elementu matchExpressions, którego pole klucza to "key", operator ma wartość "In", a tablica wartości zawiera tylko wartość. Wymagania są anded.

Meta.V1.LabelSelectorRequirement

Objekt

Wymaganie selektora etykiet to selektor zawierający wartości, klucz i operator, który wiąże klucz i wartości.

Nazwa	Typ	Opis
key	string	key to klucz etykiety, do którego ma zastosowanie selektor.
operator	LabelSelectorOperator	operator reprezentuje relację klucza z zestawem wartości. Prawidłowe operatory to In, NotIn, Exists i DoesNotExist.
values	string[]	wartości to tablica wartości ciągów. Jeśli operator ma wartość In lub NotIn, tablica wartości musi być niepusta. Jeśli operator istnieje lub DoesNotExist, tablica wartości musi być pusta. Ta tablica jest zastępowana podczas strategicznej poprawki scalania.

NetworkPolicy

Objekt

Polityka sieciowa dla zarządzanej przestrzeni nazw.

Nazwa	Typ	Opis
egress	PolicyRule	Polityka ewakuacji dla zarządzanej przestrzeni nazw.
ingress	PolicyRule	Polityka wejścia do zarządzanej przestrzeni nazw.

Placement.V1.Affinity

Objekt

Powinowactwa to grupa reguł harmonogramowania powinowactwa klastrowego. Więcej do dodania.

Nazwa	Typ	Opis
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity zawiera reguły harmonogramowania powinowactwa klastrów dla wybranych zasobów.

Placement.V1.ClusterAffinity

Objekt

ClusterAffinity zawiera reguły harmonogramowania powinowactwa klastrów dla wybranych zasobów.

Nazwa	Typ	Opis
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Jeśli wymagania dotyczące powinowactwa określone przez to pole nie zostaną spełnione w czasie harmonogramowania, zasób nie zostanie zaplanowany na klastrze. Jeśli wymagania dotyczące powinowactwa określone przez to pole przestaną być spełnione w pewnym momencie po umieszczeniu (np. z powodu aktualizacji), system może, ale nie musi, próbować ostatecznie usunąć zasób z klastra.

Placement.V1.ClusterResourcePlacementSpec

Objekt

ClusterResourcePlacementSpec definiuje pożądany stan ClusterResourcePlacement.

Nazwa	Typ	Opis
policy	Placement.V1.PlacementPolicy	Polityka definiuje, jak wybierać klastry członkowskie do umieszczenia wybranych zasobów. Jeśli nie jest to określone, wybierane są wszystkie połączone klastry członków.

Placement.V1.ClusterSelector

Objekt

ClusterSelector

Nazwa	Typ	Opis
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms to lista terminów selektorów klastrów. Terminy są takie jak ORed.

Placement.V1.ClusterSelectorTerm

Objekt

ClusterSelectorTerm

Nazwa	Typ	Opis
labelSelector	Meta.V1.LabelSelector	LabelSelector to zapytanie etykietowe dotyczące wszystkich połączonych klastrów członkowskich. Wybierane są klastry odpowiadające zapytaniu. Jeśli w tym samym terminie podasz zarówno selektor etykiety, jak i właściwości, wyniki są oznaczone AND.
propertySelector	Placement.V1.PropertySelector	PropertySelector to zapytanie o właściwości wszystkich połączonych klastrów członkowskich. Wybierane są klastry odpowiadające zapytaniu. Jeśli w tym samym terminie podasz zarówno selektor etykiety, jak i właściwości, wyniki są oznaczone AND. Obecnie PropertySelector może być używany tylko z terminami RequiredDuringSchedulingIgnoredDuringExecution afinitetowymi. Ta dziedzina jest na poziomie beta; Służy do funkcji planowania opartego na właściwościach i działa tylko wtedy, gdy dostawca właściwości jest włączony we wdrożeniu.

Placement.V1.PlacementPolicy

Objekt

PlacementPolicy zawiera reguły wyboru docelowych klastrów członkowskich do umieszczenia wybranych zasobów. Należy zauważyć, że wybierane będą tylko klastry, które są połączone i spełniają reguły. Możesz określić maksymalnie jedno z dwóch pól: ClusterNames i Affinity. Jeśli nie jest określona żadna, wybierane są wszystkie połączone klastry.

Nazwa	Typ	Opis
affinity	Placement.V1.Affinity	Affinity zawiera zasady harmonogramowania powinowactwa klastrowego. Definiuje, które klastry członkowskie mają umieścić wybrane zasoby. Jest to ważne tylko wtedy, gdy typ rozmieszczenia to "PickAll" lub "PickN".
clusterNames	string[]	ClusterNames zawiera listę nazw MemberCluster do umieszczenia wybranych zasobów. Jest to ważne tylko wtedy, gdy typ rozmieszczenia jest "PickFixed"
placementType	PlacementType	Rodzaj umiejscowienia. Może to być "PickAll", "PickN" lub "PickFixed". Domyślnie jest PickAll.
tolerations	Placement.V1.Toleration[]	Jeśli jest to wskazane, tolerancje ClusterResourcePlacement. Tolerancji nie można aktualizować ani usuwać. To pole jest na poziomie beta i dotyczy funkcji zanieczyszczeń i tolerancji.

Placement.V1.PropertySelector

Objekt

PropertySelector pomaga użytkownikowi określić wymagania dotyczące właściwości przy wyborze klastrów do rozmieszczenia zasobów.

Nazwa	Typ	Opis
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions to zestaw PropertySelectorRequirements. Wymagania są OKREŚLONE.

Placement.V1.PropertySelectorRequirement

Objekt

PropertySelectorRequirement to specyficzne wymagania właściwości przy wyborze klastrów do rozmieszczenia zasobów.

Nazwa	Typ	Opis
name	string	Nazwa to nazwa nieruchomości; powinna to być nazwa etykiety Kubernetes.
operator	PropertySelectorOperator	Operator określa zależność między obserwowaną wartością określonej właściwości klastra a wartościami podanymi w wymaganiach.
values	string[]	Wartości to lista wartości o określonej właściwości, które Fleet porównuje z obserwowanymi wartościami poszczególnych klastrów członkowskich zgodnie z danym operatorem. Na ten moment każda wartość powinna być wartością Kubernetes. Aby uzyskać więcej informacji, zobacz https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Jeśli operator to Gt (większy niż), Ge (większy lub równy), Lt (mniejszy niż), Le lub (mniejszy lub równy), równanie (równanie) lub Ne (ne), lista musi być określona dokładnie jedną wartość.

Placement.V1.Toleration

Objekt

Tolerancja pozwala ClusterResourcePlacement tolerować dowolne zanieczyszczenie odpowiadające efektowi <> potrójnego klucza, wartości, przy użyciu operatora< dopasowanego>.

Nazwa	Typ	Opis
effect	TaintEffect	Efekt wskazuje, że efekt skażenia jest zgodny. Puste oznacza, że pasują do wszystkich efektów skażenia. Gdy jest to określone, jedyną dozwoloną wartością jest NoSchedule.
key	string	Klucz to klucz skażony, do którego odnosi się tolerancja. Puste oznacza dopasowanie wszystkich kluczy skażonych. Jeśli klucz jest pusty, operator musi być Istnieje; Ta kombinacja oznacza dopasowanie wszystkich wartości i wszystkich kluczy.
operator	TolerationOperator	Operator reprezentuje relację klucza do wartości. Poprawne operatory to Istnieje i Równe. Domyślnie jest równy. Exists jest równoważny dzikiemu znakowi wartości (wildcard) dla wartości, dzięki czemu ClusterResourcePlacement może tolerować wszystkie zaskażenia danej kategorii.
value	string	Wartość to wartość skażliwa, do której tolerancja odpowiada. Jeśli operator to Exists, wartość powinna być pusta, w przeciwnym razie to tylko zwykły ciąg danych.

PlacementProfile

Objekt

Profil konfiguracji dla domyślnego ClusterResourcePlacement dla umieszczenia.

Nazwa	Typ	Opis
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	Domyślna konfiguracja polityki ClusterResourcePlacement.

PlacementType

Wyliczenie

Rodzaj umiejscowienia. Może to być "PickAll", "PickN" lub "PickFixed". Domyślnie jest PickAll.

Wartość	Opis
PickAll	PickAll wybiera wszystkie klastry spełniające zasady.
PickFixed	PickFixed wybiera stały zestaw klastrów.

PolicyRule

Wyliczenie

Możliwe wartości reprezentujące różne reguły polityki sieciowej.

Wartość	Opis
AllowAll	Zezwalaj na cały ruch sieciowy.
DenyAll	Odmów całego ruchu sieciowego.
AllowSameNamespace	Zezwalaj na ruch w tej samej przestrzeni nazw.

PropagationPolicy

Objekt

Propagacja ma być użyta do udostępniania przestrzeni nazw w ramach floty.

Nazwa	Typ	Opis
placementProfile	PlacementProfile	Profil przeznaczony do propagacji poprzez umiejscowienie.
type	PropagationType	Rodzaj polisy, którą należy stosować. Domyślnie to Placement.

PropagationType

Wyliczenie

Jak przestrzeń nazw będzie rozmieszczona wśród członków floty.

Wartość	Opis
Placement	Korzystając z ClusterResourcePlacement.

PropertySelectorOperator

Wyliczenie

Operator określa zależność między obserwowaną wartością określonej właściwości klastra a wartościami podanymi w wymaganiach.

Wartość	Opis
Gt	GT nakazuje flocie wybrać klaster, jeśli zaobserwowana wartość danej właściwości jest większa niż wartość określona w wymaganiach.
Ge	Ge nakazuje flocie wybrać klaster, jeśli jego obserwowana wartość danej właściwości jest większa lub równa wartości określonej w wymaganiach.
Eq	Równanie nakazuje Fleetowi wybrać klaster, jeśli jego obserwowana wartość danej właściwości jest równa wartościom określonym w wymaganiach.
Ne	Ne nakazuje Fleet wybrać klaster, jeśli jego zaobserwowana wartość danej właściwości nie jest równa wartościom określonym w wymaganiach.
Lt	Lt nakazuje Flocie wybrać klaster, jeśli jego zaobserwowana wartość danej właściwości jest mniejsza niż wartość określona w wymaganiach.
Le	Le nakazuje Fleet wybrać klaster, jeśli jego zaobserwowana wartość danej właściwości jest mniejsza lub równa wartości określonej w wymaganiach.

ResourceQuota

Objekt

Kwota zasobów dla zarządzanej przestrzeni nazw.

Nazwa	Typ	Opis
cpuLimit	string	Limit CPU dla zarządzanej przestrzeni nazw. Zobacz więcej na stronie https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	CPU żąda przestrzeni nazw zarządzanej. Zobacz więcej na stronie https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	Limit pamięci dla zarządzanej przestrzeni nazw. Zobacz więcej na stronie https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	Żądanie pamięci dla zarządzanej przestrzeni nazw. Zobacz więcej na stronie https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Objekt

Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.

Nazwa	Typ	Opis
createdAt	string (date-time)	Sygnatura czasowa tworzenia zasobu (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 (date-time)	Znacznik czasu 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.

TaintEffect

Wyliczenie

Efekt wskazuje, że efekt skażenia jest zgodny. Puste oznacza, że pasują do wszystkich efektów skażenia. Gdy jest to określone, jedyną dozwoloną wartością jest NoSchedule.

Wartość	Opis
NoSchedule	Nie pozwól nowym kapsułom na planowanie na węzeł, chyba że tolerują zanieczyszczenie, ale pozwól wszystkim kapsułom przesłanym do Kubelet bez przechodzenia przez harmonogram na start i pozwól wszystkim już działającym kapsułom działać dalej. Egzekwowane przez harmonogramistę.

TolerationOperator

Wyliczenie

Operator reprezentuje relację klucza do wartości. Poprawne operatory to Istnieje i Równe. Domyślnie jest równy. Exists jest równoważny dzikiemu znakowi wartości (wildcard) dla wartości, dzięki czemu ClusterResourcePlacement może tolerować wszystkie zaskażenia danej kategorii.

Wartość	Opis
Exists	Istnieje operator tolerancji
Equal	Operator tolerancji równy