Fleet Managed Namespaces - Create Or Update

Szolgáltatás:

Fleet

API-verzió:

2026-02-01-preview

Létrehozz egy FleetManagedNamespace-t

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

URI-paraméterek

Name	In	Kötelező	Típus	Description
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	A Fleet-erőforrás neve.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	A flotta által kezelt névtér erőforrás neve.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Az erőforráscsoport neve. A név nem megkülönbözteti a kis- és nagybetűket.
subscriptionId	path	True	string (uuid)	A cél-előfizetés azonosítója. Az értéknek UUID-nek kell lennie.
api-version	query	True	string minLength: 1	A művelethez használandó API-verzió.

Kérelem fejléce

Name	Kötelező	Típus	Description
If-Match		string	A kérés csak akkor folytatódhat, ha egy entitás megfelel ennek a sztringnek.
If-None-Match		string	A kérés csak akkor folytatódhat, ha egyetlen entitás sem felel meg ennek a sztringnek.

Kérelem törzse

Name	Kötelező	Típus	Description
location	True	string	Az a földrajzi hely, ahol az erőforrás él
properties		FleetManagedNamespaceProperties	Az erőforrás erőforrás-specifikus tulajdonságai.
tags		object	Erőforráscímkék.

Válaszok

Name	Típus	Description
200 OK	FleetManagedNamespace	A 'FleetManagedNamespace' erőforrás frissítési művelete sikeres
201 Created	FleetManagedNamespace	Erőforrás 'FleetManagedNamespace' létrehozása sikeres művelet Fejlécek Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Váratlan hibaválasz.

Biztonság

azure_auth

Azure Active Directory Oauth2-folyamat.

Típus: oauth2
Folyamat: implicit
Engedélyezési URL: https://login.microsoftonline.com/common/oauth2/authorize

Hatókörök

Name	Description
user_impersonation	a felhasználói fiók megszemélyesítése

Példák

FleetManagedNamespaces_CreateOrUpdate

Mintakérelem

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

Mintaválasz

Állapotkód:

200

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

Állapotkód:

201

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

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

Definíciók

