Fleet Managed Namespaces - Create Or Update

Service:: Fleet

API Version:: 2026-02-01-preview

Create a FleetManagedNamespace

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

URI Parameters

Name	In	Required	Type	Description
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	The name of the Fleet resource.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	The name of the fleet managed namespace resource.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	The name of the resource group. The name is case insensitive.
subscriptionId	path	True	string (uuid)	The ID of the target subscription. The value must be an UUID.
api-version	query	True	string minLength: 1	The API version to use for this operation.

Request Header

Name	Required	Type	Description
If-Match		string	The request should only proceed if an entity matches this string.
If-None-Match		string	The request should only proceed if no entity matches this string.

Request Body

Name	Required	Type	Description
location	True	string	The geo-location where the resource lives
properties		FleetManagedNamespaceProperties	The resource-specific properties for this resource.
tags		object	Resource tags.

Responses

Name	Type	Description
200 OK	FleetManagedNamespace	Resource 'FleetManagedNamespace' update operation succeeded
201 Created	FleetManagedNamespace	Resource 'FleetManagedNamespace' create operation succeeded Headers Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	An unexpected error response.

Name

Type

Description

200 OK

FleetManagedNamespace

Resource 'FleetManagedNamespace' update operation succeeded

201 Created

FleetManagedNamespace

Resource 'FleetManagedNamespace' create operation succeeded

Headers

Azure-AsyncOperation: string
Retry-After: integer

Other Status Codes

ErrorResponse

An unexpected error response.

Security

azure_auth

Azure Active Directory OAuth2 Flow.

Type: oauth2
Flow: implicit
Authorization URL: https://login.microsoftonline.com/common/oauth2/authorize

Scopes

Name	Description
user_impersonation	impersonate your user account

Examples

FleetManagedNamespaces_CreateOrUpdate

Sample request

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


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

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

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

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

Sample response

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

Definitions

Name	Description
AdoptionPolicy	Action if the Namespace with the same name already exists.
createdByType	The type of identity that created the resource.
DeletePolicy	Delete options for the ARM managed namespace.
ErrorAdditionalInfo	The resource management error additional info.
ErrorDetail	The error detail.
ErrorResponse	Error response
FleetManagedNamespace	A fleet managed namespace.
FleetManagedNamespaceProperties	The properties of a fleet managed namespace.
FleetManagedNamespaceProvisioningState	The provisioning state of the fleet managed namespace resource
FleetManagedNamespaceStatus	Status information for the fleet managed namespace.
LabelSelectorOperator	operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
ManagedNamespaceProperties	The namespace properties for the fleet managed namespace.
Meta.V1.LabelSelector	A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.
Meta.V1.LabelSelectorRequirement	A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.
NetworkPolicy	The network policy for the managed namespace.
Placement.V1.Affinity	Affinity is a group of cluster affinity scheduling rules. More to be added.
Placement.V1.ClusterAffinity	ClusterAffinity contains cluster affinity scheduling rules for the selected resources.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec defines the desired state of ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy contains the rules to select target member clusters to place the selected resources. Note that only clusters that are both joined and satisfying the rules will be selected. You can only specify at most one of the two fields: ClusterNames and Affinity. If none is specified, all the joined clusters are selected.
Placement.V1.PropertySelector	PropertySelector helps user specify property requirements when picking clusters for resource placement.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement is a specific property requirement when picking clusters for resource placement.
Placement.V1.Toleration	Toleration allows ClusterResourcePlacement to tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.
PlacementProfile	The configuration profile for default ClusterResourcePlacement for placement.
PlacementType	Type of placement. Can be "PickAll", "PickN" or "PickFixed". Default is PickAll.
PolicyRule	The possible values representing different network policy rules.
PropagationPolicy	The propagation to be used for provisioning the namespace among the fleet.
PropagationType	How the namespace will be provisioned among the fleet members.
PropertySelectorOperator	Operator specifies the relationship between a cluster's observed value of the specified property and the values given in the requirement.
ResourceQuota	The resource quota for the managed namespace.
systemData	Metadata pertaining to creation and last modification of the resource.
TaintEffect	Effect indicates the taint effect to match. Empty means match all taint effects. When specified, only allowed value is NoSchedule.
TolerationOperator	Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ClusterResourcePlacement can tolerate all taints of a particular category.

AdoptionPolicy

Enumeration

Action if the Namespace with the same name already exists.

