Fleet Managed Namespaces - Create Or Update

Dienst:

Fleet

API-Version:

2026-02-01-preview

Erstellen Sie einen FleetManagedNamespace

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

URI-Parameter

Name	In	Erforderlich	Typ	Beschreibung
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Der Name der Flottenressource.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Der Name der von der Flotte verwalteten Namespace-Ressource.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Der Name der Ressourcengruppe. Für den Namen wird die Groß-/Kleinschreibung nicht beachtet.
subscriptionId	path	True	string (uuid)	Hierbei handelt es sich um die ID des Zielabonnements. Der Wert muss eine UUID sein.
api-version	query	True	string minLength: 1	Die API-Version, die für diesen Vorgang verwendet werden soll.

Anforderungsheader

Name	Erforderlich	Typ	Beschreibung
If-Match		string	Die Anforderung sollte nur fortgesetzt werden, wenn eine Entität mit dieser Zeichenfolge übereinstimmt.
If-None-Match		string	Die Anforderung sollte nur fortgesetzt werden, wenn keine Entität mit dieser Zeichenfolge übereinstimmt.

Anforderungstext

Name	Erforderlich	Typ	Beschreibung
location	True	string	Der geografische Standort, an dem sich die Ressource befindet
properties		FleetManagedNamespaceProperties	Die ressourcenspezifischen Eigenschaften für diese Ressource.
tags		object	Ressourcentags.

Antworten

Name	Typ	Beschreibung
200 OK	FleetManagedNamespace	Die Aktualisierungsoperation der Ressource 'FleetManagedNamespace' war erfolgreich
201 Created	FleetManagedNamespace	Die Erstellungsoperation der Ressource 'FleetManagedNamespace' war erfolgreich Header Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Unerwartete Fehlerantwort.

Sicherheit

azure_auth

Azure Active Directory OAuth2 Flow.

Typ: oauth2
Ablauf: implicit
Autorisierungs-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiche

Name	Beschreibung
user_impersonation	Identitätswechsel ihres Benutzerkontos

Beispiele

FleetManagedNamespaces_CreateOrUpdate

Beispielanforderung

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

Beispiel für eine Antwort

Statuscode:

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

Statuscode:

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

Definitionen