Name	Description
AdoptionPolicy	Akció, ha a Namespace azonos nevű már létezik.
createdByType	Az erőforrást létrehozó identitás típusa.
DeletePolicy	Töröld az opciókat az ARM által kezelt névtérhez.
ErrorAdditionalInfo	Az erőforrás-kezelési hiba további információi.
ErrorDetail	A hiba részletei.
ErrorResponse	Hibaválasz
FleetManagedNamespace	Egy flotta által kezelt névtér.
FleetManagedNamespaceProperties	A flotta tulajdonai a névtér kezelése.
FleetManagedNamespaceProvisioningState	A flotta ellátó állapota a névtér által kezelt erőforrás
FleetManagedNamespaceStatus	A flotta által kezelt névtér állapotinformációi.
LabelSelectorOperator	operátor egy kulcs egy értékkészlethez való viszonyát jelöli. Az érvényes operátorok: In, NotIn, Exists és DoesNotExist.
ManagedNamespaceProperties	A flotta névtér tulajdonságai kezelték a névteret.
Meta.V1.LabelSelector	A címkeválasztók egy erőforráskészleten keresztüli címke-lekérdezések. A matchLabels és a matchExpressions eredménye ANDed. Az üres címkeválasztó az összes objektumnak megfelel. A nullcímke-választó nem felel meg objektumoknak.
Meta.V1.LabelSelectorRequirement	A címkeválasztó követelmény egy olyan választó, amely értékeket, kulcsot és a kulcsot és értékeket összekapcsoló operátort tartalmaz.
NetworkPolicy	A kezelt névtér hálózati szabályzata.
Placement.V1.Affinity	Az affinitás egy csoportos klaszteraffinitás ütemezési szabály. Még többet hozzáteszünk.
Placement.V1.ClusterAffinity	A ClusterAffinity tartalmazza a klaszter affinitás ütemezési szabályokat a kiválasztott erőforrásokhoz.
Placement.V1.ClusterResourcePlacementSpec	A ClusterResourcePlacementSpec meghatározza a ClusterResourcePlacement kívánt állapotát.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	A PlacementPolicy tartalmazza azokat a szabályokat, amelyek a céltag klasztereket választják ki a kiválasztott erőforrások elhelyezésére. Fontos megjegyezni, hogy csak olyan klasztereket választanak ki, amelyek egyszerre csatlakoznak és teljesítenek a szabályoknak. Legfeljebb az egyik két mezőt tudod megadni: ClusterNames és Affinity. Ha nincs megadva, az összes összekapcsolt klasztert kiválasztjuk.
Placement.V1.PropertySelector	Az PropertySelector segít a felhasználóknak megadni a tulajdonságkövetelményeket a klaszterek kiválasztásakor az erőforrás-elhelyezéshez.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement egy specifikus tulajdonságkövetelmény, amikor klasztereket választunk erőforrás-elhelyezéshez.
Placement.V1.Toleration	A toleranálás lehetővé teszi a ClusterResourcePlacement számára, hogy elviselje bármilyen szennyeződést, amely megfelel a háromkulcs<, érték, hatás> a megfelelő operátor<> segítségével.
PlacementProfile	Az alapértelmezett ClusterResourcePlacement konfigurációs profilja az elhelyezéshez.
PlacementType	A helymeghatározás típusa. Lehet "PickAll", "PickN" vagy "PickFixed". Az alapértelmezett a PickAll.
PolicyRule	A lehetséges értékek különböző hálózati szabályzati szabályokat képviselnek.
PropagationPolicy	A terjedés, amelyet a flotta névtér ellátására használnak.
PropagationType	Hogyan fogják a névtér ellátmányozni a flottatagok között.
PropertySelectorOperator	Az operátor meghatározza a klaszter megfigyelt értéke és a követelményben megadott értékek közötti kapcsolatot.
ResourceQuota	A kezelt névtér erőforráskvótája.
systemData	Az erőforrás létrehozásával és utolsó módosításával kapcsolatos metaadatok.
TaintEffect	A hatás azt jelzi, hogy a szennyező hatás illeszkedik. Az üres azt jelenti, hogy minden fertőzött hatás egyezik. Megadva az egyetlen engedélyezett érték a NoSchedule.
TolerationOperator	Az operátor a kulcs és az érték közötti kapcsolatát jelenti. Az érvényes operátorok a Létező és Egyenértékűek. Alapértelmezettként egyenlő állapotban van. A Exists értékben a vaker érték értékével egyenértékű, így egy ClusterResourcePlacement elviselheti az adott kategória összes szennyezését.

AdoptionPolicy

Felsorolás

Akció, ha a Namespace azonos nevű már létezik.

Érték	Description
Never	Ha a névtér már létezik, ne vegye át az ARM által kezelendő meglévő névteret.
IfIdentical	Ha létezik azonos névtér, vegyük át a meglévő névteret, amelyet az ARM kezel.
Always	Mindig vedd át az ARM által kezelendő meglévő névteret, még akkor is, ha nem azonos is.

createdByType

Felsorolás

Az erőforrást létrehozó identitás típusa.

Érték	Description
User
Application
ManagedIdentity
Key

DeletePolicy

Felsorolás

Töröld az opciókat az ARM által kezelt névtérhez.

Érték	Description
Keep	Töröld az ARM erőforrást, de tartsd meg a Névteret.
Delete	Töröld mind az ARM erőforrást, mind a Namespace-t.

ErrorAdditionalInfo

Tárgy

Az erőforrás-kezelési hiba további információi.

Name	Típus	Description
info	object	A további információk.
type	string	A további információtípus.

ErrorDetail

Tárgy

A hiba részletei.

Name	Típus	Description
additionalInfo	ErrorAdditionalInfo[]	A hiba további információi.
code	string	A hibakód.
details	ErrorDetail[]	A hiba részletei.
message	string	A hibaüzenet.
target	string	A hiba célpontja.

ErrorResponse

Tárgy

Hibaválasz

Name	Típus	Description
error	ErrorDetail	A hibaobjektum.

FleetManagedNamespace

Tárgy

Egy flotta által kezelt névtér.