Value	Description
Never	If the Namespace already exists, do not take over the existing Namespace to be managed by ARM.
IfIdentical	If there is an identical Namespace, take over the existing Namespace to be managed by ARM.
Always	Always take over the existing Namespace to be managed by ARM, even if it is not identical.

createdByType

Enumeration

The type of identity that created the resource.

Value	Description
User
Application
ManagedIdentity
Key

DeletePolicy

Enumeration

Delete options for the ARM managed namespace.

Value	Description
Keep	Delete the ARM resource but keep the Namespace.
Delete	Delete both ARM resource and Namespace.

ErrorAdditionalInfo

Object

The resource management error additional info.

Name	Type	Description
info	object	The additional info.
type	string	The additional info type.

ErrorDetail

Object

The error detail.

Name	Type	Description
additionalInfo	ErrorAdditionalInfo[]	The error additional info.
code	string	The error code.
details	ErrorDetail[]	The error details.
message	string	The error message.
target	string	The error target.

ErrorResponse

Object

Error response

Name	Type	Description
error	ErrorDetail	The error object.

FleetManagedNamespace

Object

A fleet managed namespace.

Name	Type	Description
eTag	string	If eTag is provided in the response body, it may also be provided as a header per the normal etag convention. Entity tags are used for comparing two or more entities from the same requested resource. HTTP/1.1 uses entity tags in the etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26), and If-Range (section 14.27) header fields.
id	string (arm-id)	Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	The geo-location where the resource lives
name	string	The name of the resource
properties	FleetManagedNamespaceProperties	The resource-specific properties for this resource.
systemData	systemData	Azure Resource Manager metadata containing createdBy and modifiedBy information.
tags	object	Resource tags.
type	string	The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

FleetManagedNamespaceProperties

Object

The properties of a fleet managed namespace.

Name	Type	Description
adoptionPolicy	AdoptionPolicy	Action if the managed namespace with the same name already exists. Default is Never.
deletePolicy	DeletePolicy	Delete options of a fleet managed namespace. Default is Keep.
managedNamespaceProperties	ManagedNamespaceProperties	The namespace properties for the fleet managed namespace.
portalFqdn	string	The Azure Portal FQDN of the Fleet hub.
propagationPolicy	PropagationPolicy	The profile of the propagation to create the namespace.
provisioningState	FleetManagedNamespaceProvisioningState	The status of the last operation.
status	FleetManagedNamespaceStatus	Status information of the last operation for fleet managed namespace.

FleetManagedNamespaceProvisioningState

Enumeration

The provisioning state of the fleet managed namespace resource

Value	Description
Succeeded	Resource has been created.
Failed	Resource creation failed.
Canceled	Resource creation was canceled.
Creating	The provisioning state of a fleet managed namespace being created.
Updating	The provisioning state of a fleet managed namespace being updated.
Deleting	The provisioning state of a fleet managed namespace being deleted.

FleetManagedNamespaceStatus

Object

Status information for the fleet managed namespace.

Name	Type	Description
lastOperationError	ErrorDetail	The last operation error of the fleet managed namespace
lastOperationId	string	The last operation ID for the fleet managed namespace

LabelSelectorOperator

Enumeration

operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.

Value	Description
In	Label Selector Operator In
NotIn	Label Selector Operator NotIn
Exists	Label Selector Operator Exists
DoesNotExist	Label Selector Operator DoesNotExist

ManagedNamespaceProperties

Object

The namespace properties for the fleet managed namespace.

Name	Type	Description
annotations	object	The annotations for the fleet managed namespace.
defaultNetworkPolicy	NetworkPolicy	The default network policy for the fleet managed namespace.
defaultResourceQuota	ResourceQuota	The default resource quota for the fleet managed namespace.
labels	object	The labels for the fleet managed namespace.

Meta.V1.LabelSelector

Object

A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all objects. A null label selector matches no objects.

Name	Type	Description
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions is a list of label selector requirements. The requirements are ANDed.
matchLabels	object	matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is "key", the operator is "In", and the values array contains only "value". The requirements are ANDed.

Meta.V1.LabelSelectorRequirement

Object

A label selector requirement is a selector that contains values, a key, and an operator that relates the key and values.

Name	Type	Description
key	string	key is the label key that the selector applies to.
operator	LabelSelectorOperator	operator represents a key's relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist.
values	string[]	values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch.

NetworkPolicy

Object

The network policy for the managed namespace.

Name	Type	Description
egress	PolicyRule	The egress policy for the managed namespace.
ingress	PolicyRule	The ingress policy for the managed namespace.

