Fleet Managed Namespaces - Create Or Update

Servicio:

Fleet

Versión de la API:

2026-02-01-preview

Crear un espacio de nombres gestionado por la flota

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

Parámetros de identificador URI

Nombre	En	Requerido	Tipo	Description
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Nombre del recurso Fleet.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	El nombre del recurso de espacio de nombres gestionado por la flota.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Nombre del grupo de recursos. El nombre distingue mayúsculas de minúsculas.
subscriptionId	path	True	string (uuid)	Identificador de la suscripción de destino. El valor debe ser un UUID.
api-version	query	True	string minLength: 1	Versión de API que se usará para la operación.

Encabezado de la solicitud

Nombre	Requerido	Tipo	Description
If-Match		string	La solicitud solo debe continuar si una entidad coincide con esta cadena.
If-None-Match		string	La solicitud solo debe continuar si ninguna entidad coincide con esta cadena.

Cuerpo de la solicitud

Nombre	Requerido	Tipo	Description
location	True	string	Ubicación geográfica donde reside el recurso
properties		FleetManagedNamespaceProperties	Propiedades específicas del recurso para este recurso.
tags		object	Etiquetas de recursos.

Respuestas

Nombre	Tipo	Description
200 OK	FleetManagedNamespace	Operación de actualización del recurso 'FleetManagedNamespace' exitosa
201 Created	FleetManagedNamespace	Recurso 'FleetManagedNamespace' crear operación exitosa Encabezados Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Una respuesta de error inesperada.

Seguridad

azure_auth

Azure Active Directory OAuth2 Flow.

Tipo: oauth2
Flujo: implicit
Dirección URL de autorización: https://login.microsoftonline.com/common/oauth2/authorize

Ámbitos

Nombre	Description
user_impersonation	suplantar la cuenta de usuario

Ejemplos

FleetManagedNamespaces_CreateOrUpdate

Solicitud de ejemplo

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

Respuesta de muestra

status code:

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

status code:

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

Definiciones

Nombre	Description
AdoptionPolicy	Acción si el espacio de nombres con el mismo nombre ya existe.
createdByType	Tipo de identidad que creó el recurso.
DeletePolicy	Eliminar opciones para el espacio de nombres gestionado por ARM.
ErrorAdditionalInfo	Información adicional sobre el error de administración de recursos.
ErrorDetail	Detalle del error.
ErrorResponse	Respuesta de error
FleetManagedNamespace	Un espacio de nombres gestionado por flota.
FleetManagedNamespaceProperties	Las propiedades de un espacio de nombres gestionado por flota.
FleetManagedNamespaceProvisioningState	El estado de aprovisionamiento del recurso de espacio de nombres gestionado por flota
FleetManagedNamespaceStatus	Información de estado para el espacio de nombres gestionado por flota.
LabelSelectorOperator	operator representa la relación de una clave con un conjunto de valores. Los operadores válidos son In, NotIn, Exists y DoesNotExist.
ManagedNamespaceProperties	Las propiedades del espacio de nombres gestionado por flota.
Meta.V1.LabelSelector	Un selector de etiquetas es una consulta de etiqueta sobre un conjunto de recursos. El resultado de matchLabels y matchExpressions son ANDed. Un selector de etiquetas vacío coincide con todos los objetos. Un selector de etiquetas null no coincide con ningún objeto.
Meta.V1.LabelSelectorRequirement	Un requisito del selector de etiquetas es un selector que contiene valores, una clave y un operador que relaciona la clave y los valores.
NetworkPolicy	La política de red para el espacio de nombres gestionado.
Placement.V1.Affinity	La afinidad es un conjunto de reglas de planificación de afinidad por clústeres. Más por añadir.
Placement.V1.ClusterAffinity	ClusterAffinity contiene reglas de planificación de afinidad de clúster para los recursos seleccionados.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec define el estado deseado de ClusterResourcePlacement.
Placement.V1.ClusterSelector	Selector de Clústeres
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy contiene las reglas para seleccionar los clústeres de miembros objetivo que colocan los recursos seleccionados. Ten en cuenta que solo se seleccionarán los clústeres que estén unidos y que cumplan las reglas. Solo puedes especificar como mucho uno de los dos campos: Nombres de Clúster y Afinidad. Si no se especifica ninguno, se seleccionan todos los clústeres unidos.
Placement.V1.PropertySelector	PropertySelector ayuda al usuario a especificar los requisitos de propiedad al elegir clústeres para la colocación de recursos.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement es un requisito específico de propiedad al seleccionar clústeres para la colocación de recursos.
Placement.V1.Toleration	La tolerancia permite a ClusterResourcePlacement tolerar cualquier contaminación que coincida con la triple <key,value,effect> usando el operador <>de operador de correspondencia.
PlacementProfile	El perfil de configuración para ClusterResourcePlacement por defecto para la ubicación.
PlacementType	Tipo de colocación. Puede ser "PickAll", "PickN" o "PickFixed". Por defecto es PickAll.
PolicyRule	Los valores posibles que representan diferentes reglas de política de red.
PropagationPolicy	La propagación se usará para abastecer el espacio de nombres dentro de la flota.
PropagationType	Cómo se provisionará el espacio de nombres entre los miembros de la flota.
PropertySelectorOperator	El operador especifica la relación entre el valor observado de la propiedad especificada por un clúster y los valores dados en el requisito.
ResourceQuota	La cuota de recursos para el espacio de nombres gestionado.
systemData	Metadatos relativos a la creación y última modificación del recurso.
TaintEffect	Efecto indica el efecto de contaminación correspondiente. Vacío significa que igualan todos los efectos de contaminación. Cuando se especifica, el único valor permitido es NoSchedule.
TolerationOperator	El operador representa la relación de una clave con el valor. Los operadores válidos son Exists e Equal. Por defecto es igual. Exists es equivalente a comodín por valor, de modo que un ClusterResourcePlacement puede tolerar todas las manchas de una categoría particular.