Name	Típus	Description
eTag	string	Ha az eTag szerepel a válasz törzsében, akkor a szokásos etag-konvenciók szerint fejlécként is megadható. Az entitáscímkék két vagy több entitás egyazon kért erőforrásból való összehasonlítására szolgálnak. A HTTP/1.1 entitáscímkéket használ az etagben (14.19. szakasz), If-Match (14.24. szakasz), If-None-Match (14.26. szakasz) és If-Range (14.27. szakasz) fejlécmezőkben.
id	string (arm-id)	Az erőforrás teljes erőforrás-azonosítója. Például: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Az a földrajzi hely, ahol az erőforrás él
name	string	Az erőforrás neve
properties	FleetManagedNamespaceProperties	Az erőforrás erőforrás-specifikus tulajdonságai.
systemData	systemData	A createdBy és a modifiedBy adatokat tartalmazó Azure Resource Manager-metaadatok.
tags	object	Erőforráscímkék.
type	string	Az erőforrás típusa. Pl. "Microsoft.Compute/virtualMachines" vagy "Microsoft.Storage/storageAccounts"

FleetManagedNamespaceProperties

Tárgy

A flotta tulajdonai a névtér kezelése.

Name	Típus	Description
adoptionPolicy	AdoptionPolicy	Akció, ha a menedzselt névtér ugyanazzal a nevével már létezik. Az alapértelmezés a Soha.
deletePolicy	DeletePolicy	Töröld a flotta által kezelt névtér opcióit. Az alapértelmezés a Fenntartás.
managedNamespaceProperties	ManagedNamespaceProperties	A flotta névtér tulajdonságai kezelték a névteret.
portalFqdn	string	A Fleet Hub Azure Portal teljes tartományneve.
propagationPolicy	PropagationPolicy	A névtér létrehozásához szükséges terjedési profil.
provisioningState	FleetManagedNamespaceProvisioningState	Az utolsó művelet állapota.
status	FleetManagedNamespaceStatus	A flotta által kezelt névtér utolsó műveletének állapotinformációi.

FleetManagedNamespaceProvisioningState

Felsorolás

A flotta ellátó állapota a névtér által kezelt erőforrás

Érték	Description
Succeeded	Az erőforrás létrejött.
Failed	Az erőforrás létrehozása nem sikerült.
Canceled	Az erőforrás létrehozása megszakadt.
Creating	A flotta által kezelt névtér ellátási állapota létrejött.
Updating	A flotta által kezelt névtér ellátási állapota frissül.
Deleting	A flotta által kezelt névtér ellátási állapota törlésre került.

FleetManagedNamespaceStatus

Tárgy

A flotta által kezelt névtér állapotinformációi.

Name	Típus	Description
lastOperationError	ErrorDetail	A flotta utolsó üzemeltetési hibája a kezelő névtér
lastOperationId	string	A flotta utolsó műveleti azonosítója a kezelt névtér

LabelSelectorOperator

Felsorolás

operátor egy kulcs egy értékkészlethez való viszonyát jelöli. Az érvényes operátorok: In, NotIn, Exists és DoesNotExist.

Érték	Description
In	Címkéválasztó operátor A Ben
NotIn	Címkeválasztó operátor NotIn
Exists	Címkeválasztó operátor létezik
DoesNotExist	Label Selector Operator DoesNotExist

ManagedNamespaceProperties

Tárgy

A flotta névtér tulajdonságai kezelték a névteret.

Name	Típus	Description
annotations	object	A flotta jegyzetei a névtér kezelését használták.
defaultNetworkPolicy	NetworkPolicy	A flotta alapértelmezett hálózati szabályzata a kezelt névtér.
defaultResourceQuota	ResourceQuota	A flotta által kezelt névtér alapértelmezett erőforráskvótája.
labels	object	A flotta címkéi kezelték a névteret.

Meta.V1.LabelSelector

Tárgy

A címkeválasztók egy erőforráskészleten keresztüli címke-lekérdezések. A matchLabels és a matchExpressions eredménye ANDed. Az üres címkeválasztó az összes objektumnak megfelel. A nullcímke-választó nem felel meg objektumoknak.

Name	Típus	Description
matchExpressions	Meta.V1.LabelSelectorRequirement[]	A matchExpressions a címkeválasztó követelmények listája. A követelmények ANDedek.
matchLabels	object	a matchLabels {key,value} párok leképezése. A matchLabels-megfeleltetés egyetlen {key,value} eleme egyenértékű a matchExpressions elemével, amelynek kulcsmezője "kulcs", az operátor "In", az értéktömb pedig csak az "érték" értéket tartalmazza. A követelmények ANDedek.