Placement.V1.Affinity

Object

Affinity is a group of cluster affinity scheduling rules. More to be added.

Name	Type	Description
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity contains cluster affinity scheduling rules for the selected resources.

Placement.V1.ClusterAffinity

Object

ClusterAffinity contains cluster affinity scheduling rules for the selected resources.

Name	Type	Description
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	If the affinity requirements specified by this field are not met at scheduling time, the resource will not be scheduled onto the cluster. If the affinity requirements specified by this field cease to be met at some point after the placement (e.g. due to an update), the system may or may not try to eventually remove the resource from the cluster.

Placement.V1.ClusterResourcePlacementSpec

Object

ClusterResourcePlacementSpec defines the desired state of ClusterResourcePlacement.

Name	Type	Description
policy	Placement.V1.PlacementPolicy	Policy defines how to select member clusters to place the selected resources. If unspecified, all the joined member clusters are selected.

Placement.V1.ClusterSelector

Object

ClusterSelector

Name	Type	Description
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms is a list of cluster selector terms. The terms are `ORed`.

Placement.V1.ClusterSelectorTerm

Object

ClusterSelectorTerm

Name	Type	Description
labelSelector	Meta.V1.LabelSelector	LabelSelector is a label query over all the joined member clusters. Clusters matching the query are selected. If you specify both label and property selectors in the same term, the results are AND'd.
propertySelector	Placement.V1.PropertySelector	PropertySelector is a property query over all joined member clusters. Clusters matching the query are selected. If you specify both label and property selectors in the same term, the results are AND'd. At this moment, PropertySelector can only be used with `RequiredDuringSchedulingIgnoredDuringExecution` affinity terms. This field is beta-level; it is for the property-based scheduling feature and is only functional when a property provider is enabled in the deployment.

Placement.V1.PlacementPolicy

Object

PlacementPolicy contains the rules to select target member clusters to place the selected resources. Note that only clusters that are both joined and satisfying the rules will be selected. You can only specify at most one of the two fields: ClusterNames and Affinity. If none is specified, all the joined clusters are selected.

Name	Type	Description
affinity	Placement.V1.Affinity	Affinity contains cluster affinity scheduling rules. Defines which member clusters to place the selected resources. Only valid if the placement type is "PickAll" or "PickN".
clusterNames	string[]	ClusterNames contains a list of names of MemberCluster to place the selected resources. Only valid if the placement type is "PickFixed"
placementType	PlacementType	Type of placement. Can be "PickAll", "PickN" or "PickFixed". Default is PickAll.
tolerations	Placement.V1.Toleration[]	If specified, the ClusterResourcePlacement's Tolerations. Tolerations cannot be updated or deleted. This field is beta-level and is for the taints and tolerations feature.

Placement.V1.PropertySelector

Object

PropertySelector helps user specify property requirements when picking clusters for resource placement.

Name	Type	Description
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions is an array of PropertySelectorRequirements. The requirements are AND'd.

Placement.V1.PropertySelectorRequirement

Object

PropertySelectorRequirement is a specific property requirement when picking clusters for resource placement.

Name	Type	Description
name	string	Name is the name of the property; it should be a Kubernetes label name.
operator	PropertySelectorOperator	Operator specifies the relationship between a cluster's observed value of the specified property and the values given in the requirement.
values	string[]	Values are a list of values of the specified property which Fleet will compare against the observed values of individual member clusters in accordance with the given operator. At this moment, each value should be a Kubernetes quantity. For more information, see https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. If the operator is Gt (greater than), Ge (greater than or equal to), Lt (less than), or `Le` (less than or equal to), Eq (equal to), or Ne (ne), exactly one value must be specified in the list.

Placement.V1.Toleration

Object

Toleration allows ClusterResourcePlacement to tolerate any taint that matches the triple <key,value,effect> using the matching operator <operator>.

Name	Type	Description
effect	TaintEffect	Effect indicates the taint effect to match. Empty means match all taint effects. When specified, only allowed value is NoSchedule.
key	string	Key is the taint key that the toleration applies to. Empty means match all taint keys. If the key is empty, operator must be Exists; this combination means to match all values and all keys.
operator	TolerationOperator	Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ClusterResourcePlacement can tolerate all taints of a particular category.
value	string	Value is the taint value the toleration matches to. If the operator is Exists, the value should be empty, otherwise just a regular string.

PlacementProfile

Object