AdoptionPolicy

Enumeración

Acción si el espacio de nombres con el mismo nombre ya existe.

Valor	Description
Never	Si el Espacio de Nombres ya existe, no tomes el control del Espacio de Nombres existente para que ARM lo gestione.
IfIdentical	Si existe un Espacio de Nombres idéntico, toma el control del Espacio de Nombres existente que será gestionado por ARM.
Always	Toma siempre el Namespace existente para que ARM lo gestione, aunque no sea idéntico.

createdByType

Enumeración

Tipo de identidad que creó el recurso.

Valor	Description
User
Application
ManagedIdentity
Key

DeletePolicy

Enumeración

Eliminar opciones para el espacio de nombres gestionado por ARM.

Valor	Description
Keep	Elimina el recurso ARM pero mantén el espacio de nombres.
Delete	Elimina tanto el recurso ARM como el espacio de nombres.

ErrorAdditionalInfo

Objeto

Información adicional sobre el error de administración de recursos.

Nombre	Tipo	Description
info	object	Información adicional.
type	string	Tipo de información adicional.

ErrorDetail

Objeto

Detalle del error.

Nombre	Tipo	Description
additionalInfo	ErrorAdditionalInfo[]	Información adicional del error.
code	string	Código de error.
details	ErrorDetail[]	Detalles del error.
message	string	El mensaje de error.
target	string	Destino del error.

ErrorResponse

Objeto

Respuesta de error

Nombre	Tipo	Description
error	ErrorDetail	Objeto de error.

FleetManagedNamespace

Objeto

Un espacio de nombres gestionado por flota.

Nombre	Tipo	Description
eTag	string	Si eTag se proporciona en el cuerpo de la respuesta, también se puede proporcionar como encabezado según la convención de etag normal. Las etiquetas de entidad se usan para comparar dos o más entidades del mismo recurso solicitado. HTTP/1.1 usa etiquetas de entidad en etag (sección 14.19), If-Match (sección 14.24), If-None-Match (sección 14.26) y If-Range (sección 14.27) campos de encabezado.
id	string (arm-id)	Identificador de recurso completo para el recurso. Por ejemplo, "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Ubicación geográfica donde reside el recurso
name	string	Nombre del recurso
properties	FleetManagedNamespaceProperties	Propiedades específicas del recurso para este recurso.
systemData	systemData	Azure Resource Manager metadatos que contienen información createdBy y modifiedBy.
tags	object	Etiquetas de recursos.
type	string	Tipo de recurso. Por ejemplo, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"

FleetManagedNamespaceProperties

Objeto

Las propiedades de un espacio de nombres gestionado por flota.

Nombre	Tipo	Description
adoptionPolicy	AdoptionPolicy	Acción si el espacio de nombres gestionado con el mismo nombre ya existe. El predeterminado es nunca.
deletePolicy	DeletePolicy	Eliminar opciones de un espacio de nombres gestionado por flota. El predeterminado es Keep.
managedNamespaceProperties	ManagedNamespaceProperties	Las propiedades del espacio de nombres gestionado por flota.
portalFqdn	string	FQDN de Azure Portal del centro de flotas.
propagationPolicy	PropagationPolicy	El perfil de la propagación para crear el espacio de nombres.
provisioningState	FleetManagedNamespaceProvisioningState	Estado de la última operación.
status	FleetManagedNamespaceStatus	Información de estado de la última operación para el espacio de nombres gestionado por flota.