Meta.V1.LabelSelectorRequirement

Tárgy

A címkeválasztó követelmény egy olyan választó, amely értékeket, kulcsot és a kulcsot és értékeket összekapcsoló operátort tartalmaz.

Name	Típus	Description
key	string	A kulcs az a címkekulcs, amelyre a választó vonatkozik.
operator	LabelSelectorOperator	operátor egy kulcs egy értékkészlethez való viszonyát jelöli. Az érvényes operátorok: In, NotIn, Exists és DoesNotExist.
values	string[]	az értékek sztringértékek tömbje. Ha az operátor In vagy NotIn, az értéktömbnek nem üresnek kell lennie. Ha az operátor Létezik vagy DoesNotExist, az értéktömbnek üresnek kell lennie. Ezt a tömböt egy stratégiai egyesítési javítás során cseréli le a rendszer.

NetworkPolicy

Tárgy

A kezelt névtér hálózati szabályzata.

Name	Típus	Description
egress	PolicyRule	A menedzselt névtér kilépési szabályzata.
ingress	PolicyRule	A menedzselt névtér belépési szabályzata.

Placement.V1.Affinity

Tárgy

Az affinitás egy csoportos klaszteraffinitás ütemezési szabály. Még többet hozzáteszünk.

Name	Típus	Description
clusterAffinity	Placement.V1.ClusterAffinity	A ClusterAffinity tartalmazza a klaszter affinitás ütemezési szabályokat a kiválasztott erőforrásokhoz.

Placement.V1.ClusterAffinity

Tárgy

A ClusterAffinity tartalmazza a klaszter affinitás ütemezési szabályokat a kiválasztott erőforrásokhoz.

Name	Típus	Description
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Ha a mező által meghatározott affinitási követelmények nem teljesülnek az ütemezési időben, az erőforrás nem lesz ütemezve a klaszterre. Ha a mező által meghatározott affinitási követelmények a telepítés után (például frissítés miatt) megszűnnek teljesíteni, a rendszer megpróbálhatja vagy nem próbálja eltávolítani az erőforrást a klaszterből.

Placement.V1.ClusterResourcePlacementSpec

Tárgy

A ClusterResourcePlacementSpec meghatározza a ClusterResourcePlacement kívánt állapotát.

Name	Típus	Description
policy	Placement.V1.PlacementPolicy	A szabályzat meghatározza, hogyan válasszuk ki a tagklasztereket a kiválasztott erőforrások elhelyezéséhez. Ha nincs meghatározva, az összes egyesített tagklasztert kiválasztjuk.

Placement.V1.ClusterSelector

Tárgy

ClusterSelector

Name	Típus	Description
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	A ClusterSelectorTerms klaszterválasztó kifejezések listája. A kifejezések : ORed.

Placement.V1.ClusterSelectorTerm

Tárgy

ClusterSelectorTerm

Name	Típus	Description
labelSelector	Meta.V1.LabelSelector	A LabelSelector egy címkés lekérdezés az összes összekapcsolt tagklaszterre. A lekérdezéshez illeszkedő klasztereket választják ki. Ha ugyanabban a kifejezésben megadod a címkét és a tulajdonságválasztókat, az eredmények ÉS lesznek.
propertySelector	Placement.V1.PropertySelector	Az PropertySelector egy tulajdonságlekérdezés az összes tag klaszterre vonatkozóan. A lekérdezéshez illeszkedő klasztereket választják ki. Ha ugyanabban a kifejezésben megadod a címkét és a tulajdonságválasztókat, az eredmények ÉS lesznek. Jelenleg a PropertySelector csak affinitáskifejezésekkel használható RequiredDuringSchedulingIgnoredDuringExecution . Ez a mező béta-szintű; Ez a tulajdonságalapú ütemezési funkcióra vonatkozik, és csak akkor működik, ha egy tulajdonságszolgáltató engedélyezve van a telepítésben.

Placement.V1.PlacementPolicy

Tárgy