Name	Beschreibung
AdoptionPolicy	Aktion, falls der Namensraum mit demselben Namen bereits existiert.
createdByType	Der Identitätstyp, der die Ressource erstellt hat.
DeletePolicy	Lösche Optionen für den ARM verwalteten Namensraum.
ErrorAdditionalInfo	Der Ressourcenverwaltungsfehler zusätzliche Informationen.
ErrorDetail	Das Fehlerdetails.
ErrorResponse	Fehlerantwort
FleetManagedNamespace	Ein von der Flotte verwalteter Namensraum.
FleetManagedNamespaceProperties	Die Eigenschaften eines flottenverwalteten Namensraums.
FleetManagedNamespaceProvisioningState	Der Bereitstellungszustand der flottenverwalteten Namensraumressource
FleetManagedNamespaceStatus	Statusinformationen für den von der Flotte verwalteten Namensraum.
LabelSelectorOperator	-Operator stellt die Beziehung eines Schlüssels zu einer Reihe von Werten dar. Gültige Operatoren sind In, NotIn, Exists und DoesNotExist.
ManagedNamespaceProperties	Die Namensraumeigenschaften für den von der Flotte verwalteten Namensraum.
Meta.V1.LabelSelector	Eine Bezeichnungsauswahl ist eine Bezeichnungsabfrage über eine Reihe von Ressourcen. Das Ergebnis von matchLabels und matchExpressions ist ANDed. Eine leere Bezeichnungsmarkierer entspricht allen Objekten. Ein Null-Bezeichnungsmarkierer stimmt mit keinem Objekt überein.
Meta.V1.LabelSelectorRequirement	Eine Bezeichnungsauswahlanforderung ist ein Selektor, der Werte, einen Schlüssel und einen Operator enthält, der den Schlüssel und die Werte bezieht.
NetworkPolicy	Die Netzwerkrichtlinie für den verwalteten Namensraum.
Placement.V1.Affinity	Affinität ist eine Gruppe von Cluster-Affinitäts-Planungsregeln. Mehr wird noch hinzugefügt.
Placement.V1.ClusterAffinity	ClusterAffinity enthält Cluster-Affinitäts-Planungsregeln für die ausgewählten Ressourcen.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec definiert den gewünschten Zustand von ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy enthält die Regeln, um Zielmitgliedscluster auszuwählen, um die ausgewählten Ressourcen zu platzieren. Beachten Sie, dass nur Cluster ausgewählt werden, die sowohl verbunden sind als auch die Regeln erfüllen. Du kannst höchstens eines der beiden Felder angeben: ClusterNames und Affinity. Wenn keiner angegeben ist, werden alle verbundenen Cluster ausgewählt.
Placement.V1.PropertySelector	PropertySelector hilft dem Benutzer dabei, Eigenschaftsanforderungen bei der Auswahl von Clustern für die Ressourcenplatzierung zu spezifizieren.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement ist eine spezifische Eigenschaftsanforderung bei der Auswahl von Clustern für die Ressourcenplatzierung.
Placement.V1.Toleration	Toleranz erlaubt es ClusterResourcePlacement, jede Verunreinigung zu tolerieren, die mit dem Dreifach-Schlüssel<, Wert und Effekt> übereinstimmt, indem er den entsprechenden Operatoroperator <>verwendet.
PlacementProfile	Das Konfigurationsprofil für Standard-ClusterResourcePlacement für die Platzierung.
PlacementType	Art der Platzierung. Kann "PickAll", "PickN" oder "PickFixed" sein. Standardmäßig ist PickAll.
PolicyRule	Die möglichen Werte repräsentieren verschiedene Netzwerkrichtlinien.
PropagationPolicy	Die Ausbreitung soll verwendet werden, um den Namensraum innerhalb der Flotte zu versorgen.
PropagationType	Wie der Namensraum unter den Flottenmitgliedern bereitgestellt wird.
PropertySelectorOperator	Operator spezifiziert die Beziehung zwischen dem beobachteten Wert der angegebenen Eigenschaft eines Clusters und den in der Anforderung angegebenen Werten.
ResourceQuota	Die Ressourcenquote für den verwalteten Namensraum.
systemData	Metadaten zur Erstellung und letzten Änderung der Ressource.
TaintEffect	Effekt zeigt an, dass der Taint-Effekt dazu passt. Leere bedeutet, dass alle Verunreinigungseffekte übereinstimmen. Wenn angegeben, ist der einzige erlaubte Wert NoSchedule.
TolerationOperator	Operator stellt die Beziehung eines Schlüssels zum Wert dar. Gültige Operatoren sind Existenz und Gleich. Standardmäßig steht Gleichheit. Exists entspricht dem Wildcard für den Wert, sodass ein ClusterResourcePlacement alle Beeinträchtigungen einer bestimmten Kategorie tolerieren kann.

AdoptionPolicy

Enumeration

Aktion, falls der Namensraum mit demselben Namen bereits existiert.

Wert	Beschreibung
Never	Wenn der Namespace bereits existiert, übernehmen Sie nicht den bestehenden Namespace, der von ARM verwaltet wird.
IfIdentical	Wenn es einen identischen Namespace gibt, übernehmen Sie den bestehenden Namespace, der von ARM verwaltet wird.
Always	Übernehmen Sie immer den bestehenden Namespace, um von ARM verwaltet zu werden, auch wenn dieser nicht identisch ist.

createdByType

Enumeration

Der Identitätstyp, der die Ressource erstellt hat.

Wert	Beschreibung
User
Application
ManagedIdentity
Key

DeletePolicy

Enumeration

Lösche Optionen für den ARM verwalteten Namensraum.

Wert	Beschreibung
Keep	Lösche die ARM-Ressource, behalte aber den Namespace.
Delete	Lösche sowohl die ARM-Ressource als auch den Namensraum.