FleetManagedNamespaceProvisioningState

Enumeración

El estado de aprovisionamiento del recurso de espacio de nombres gestionado por flota

Valor	Description
Succeeded	Se ha creado el recurso.
Failed	Error en la creación de recursos.
Canceled	Se canceló la creación de recursos.
Creating	El estado de aprovisionamiento de un espacio de nombres gestionado por flota que se está creando.
Updating	El estado de aprovisionamiento de un espacio de nombres gestionado por flota se está actualizando.
Deleting	El estado de aprovisionamiento de un espacio de nombres gestionado por flota fue eliminado.

FleetManagedNamespaceStatus

Objeto

Información de estado para el espacio de nombres gestionado por flota.

Nombre	Tipo	Description
lastOperationError	ErrorDetail	El último error de operación del espacio de nombres gestionado por flota
lastOperationId	string	El último ID de operación para el espacio de nombres gestionado por flota

LabelSelectorOperator

Enumeración

operator representa la relación de una clave con un conjunto de valores. Los operadores válidos son In, NotIn, Exists y DoesNotExist.

Valor	Description
In	Operador selector de etiquetas en
NotIn	Operador selector de etiquetas NotIn
Exists	Existe el operador selector de etiquetas
DoesNotExist	El operador selector de etiquetas NoExisteExiste

ManagedNamespaceProperties

Objeto

Las propiedades del espacio de nombres gestionado por flota.

Nombre	Tipo	Description
annotations	object	Las anotaciones para el espacio de nombres gestionado por la flota.
defaultNetworkPolicy	NetworkPolicy	La política de red predeterminada para el espacio de nombres gestionado por flota.
defaultResourceQuota	ResourceQuota	La cuota de recursos predeterminada para el espacio de nombres gestionado por flota.
labels	object	Las etiquetas del espacio de nombres gestionado por la flota.

Meta.V1.LabelSelector

Objeto

Un selector de etiquetas es una consulta de etiqueta sobre un conjunto de recursos. El resultado de matchLabels y matchExpressions son ANDed. Un selector de etiquetas vacío coincide con todos los objetos. Un selector de etiquetas null no coincide con ningún objeto.

Nombre	Tipo	Description
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions es una lista de requisitos del selector de etiquetas. Los requisitos son ANDed.
matchLabels	object	matchLabels es un mapa de pares {key,value}. Un único {key,value} en el mapa matchLabels es equivalente a un elemento de matchExpressions, cuyo campo de clave es "key", el operador es "In" y la matriz de valores contiene solo "value". Los requisitos son ANDed.

Meta.V1.LabelSelectorRequirement

Objeto

Un requisito del selector de etiquetas es un selector que contiene valores, una clave y un operador que relaciona la clave y los valores.

Nombre	Tipo	Description
key	string	key es la clave de etiqueta a la que se aplica el selector.
operator	LabelSelectorOperator	operator representa la relación de una clave con un conjunto de valores. Los operadores válidos son In, NotIn, Exists y DoesNotExist.
values	string[]	values es una matriz de valores de cadena. Si el operador es In o NotIn, la matriz de valores debe no estar vacía. Si el operador es Exists o DoesNotExist, la matriz de valores debe estar vacía. Esta matriz se reemplaza durante una revisión de combinación estratégica.

NetworkPolicy

Objeto

La política de red para el espacio de nombres gestionado.

Nombre	Tipo	Description
egress	PolicyRule	La política de salida para el espacio de nombres gestionado.
ingress	PolicyRule	La política de entrada para el espacio de nombres gestionado.

Placement.V1.Affinity

Objeto

La afinidad es un conjunto de reglas de planificación de afinidad por clústeres. Más por añadir.

Nombre	Tipo	Description
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity contiene reglas de planificación de afinidad de clúster para los recursos seleccionados.

Placement.V1.ClusterAffinity

Objeto

ClusterAffinity contiene reglas de planificación de afinidad de clúster para los recursos seleccionados.

Nombre	Tipo	Description
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Si los requisitos de afinidad especificados por este campo no se cumplen en el momento de la planificación, el recurso no se programará en el clúster. Si los requisitos de afinidad especificados por este campo dejan de cumplirse en algún momento después de la colocación (por ejemplo, debido a una actualización), el sistema puede o no intentar eliminar el recurso del clúster.

Placement.V1.ClusterResourcePlacementSpec

Objeto

ClusterResourcePlacementSpec define el estado deseado de ClusterResourcePlacement.