A PlacementPolicy tartalmazza azokat a szabályokat, amelyek a céltag klasztereket választják ki a kiválasztott erőforrások elhelyezésére. Fontos megjegyezni, hogy csak olyan klasztereket választanak ki, amelyek egyszerre csatlakoznak és teljesítenek a szabályoknak. Legfeljebb az egyik két mezőt tudod megadni: ClusterNames és Affinity. Ha nincs megadva, az összes összekapcsolt klasztert kiválasztjuk.

Name	Típus	Description
affinity	Placement.V1.Affinity	Az affinitás tartalmazza a klaszteraffinitás ütemezési szabályokat. Meghatározza, mely tagklasztereket helyezik el a kiválasztott erőforrásokat. Csak akkor érvényes, ha az elhelyezési típus "PickAll" vagy "PickN".
clusterNames	string[]	A ClusterNames tartalmazza a MemberCluster neveinek listáját, amelyekkel a kiválasztott erőforrásokat elhelyezhetjük. Csak akkor érvényes, ha az elhelyezési típus "PickFixed".
placementType	PlacementType	A helymeghatározás típusa. Lehet "PickAll", "PickN" vagy "PickFixed". Az alapértelmezett a PickAll.
tolerations	Placement.V1.Toleration[]	Ha van megadva, akkor a ClusterResourcePlacement toleranációi. A toleranációkat nem lehet frissíteni vagy törölni. Ez a pálya béta-szintű, és a szennyeződések és toleranciák funkcióját szolgálja.

Placement.V1.PropertySelector

Tárgy

Az PropertySelector segít a felhasználóknak megadni a tulajdonságkövetelményeket a klaszterek kiválasztásakor az erőforrás-elhelyezéshez.

Name	Típus	Description
matchExpressions	Placement.V1.PropertySelectorRequirement[]	A MatchExpressions egy PropertySelectorRequirements tömbje. A követelmények ÉS a ÉS vannak megfogalmazva.

Placement.V1.PropertySelectorRequirement

Tárgy

PropertySelectorRequirement egy specifikus tulajdonságkövetelmény, amikor klasztereket választunk erőforrás-elhelyezéshez.

Name	Típus	Description
name	string	A név az ingatlan neve; Kubernetes címke kellene legyen.
operator	PropertySelectorOperator	Az operátor meghatározza a klaszter megfigyelt értéke és a követelményben megadott értékek közötti kapcsolatot.
values	string[]	Az értékek a megadott tulajdonság értékeinek listája, amelyet a Fleet összehasonlít az adott operátor szerint az egyes tagklaszterek megfigyelt értékeivel. Ebben a pillanatban minden értéknek Kubernetes mennyiségnek kell lennie. További információért lásd https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Ha az operátor Gt (nagyobb), Ge (nagyobb vagy egyenlő), Lt (kisebb), vagy Le (kisebb vagy egyenlő), Eq (egyenlő) vagy Ne (ne), pontosan egy értéket kell megadni a listán.

Placement.V1.Toleration

Tárgy

A toleranálás lehetővé teszi a ClusterResourcePlacement számára, hogy elviselje bármilyen szennyeződést, amely megfelel a háromkulcs<, érték, hatás> a megfelelő operátor<> segítségével.

Name	Típus	Description
effect	TaintEffect	A hatás azt jelzi, hogy a szennyező hatás illeszkedik. Az üres azt jelenti, hogy minden fertőzött hatás egyezik. Megadva az egyetlen engedélyezett érték a NoSchedule.
key	string	A kulcs az a szennyező kulcs, amire a tolerancia vonatkozik. Az üres azt jelenti, hogy minden szennyező kulcsot egyeztet. Ha a kulcs üres, akkor az operátornak Létezik kell lennie; Ez a kombináció azt jelenti, hogy minden értéket és kulcsot egyeztetünk.
operator	TolerationOperator	Az operátor a kulcs és az érték közötti kapcsolatát jelenti. Az érvényes operátorok a Létező és Egyenértékűek. Alapértelmezettként egyenlő állapotban van. A Exists értékben a vaker érték értékével egyenértékű, így egy ClusterResourcePlacement elviselheti az adott kategória összes szennyezését.
value	string	Az érték az a szennyező érték, amelyhez a tolerancia megegyezik. Ha az operátor Exists, akkor az értéknek üresnek kell lennie, különben csak egy sima string.

PlacementProfile

Tárgy