ErrorAdditionalInfo

Objekt

Der Ressourcenverwaltungsfehler zusätzliche Informationen.

Name	Typ	Beschreibung
info	object	Die zusätzlichen Informationen.
type	string	Der zusätzliche Informationstyp.

ErrorDetail

Objekt

Das Fehlerdetails.

Name	Typ	Beschreibung
additionalInfo	ErrorAdditionalInfo[]	Die zusätzlichen Informationen des Fehlers.
code	string	Der Fehlercode.
details	ErrorDetail[]	Die Fehlerdetails.
message	string	Die Fehlermeldung.
target	string	Das Fehlerziel.

ErrorResponse

Objekt

Fehlerantwort

Name	Typ	Beschreibung
error	ErrorDetail	Das Fehlerobjekt.

FleetManagedNamespace

Objekt

Ein von der Flotte verwalteter Namensraum.

Name	Typ	Beschreibung
eTag	string	Wenn eTag im Antworttext bereitgestellt wird, kann es auch als Kopfzeile gemäß der normalen etag-Konvention bereitgestellt werden. Entitätstags werden zum Vergleichen von zwei oder mehr Entitäten aus derselben angeforderten Ressource verwendet. HTTP/1.1 verwendet Entitätstags im etag (Abschnitt 14.19), If-Match (Abschnitt 14.24), If-None-Match (Abschnitt 14.26) und If-Range (Abschnitt 14.27)-Kopfzeilenfelder.
id	string (arm-id)	Vollqualifizierte Ressourcen-ID für die Ressource. Z. B. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Der geografische Standort, an dem sich die Ressource befindet
name	string	Der Name der Ressource
properties	FleetManagedNamespaceProperties	Die ressourcenspezifischen Eigenschaften für diese Ressource.
systemData	systemData	Azure Resource Manager-Metadaten, die createdBy- und modifiedBy-Informationen enthalten.
tags	object	Ressourcentags.
type	string	Der Typ der Ressource. Z. B. "Microsoft.Compute/virtualMachines" oder "Microsoft.Storage/storageAccounts"

FleetManagedNamespaceProperties

Objekt

Die Eigenschaften eines flottenverwalteten Namensraums.

Name	Typ	Beschreibung
adoptionPolicy	AdoptionPolicy	Aktion, wenn der verwaltete Namespace mit demselben Namen bereits existiert. Standard ist niemals.
deletePolicy	DeletePolicy	Lösche die Optionen eines von der Flotte verwalteten Namensraums. Standardwert ist Behalten.
managedNamespaceProperties	ManagedNamespaceProperties	Die Namensraumeigenschaften für den von der Flotte verwalteten Namensraum.
portalFqdn	string	Der Azure Portal-FQDN des Flottenhubs.
propagationPolicy	PropagationPolicy	Das Profil der Propagation zur Erstellung des Namensraums.
provisioningState	FleetManagedNamespaceProvisioningState	Der Status des letzten Vorgangs.
status	FleetManagedNamespaceStatus	Statusinformationen der letzten Operation für den von der Flotte verwalteten Namensraum.

FleetManagedNamespaceProvisioningState

Enumeration

Der Bereitstellungszustand der flottenverwalteten Namensraumressource

Wert	Beschreibung
Succeeded	Ressource wurde erstellt.
Failed	Fehler bei der Ressourcenerstellung.
Canceled	Die Ressourcenerstellung wurde abgebrochen.
Creating	Der Bereitstellungszustand eines flottenverwalteten Namensraums wird erstellt.
Updating	Der Bereitstellungszustand eines flottenverwalteten Namensraums wird aktualisiert.
Deleting	Der Bereitstellungszustand eines von der Flotte verwalteten Namensraums wird gelöscht.

FleetManagedNamespaceStatus

Objekt

Statusinformationen für den von der Flotte verwalteten Namensraum.