The configuration profile for default ClusterResourcePlacement for placement.

Name	Type	Description
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	The default ClusterResourcePlacement policy configuration.

PlacementType

Enumeration

Type of placement. Can be "PickAll", "PickN" or "PickFixed". Default is PickAll.

Value	Description
PickAll	PickAll picks all clusters that satisfy the rules.
PickFixed	PickFixed picks a fixed set of clusters.

PolicyRule

Enumeration

The possible values representing different network policy rules.

Value	Description
AllowAll	Allow all network traffic.
DenyAll	Deny all network traffic.
AllowSameNamespace	Allow traffic within the same namespace.

PropagationPolicy

Object

The propagation to be used for provisioning the namespace among the fleet.

Name	Type	Description
placementProfile	PlacementProfile	The profile to be used for propagation via placement.
type	PropagationType	The type of the policy to be used. Default is Placement.

PropagationType

Enumeration

How the namespace will be provisioned among the fleet members.

Value	Description
Placement	Using ClusterResourcePlacement.

PropertySelectorOperator

Enumeration

Operator specifies the relationship between a cluster's observed value of the specified property and the values given in the requirement.

Value	Description
Gt	Gt dictates Fleet to select cluster if its observed value of a given property is greater than the value specified in the requirement.
Ge	Ge dictates Fleet to select cluster if its observed value of a given property is greater than or equal to the value specified in the requirement.
Eq	Eq dictates Fleet to select cluster if its observed value of a given property is equal to the values specified in the requirement.
Ne	Ne dictates Fleet to select cluster if its observed value of a given property is not equal to the values specified in the requirement.
Lt	Lt dictates Fleet to select cluster if its observed value of a given property is less than the value specified in the requirement.
Le	Le dictates Fleet to select cluster if its observed value of a given property is less than or equal to the value specified in the requirement.

ResourceQuota

Object

The resource quota for the managed namespace.

Name	Type	Description
cpuLimit	string	The CPU limit for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	The CPU request for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	The memory limit for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	The memory request for the managed namespace. See more at https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Object

Metadata pertaining to creation and last modification of the resource.

Name	Type	Description
createdAt	string (date-time)	The timestamp of resource creation (UTC).
createdBy	string	The identity that created the resource.
createdByType	createdByType	The type of identity that created the resource.
lastModifiedAt	string (date-time)	The timestamp of resource last modification (UTC)
lastModifiedBy	string	The identity that last modified the resource.
lastModifiedByType	createdByType	The type of identity that last modified the resource.

TaintEffect

Enumeration

Effect indicates the taint effect to match. Empty means match all taint effects. When specified, only allowed value is NoSchedule.

Value	Description
NoSchedule	Do not allow new pods to schedule onto the node unless they tolerate the taint, but allow all pods submitted to Kubelet without going through the scheduler to start, and allow all already-running pods to continue running. Enforced by the scheduler.

TolerationOperator

Enumeration

Operator represents a key's relationship to the value. Valid operators are Exists and Equal. Defaults to Equal. Exists is equivalent to wildcard for value, so that a ClusterResourcePlacement can tolerate all taints of a particular category.

Value	Description
Exists	Toleration Operator Exists
Equal	Toleration Operator Equal

Share via

Fleet Managed Namespaces - Create Or Update

URI Parameters

Request Header

Request Body

Responses

Security

azure_auth

Scopes

Examples

FleetManagedNamespaces_CreateOrUpdate

Sample request

Sample response

Definitions

AdoptionPolicy

createdByType

DeletePolicy

ErrorAdditionalInfo

ErrorDetail

ErrorResponse

FleetManagedNamespace

FleetManagedNamespaceProperties

FleetManagedNamespaceProvisioningState

FleetManagedNamespaceStatus

LabelSelectorOperator

ManagedNamespaceProperties

Meta.V1.LabelSelector

Meta.V1.LabelSelectorRequirement

NetworkPolicy

Placement.V1.Affinity

Placement.V1.ClusterAffinity

Placement.V1.ClusterResourcePlacementSpec

Placement.V1.ClusterSelector

Placement.V1.ClusterSelectorTerm

Placement.V1.PlacementPolicy

Placement.V1.PropertySelector

Placement.V1.PropertySelectorRequirement

Placement.V1.Toleration

PlacementProfile

PlacementType

PolicyRule

PropagationPolicy

PropagationType

PropertySelectorOperator

ResourceQuota

systemData

TaintEffect

TolerationOperator