Nombre	Tipo	Description
policy	Placement.V1.PlacementPolicy	La política define cómo seleccionar los clústeres de miembros para colocar los recursos seleccionados. Si no se especifica, se seleccionan todos los clústeres de miembros unidos.

Placement.V1.ClusterSelector

Objeto

Selector de Clústeres

Nombre	Tipo	Description
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms es una lista de términos selectores de grupos. Los términos son ORed.

Placement.V1.ClusterSelectorTerm

Objeto

ClusterSelectorTerm

Nombre	Tipo	Description
labelSelector	Meta.V1.LabelSelector	LabelSelector es una consulta de etiquetas sobre todos los clústeres miembros unidos. Se seleccionan los clústeres que coinciden con la consulta. Si especificas tanto los selectores de etiquetas como los de propiedades en el mismo término, los resultados son Y se resuelven.
propertySelector	Placement.V1.PropertySelector	PropertySelector es una consulta de propiedades sobre todos los clústeres miembros unidos. Se seleccionan los clústeres que coinciden con la consulta. Si especificas tanto los selectores de etiquetas como los de propiedades en el mismo término, los resultados son Y se resuelven. Por ahora, PropertySelector solo puede usarse con RequiredDuringSchedulingIgnoredDuringExecution términos de afinidad. Este campo es de nivel beta; Es para la función de planificación basada en propiedades y solo funciona cuando un proveedor de propiedades está habilitado en el despliegue.

Placement.V1.PlacementPolicy

Objeto

PlacementPolicy contiene las reglas para seleccionar los clústeres de miembros objetivo que colocan los recursos seleccionados. Ten en cuenta que solo se seleccionarán los clústeres que estén unidos y que cumplan las reglas. Solo puedes especificar como mucho uno de los dos campos: Nombres de Clúster y Afinidad. Si no se especifica ninguno, se seleccionan todos los clústeres unidos.

Nombre	Tipo	Description
affinity	Placement.V1.Affinity	Affinity contiene reglas de planificación de afinidad por clúster. Define qué clústeres de miembros colocar los recursos seleccionados. Solo válido si el tipo de colocación es "PickAll" o "PickN".
clusterNames	string[]	ClusterNames contiene una lista de nombres de MemberCluster para colocar los recursos seleccionados. Solo válido si el tipo de colocación es "PickFixed"
placementType	PlacementType	Tipo de colocación. Puede ser "PickAll", "PickN" o "PickFixed". Por defecto es PickAll.
tolerations	Placement.V1.Toleration[]	Si se especifica, las tolerancias de ClusterResourcePlacement. Las tolerancias no pueden actualizarse ni eliminarse. Este campo es de nivel beta y es para la característica de contaminaciones y tolerancias.

Placement.V1.PropertySelector

Objeto

PropertySelector ayuda al usuario a especificar los requisitos de propiedad al elegir clústeres para la colocación de recursos.

Nombre	Tipo	Description
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions es un conjunto de PropertySelectorRequirements. Los requisitos están Y definidos.

Placement.V1.PropertySelectorRequirement

Objeto

PropertySelectorRequirement es un requisito específico de propiedad al seleccionar clústeres para la colocación de recursos.

Nombre	Tipo	Description
name	string	El nombre es el nombre de la propiedad; debería ser un nombre de marca Kubernetes.
operator	PropertySelectorOperator	El operador especifica la relación entre el valor observado de la propiedad especificada por un clúster y los valores dados en el requisito.
values	string[]	Los valores son una lista de valores de la propiedad especificada que Fleet comparará con los valores observados de los grupos miembros individuales de acuerdo con el operador dado. En este momento, cada valor debería ser una cantidad de Kubernetes. Para obtener más información, consulte https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Si el operador es Gt (mayor que), Ge (mayor o igual a), Lt (menor que), o Le (menor o igual a), Eq (igual a) o Ne (ne), se debe especificar exactamente un valor en la lista.

Placement.V1.Toleration

Objeto

La tolerancia permite a ClusterResourcePlacement tolerar cualquier contaminación que coincida con la triple <key,value,effect> usando el operador <>de operador de correspondencia.

Nombre	Tipo	Description
effect	TaintEffect	Efecto indica el efecto de contaminación correspondiente. Vacío significa que igualan todos los efectos de contaminación. Cuando se especifica, el único valor permitido es NoSchedule.
key	string	La clave es la clave de contaminación a la que se aplica la tolerancia. Vacío significa que coinciden todas las claves de contaminación. Si la clave está vacía, el operador debe ser Existe; Esta combinación significa que todos los valores y todas las claves coinciden.
operator	TolerationOperator	El operador representa la relación de una clave con el valor. Los operadores válidos son Exists e Equal. Por defecto es igual. Exists es equivalente a comodín por valor, de modo que un ClusterResourcePlacement puede tolerar todas las manchas de una categoría particular.
value	string	El valor es el valor de contaminación al que corresponde la tolerancia. Si el operador es Exists, el valor debería estar vacío, de lo contrario solo una cadena normal.