Name	Typ	Beschreibung
lastOperationError	ErrorDetail	Der letzte Betriebsfehler des von der Flotte verwalteten Namensraums
lastOperationId	string	Die letzte Operations-ID für den von der Flotte verwalteten Namensraum

LabelSelectorOperator

Enumeration

-Operator stellt die Beziehung eines Schlüssels zu einer Reihe von Werten dar. Gültige Operatoren sind In, NotIn, Exists und DoesNotExist.

Wert	Beschreibung
In	Label-Selector-Operator In
NotIn	Label-Selektor-Operator NotIn
Exists	Es gibt einen Label-Selector-Operator
DoesNotExist	Label Selector Operator existiert nichtNicht

ManagedNamespaceProperties

Objekt

Die Namensraumeigenschaften für den von der Flotte verwalteten Namensraum.

Name	Typ	Beschreibung
annotations	object	Die Anmerkungen für den von der Flotte verwalteten Namensraum.
defaultNetworkPolicy	NetworkPolicy	Die Standard-Netzwerkrichtlinie für den von der Flotte verwalteten Namensraum.
defaultResourceQuota	ResourceQuota	Die Standard-Ressourcenquote für den von der Flotte verwalteten Namensraum.
labels	object	Die Bezeichnungen für den Namensraum der Flotte verwaltet.

Meta.V1.LabelSelector

Objekt

Eine Bezeichnungsauswahl ist eine Bezeichnungsabfrage über eine Reihe von Ressourcen. Das Ergebnis von matchLabels und matchExpressions ist ANDed. Eine leere Bezeichnungsmarkierer entspricht allen Objekten. Ein Null-Bezeichnungsmarkierer stimmt mit keinem Objekt überein.

Name	Typ	Beschreibung
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions ist eine Liste der Bezeichnungsauswahlanforderungen. Die Anforderungen sind ANDed.
matchLabels	object	matchLabels ist eine Abbildung von {key,value}-Paaren. Ein einzelner {key,value} in der matchLabels-Zuordnung entspricht einem Element von matchExpressions, dessen Schlüsselfeld "key" lautet, der Operator "In", und das Wertearray enthält nur "Value". Die Anforderungen sind ANDed.

Meta.V1.LabelSelectorRequirement

Objekt

Eine Bezeichnungsauswahlanforderung ist ein Selektor, der Werte, einen Schlüssel und einen Operator enthält, der den Schlüssel und die Werte bezieht.

Name	Typ	Beschreibung
key	string	key ist der Bezeichnungsschlüssel, auf den der Selektor angewendet wird.
operator	LabelSelectorOperator	-Operator stellt die Beziehung eines Schlüssels zu einer Reihe von Werten dar. Gültige Operatoren sind In, NotIn, Exists und DoesNotExist.
values	string[]	Werte sind ein Array von Zeichenfolgenwerten. Wenn der Operator "In" oder "NotIn" lautet, muss das Wertearray nicht leer sein. Wenn der Operator "Exists" oder "DoesNotExist" lautet, muss das Wertearray leer sein. Dieses Array wird während eines strategischen Zusammenführungspatches ersetzt.

NetworkPolicy

Objekt

Die Netzwerkrichtlinie für den verwalteten Namensraum.

Name	Typ	Beschreibung
egress	PolicyRule	Die Ausgangsrichtlinie für den verwalteten Namensraum.
ingress	PolicyRule	Die Ingress-Policy für den verwalteten Namensraum.

Placement.V1.Affinity

Objekt

Affinität ist eine Gruppe von Cluster-Affinitäts-Planungsregeln. Mehr wird noch hinzugefügt.

Name	Typ	Beschreibung
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity enthält Cluster-Affinitäts-Planungsregeln für die ausgewählten Ressourcen.

Placement.V1.ClusterAffinity

Objekt

ClusterAffinity enthält Cluster-Affinitäts-Planungsregeln für die ausgewählten Ressourcen.