Az alapértelmezett ClusterResourcePlacement konfigurációs profilja az elhelyezéshez.

Name	Típus	Description
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	Az alapértelmezett ClusterResourcePlacement szabályzat konfigurációja.

PlacementType

Felsorolás

A helymeghatározás típusa. Lehet "PickAll", "PickN" vagy "PickFixed". Az alapértelmezett a PickAll.

Érték	Description
PickAll	A PickAll minden olyan csoportot választ, amely megfelel a szabályoknak.
PickFixed	A PickFixed egy fix klaszterkészletet választ.

PolicyRule

Felsorolás

A lehetséges értékek különböző hálózati szabályzati szabályokat képviselnek.

Érték	Description
AllowAll	Minden hálózati forgalom engedélyezése.
DenyAll	Tiltson le minden hálózati forgalmat.
AllowSameNamespace	Engedélyezze a forgalmat ugyanazon a névtéren belül.

PropagationPolicy

Tárgy

A terjedés, amelyet a flotta névtér ellátására használnak.

Name	Típus	Description
placementProfile	PlacementProfile	A profil, amelyet elhelyezéssel való terjesztésre használnak.
type	PropagationType	Milyen típusú kötvény van, amit alkalmazni kell. Az alapértelmezés az elhelyezés.

PropagationType

Felsorolás

Hogyan fogják a névtér ellátmányozni a flottatagok között.

Érték	Description
Placement	ClusterResourcePlacement használatával.

PropertySelectorOperator

Felsorolás

Az operátor meghatározza a klaszter megfigyelt értéke és a követelményben megadott értékek közötti kapcsolatot.

Érték	Description
Gt	Gt előírja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke nagyobb, mint a követelményben megadott érték.
Ge	A Ge előírja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke nagyobb, mint vagy egyenlő a követelményben megadott értékkel.
Eq	Az EQ előírja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke megegyezik a követelményben megadott értékekkel.
Ne	Ne előírja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke nem egyezik meg a követelményben megadott értékekkel.
Lt	Lt előírja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke kisebb, mint a követelményben megadott érték.
Le	Le diktálja a Fleetnek, hogy válasszon klasztert, ha egy adott tulajdonság megfigyelt értéke kisebb, mint a követelményben megadott érték.

ResourceQuota

Tárgy

A kezelt névtér erőforráskvótája.

Name	Típus	Description
cpuLimit	string	A CPU korlátja a kezelt névtérhez. További információ: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	A CPU kérése a kezelt névtérre. További információ: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	A menedzselt névtér memóriakorlátja. További információ: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	A menedzselt névtér memóriakérése. További információ: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Tárgy

Az erőforrás létrehozásával és utolsó módosításával kapcsolatos metaadatok.

Name	Típus	Description
createdAt	string (date-time)	Az erőforrás-létrehozás időbélyege (UTC).
createdBy	string	Az erőforrást létrehozó identitás.
createdByType	createdByType	Az erőforrást létrehozó identitás típusa.
lastModifiedAt	string (date-time)	Az erőforrás utolsó módosításának időbélyege (UTC)
lastModifiedBy	string	Az erőforrást legutóbb módosító identitás.
lastModifiedByType	createdByType	Az erőforrást legutóbb módosító identitás típusa.

TaintEffect

Felsorolás

A hatás azt jelzi, hogy a szennyező hatás illeszkedik. Az üres azt jelenti, hogy minden fertőzött hatás egyezik. Megadva az egyetlen engedélyezett érték a NoSchedule.

Érték	Description
NoSchedule	Ne engedd, hogy új podok ütemezződjenek a csomópontra, hacsak nem tűrik a szennyeződést, de minden kapszulát a Kubeletnek küldött kapszul anélkül, hogy az ütemező indult volna, és engedd az összes már működő pod folytatását. A beosztó érvényesíti.

TolerationOperator

Felsorolás

Az operátor a kulcs és az érték közötti kapcsolatát jelenti. Az érvényes operátorok a Létező és Egyenértékűek. Alapértelmezettként egyenlő állapotban van. A Exists értékben a vaker érték értékével egyenértékű, így egy ClusterResourcePlacement elviselheti az adott kategória összes szennyezését.

Érték	Description
Exists	Tolerációs operátor létezik
Equal	Tolerációs operátor egyenlő