PlacementProfile

Objeto

El perfil de configuración para ClusterResourcePlacement por defecto para la ubicación.

Nombre	Tipo	Description
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	La configuración predeterminada de la política ClusterResourcePlacement.

PlacementType

Enumeración

Tipo de colocación. Puede ser "PickAll", "PickN" o "PickFixed". Por defecto es PickAll.

Valor	Description
PickAll	PickAll selecciona todos los clústeres que cumplen las reglas.
PickFixed	PickFixed elige un conjunto fijo de clústeres.

PolicyRule

Enumeración

Los valores posibles que representan diferentes reglas de política de red.

Valor	Description
AllowAll	Permitir todo el tráfico de red.
DenyAll	Denegar todo el tráfico de red.
AllowSameNamespace	Permitir el tráfico dentro del mismo espacio de nombres.

PropagationPolicy

Objeto

La propagación se usará para abastecer el espacio de nombres dentro de la flota.

Nombre	Tipo	Description
placementProfile	PlacementProfile	El perfil que se usará para propagación mediante colocación.
type	PropagationType	El tipo de póliza que se va a utilizar. Por defecto es la colocación.

PropagationType

Enumeración

Cómo se provisionará el espacio de nombres entre los miembros de la flota.

Valor	Description
Placement	Usando ClusterResourcePlacement.

PropertySelectorOperator

Enumeración

El operador especifica la relación entre el valor observado de la propiedad especificada por un clúster y los valores dados en el requisito.

Valor	Description
Gt	Gt dicta que la flota seleccione el clúster si su valor observado de una propiedad dada es mayor que el valor especificado en el requisito.
Ge	Ge dicta que la flota seleccione el clúster si su valor observado de una propiedad dada es mayor o igual al valor especificado en el requisito.
Eq	La EQ dicta que la flota seleccione el clúster si su valor observado de una propiedad dada es igual a los valores especificados en el requisito.
Ne	Ne dicta que la Flota seleccione el clúster si su valor observado de una propiedad dada no es igual a los valores especificados en el requisito.
Lt	Lt dicta que la Flota seleccione el clúster si su valor observado de una propiedad dada es menor que el valor especificado en el requisito.
Le	Le dicta a la Flota que seleccione el clúster si su valor observado de una propiedad dada es menor o igual al valor especificado en el requisito.

ResourceQuota

Objeto

La cuota de recursos para el espacio de nombres gestionado.

Nombre	Tipo	Description
cpuLimit	string	El límite de CPU para el espacio de nombres gestionado. Consulte más información en https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	La solicitud de la CPU para el espacio de nombres gestionado. Consulte más información en https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	El límite de memoria para el espacio de nombres gestionado. Consulte más información en https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	La solicitud de memoria para el espacio de nombres gestionado. Consulte más información en https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Objeto

Metadatos relativos a la creación y última modificación del recurso.

Nombre	Tipo	Description
createdAt	string (date-time)	Marca de tiempo de creación de recursos (UTC).
createdBy	string	Identidad que creó el recurso.
createdByType	createdByType	Tipo de identidad que creó el recurso.
lastModifiedAt	string (date-time)	Marca de tiempo de la última modificación del recurso (UTC)
lastModifiedBy	string	Identidad que modificó por última vez el recurso.
lastModifiedByType	createdByType	Tipo de identidad que modificó por última vez el recurso.

TaintEffect

Enumeración

Efecto indica el efecto de contaminación correspondiente. Vacío significa que igualan todos los efectos de contaminación. Cuando se especifica, el único valor permitido es NoSchedule.

Valor	Description
NoSchedule	No permitas que nuevos pods programen en el nodo a menos que toleren la contaminación, pero sí que todos los pods enviados a Kubelet sin pasar por el programador para iniciar, y que todos los pods ya en funcionamiento sigan funcionando. Lo hace cumplir el programador.

TolerationOperator

Enumeración

El operador representa la relación de una clave con el valor. Los operadores válidos son Exists e Equal. Por defecto es igual. Exists es equivalente a comodín por valor, de modo que un ClusterResourcePlacement puede tolerar todas las manchas de una categoría particular.

Valor	Description
Exists	Existe un operador de tolerancia
Equal	Operador de tolerancia igual