Name	Typ	Beschreibung
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Wenn die in diesem Feld angegebenen Affinitätsanforderungen zum Zeitpunkt der Planung nicht erfüllt werden, wird die Ressource nicht auf den Cluster eingeplant. Wenn die in diesem Feld festgelegten Affinitätsanforderungen irgendwann nach der Platzierung nicht mehr erfüllt werden (z. B. aufgrund eines Updates), kann das System versuchen, die Ressource schließlich aus dem Cluster zu entfernen oder auch nicht.

Placement.V1.ClusterResourcePlacementSpec

Objekt

ClusterResourcePlacementSpec definiert den gewünschten Zustand von ClusterResourcePlacement.

Name	Typ	Beschreibung
policy	Placement.V1.PlacementPolicy	Die Richtlinie definiert, wie Mitgliedercluster ausgewählt werden, um die ausgewählten Ressourcen zu platzieren. Wenn nicht angegeben, werden alle verbundenen Mitgliedscluster ausgewählt.

Placement.V1.ClusterSelector

Objekt

ClusterSelector

Name	Typ	Beschreibung
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms ist eine Liste von Cluster-Selektortermen. Die Begriffe sind ORed.

Placement.V1.ClusterSelectorTerm

Objekt

ClusterSelectorTerm

Name	Typ	Beschreibung
labelSelector	Meta.V1.LabelSelector	LabelSelector ist eine Label-Abfrage über alle verbundenen Mitgliedscluster. Cluster, die der Abfrage entsprechen, werden ausgewählt. Wenn du sowohl Label- als auch Property-Selektoren im selben Begriff angibst, sind die Ergebnisse AND'd.
propertySelector	Placement.V1.PropertySelector	PropertySelector ist eine Eigenschaftsanfrage über alle verbundenen Mitgliedscluster. Cluster, die der Abfrage entsprechen, werden ausgewählt. Wenn du sowohl Label- als auch Property-Selektoren im selben Begriff angibst, sind die Ergebnisse AND'd. Derzeit kann PropertySelector nur mit RequiredDuringSchedulingIgnoredDuringExecution Affinitätstermen verwendet werden. Dieses Feld ist auf Beta-Niveau; Es ist für die property-basierte Planungsfunktion vorgesehen und nur funktional, wenn ein Property-Anbieter in der Bereitstellung aktiviert ist.

Placement.V1.PlacementPolicy

Objekt

PlacementPolicy enthält die Regeln, um Zielmitgliedscluster auszuwählen, um die ausgewählten Ressourcen zu platzieren. Beachten Sie, dass nur Cluster ausgewählt werden, die sowohl verbunden sind als auch die Regeln erfüllen. Du kannst höchstens eines der beiden Felder angeben: ClusterNames und Affinity. Wenn keiner angegeben ist, werden alle verbundenen Cluster ausgewählt.

Name	Typ	Beschreibung
affinity	Placement.V1.Affinity	Affinität enthält Cluster-Affinitätsplanungsregeln. Definiert, welche Mitgliedscluster die ausgewählten Ressourcen platzieren sollen. Gilt nur, wenn der Platzierungstyp "PickAll" oder "PickN" ist.
clusterNames	string[]	ClusterNames enthält eine Liste von Namen von MemberCluster, um die ausgewählten Ressourcen zu platzieren. Nur gültig, wenn der Platzierungstyp "PickFixed" ist.
placementType	PlacementType	Art der Platzierung. Kann "PickAll", "PickN" oder "PickFixed" sein. Standardmäßig ist PickAll.
tolerations	Placement.V1.Toleration[]	Wenn angegeben, die Toleranzen von ClusterResourcePlacement. Toleranzen können nicht aktualisiert oder gelöscht werden. Dieses Feld ist auf Beta-Niveau und dient für die Funktion Verunreinigungen und Toleranzen.

Placement.V1.PropertySelector

Objekt

PropertySelector hilft dem Benutzer dabei, Eigenschaftsanforderungen bei der Auswahl von Clustern für die Ressourcenplatzierung zu spezifizieren.

Name	Typ	Beschreibung
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions ist ein Array von PropertySelectorRequirements. Die Anforderungen sind AND'd.

Placement.V1.PropertySelectorRequirement

Objekt

PropertySelectorRequirement ist eine spezifische Eigenschaftsanforderung bei der Auswahl von Clustern für die Ressourcenplatzierung.

Name	Typ	Beschreibung
name	string	Der Name ist der Name des Grundstücks; es sollte ein Kubernetes-Label-Name sein.
operator	PropertySelectorOperator	Operator spezifiziert die Beziehung zwischen dem beobachteten Wert der angegebenen Eigenschaft eines Clusters und den in der Anforderung angegebenen Werten.
values	string[]	Werte sind eine Liste von Werten der angegebenen Eigenschaft, die die Flotte mit den beobachteten Werten einzelner Mitgliedscluster gemäß dem jeweiligen Operator vergleicht. Im Moment sollte jeder Wert eine Kubernetes-Größe sein. Weitere Informationen finden Sie unter https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Wenn der Operator Gt (größer als), Ge (größer oder gleich zu), Lt (kleiner als) oder Le (kleiner als oder gleich un), Eq (gleich an) oder Ne (ne) ist, muss genau ein Wert in der Liste angegeben werden.

Placement.V1.Toleration

Objekt

Toleranz erlaubt es ClusterResourcePlacement, jede Verunreinigung zu tolerieren, die mit dem Dreifach-Schlüssel<, Wert und Effekt> übereinstimmt, indem er den entsprechenden Operatoroperator <>verwendet.

Name	Typ	Beschreibung
effect	TaintEffect	Effekt zeigt an, dass der Taint-Effekt dazu passt. Leere bedeutet, dass alle Verunreinigungseffekte übereinstimmen. Wenn angegeben, ist der einzige erlaubte Wert NoSchedule.
key	string	Der Schlüssel ist der Taint-Schlüssel, auf den die Toleranz gilt. Leer bedeutet, dass alle Taint-Schlüssel übereinstimmen. Ist der Schlüssel leer, muss der Operator Exists sein; Diese Kombination bedeutet, alle Werte und Schlüssel abzugleichen.
operator	TolerationOperator	Operator stellt die Beziehung eines Schlüssels zum Wert dar. Gültige Operatoren sind Existenz und Gleich. Standardmäßig steht Gleichheit. Exists entspricht dem Wildcard für den Wert, sodass ein ClusterResourcePlacement alle Beeinträchtigungen einer bestimmten Kategorie tolerieren kann.
value	string	Wert ist der Taint-Wert, dem die Toleranz entspricht. Wenn der Operator existiert, sollte der Wert leer sein, ansonsten nur eine reguläre Zeichenkette.

PlacementProfile

Objekt

Das Konfigurationsprofil für Standard-ClusterResourcePlacement für die Platzierung.

Name	Typ	Beschreibung
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	Die Standard-Konfiguration der ClusterResourcePlacement-Richtlinie.

PlacementType

Enumeration

Art der Platzierung. Kann "PickAll", "PickN" oder "PickFixed" sein. Standardmäßig ist PickAll.

Wert	Beschreibung
PickAll	PickAll wählt alle Cluster aus, die die Regeln erfüllen.
PickFixed	PickFixed wählt eine feste Gruppe von Clustern.

PolicyRule

Enumeration

Die möglichen Werte repräsentieren verschiedene Netzwerkrichtlinien.

Wert	Beschreibung
AllowAll	Lassen Sie den gesamten Netzwerkverkehr zu.
DenyAll	Verweigern Sie den gesamten Netzwerkverkehr.
AllowSameNamespace	Datenverkehr innerhalb desselben Namespace zulassen.

PropagationPolicy

Objekt

Die Ausbreitung soll verwendet werden, um den Namensraum innerhalb der Flotte zu versorgen.

Name	Typ	Beschreibung
placementProfile	PlacementProfile	Das Profil, das für die Ausbreitung durch Platzierung verwendet werden soll.
type	PropagationType	Die Art der zu verwendenden Police. Standard ist die Platzierung.

PropagationType

Enumeration

Wie der Namensraum unter den Flottenmitgliedern bereitgestellt wird.

Wert	Beschreibung
Placement	Verwendung von ClusterResourcePlacement.

PropertySelectorOperator

Enumeration

Operator spezifiziert die Beziehung zwischen dem beobachteten Wert der angegebenen Eigenschaft eines Clusters und den in der Anforderung angegebenen Werten.

Wert	Beschreibung
Gt	gt diktiert Fleet, den Cluster auszuwählen, wenn der beobachtete Wert einer bestimmten Eigenschaft größer ist als der in der Anforderung angegebene Wert.
Ge	Ge diktiert Fleet, den Cluster auszuwählen, wenn der beobachtete Wert einer bestimmten Eigenschaft größer oder gleich dem in der Anforderung angegebenen Wert ist.
Eq	EQ bestimmt, dass Fleet den Cluster auswählen soll, wenn sein beobachteter Wert einer bestimmten Eigenschaft den in der Anforderung angegebenen Werte entspricht.
Ne	Ne bestimmt Fleet, den Cluster auszuwählen, wenn der beobachtete Wert einer bestimmten Eigenschaft nicht den in der Anforderung angegebenen Werten entspricht.
Lt	Lt diktiert Fleet, den Cluster auszuwählen, wenn der beobachtete Wert einer bestimmten Eigenschaft kleiner ist als der in der Anforderung angegebene Wert.
Le	Le diktiert Fleet, den Cluster auszuwählen, wenn der beobachtete Wert einer bestimmten Eigenschaft kleiner oder gleich dem in der Anforderung angegebenen Wert ist.

ResourceQuota

Objekt

Die Ressourcenquote für den verwalteten Namensraum.

Name	Typ	Beschreibung
cpuLimit	string	Die CPU-Begrenzung für den verwalteten Namensraum. Weitere Informationen finden Sie unter https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	Die CPU-Anfrage für den verwalteten Namensraum. Weitere Informationen finden Sie unter https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	Das Speicherlimit für den verwalteten Namensraum. Weitere Informationen finden Sie unter https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	Die Speicheranforderung für den verwalteten Namensraum. Weitere Informationen finden Sie unter https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Objekt

Metadaten zur Erstellung und letzten Änderung der Ressource.

Name	Typ	Beschreibung
createdAt	string (date-time)	Der Zeitstempel der Ressourcenerstellung (UTC).
createdBy	string	Die Identität, die die Ressource erstellt hat.
createdByType	createdByType	Der Identitätstyp, der die Ressource erstellt hat.
lastModifiedAt	string (date-time)	Der Zeitstempel der letzten Änderung der Ressource (UTC)
lastModifiedBy	string	Die Identität, die die Ressource zuletzt geändert hat.
lastModifiedByType	createdByType	Der Identitätstyp, der die Ressource zuletzt geändert hat.

TaintEffect

Enumeration

Effekt zeigt an, dass der Taint-Effekt dazu passt. Leere bedeutet, dass alle Verunreinigungseffekte übereinstimmen. Wenn angegeben, ist der einzige erlaubte Wert NoSchedule.

Wert	Beschreibung
NoSchedule	Erlauben Sie nicht, dass neue Pods auf den Knoten eingeplant werden, es sei denn, sie tolerieren die Verunreinigung, sondern lassen Sie alle Pods, die an Kubelet eingereicht werden, ohne den Scheduler zu durchlaufen, starten, und lassen alle bereits laufenden Pods weiterlaufen. Durchgesetzt vom Scheduler.

TolerationOperator

Enumeration

Operator stellt die Beziehung eines Schlüssels zum Wert dar. Gültige Operatoren sind Existenz und Gleich. Standardmäßig steht Gleichheit. Exists entspricht dem Wildcard für den Wert, sodass ein ClusterResourcePlacement alle Beeinträchtigungen einer bestimmten Kategorie tolerieren kann.

Wert	Beschreibung
Exists	Es existiert ein Toleranzoperator
Equal	Toleranzoperator gleich