Fleet Managed Namespaces - Create Or Update

Service:: Fleet

Version d'API:: 2026-02-01-preview

Créer un espace de noms FleetManagedNamespace

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

Paramètres URI

Nom	Dans	Obligatoire	Type	Description
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Nom de la ressource Fleet.
managedNamespaceName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Le nom de la ressource d’espace de noms gérée par la flotte.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Nom du groupe de ressources. Le nom ne respecte pas la casse.
subscriptionId	path	True	string (uuid)	ID de l’abonnement cible. La valeur doit être un UUID.
api-version	query	True	string minLength: 1	Version de l’API à utiliser pour cette opération.

En-tête de la demande

Nom	Obligatoire	Type	Description
If-Match		string	La requête ne doit continuer que si une entité correspond à cette chaîne.
If-None-Match		string	La requête ne doit continuer que si aucune entité ne correspond à cette chaîne.

Corps de la demande

Nom	Obligatoire	Type	Description
location	True	string	Emplacement géographique où réside la ressource
properties		FleetManagedNamespaceProperties	Propriétés spécifiques à la ressource pour cette ressource.
tags		object	Balises de ressource.

Réponses

Nom	Type	Description
200 OK	FleetManagedNamespace	Opération de mise à jour de la ressource 'FleetManagedNamespace' réussie
201 Created	FleetManagedNamespace	Ressource « FleetManagedNamespace » créer une opération réussie En-têtes Azure-AsyncOperation: string Retry-After: integer
Other Status Codes	ErrorResponse	Réponse d’erreur inattendue.

Nom

Type

Description

200 OK

FleetManagedNamespace

Opération de mise à jour de la ressource 'FleetManagedNamespace' réussie

201 Created

FleetManagedNamespace

Ressource « FleetManagedNamespace » créer une opération réussie

En-têtes

Azure-AsyncOperation: string
Retry-After: integer

Other Status Codes

ErrorResponse

Réponse d’erreur inattendue.

Sécurité

azure_auth

Azure Active Directory OAuth2 Flow.

Type: oauth2
Flux: implicit
URL d’autorisation: https://login.microsoftonline.com/common/oauth2/authorize

Étendues

Nom	Description
user_impersonation	emprunter l’identité de votre compte d’utilisateur

Exemples

FleetManagedNamespaces_CreateOrUpdate

Exemple de requête

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

Exemple de réponse

Code d’état:: 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"
  }
}

Code d’état:: 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"
  }
}

Définitions

Nom	Description
AdoptionPolicy	Action si l’espace de noms portant le même nom existe déjà.
createdByType	Type d’identité qui a créé la ressource.
DeletePolicy	Supprimer les options pour l’espace de noms géré ARM.
ErrorAdditionalInfo	Informations supplémentaires sur l’erreur de gestion des ressources.
ErrorDetail	Détail de l’erreur.
ErrorResponse	Réponse d’erreur
FleetManagedNamespace	Un espace de noms géré par la flotte.
FleetManagedNamespaceProperties	Les propriétés d’un espace de noms géré par flotte.
FleetManagedNamespaceProvisioningState	L’état de provisionnement de la ressource d’espace de noms géré par flotte
FleetManagedNamespaceStatus	Informations de statut pour l’espace de noms géré par la flotte.
LabelSelectorOperator	l’opérateur représente la relation d’une clé à un ensemble de valeurs. Les opérateurs valides sont In, NotIn, Exists et DoesNotExist.
ManagedNamespaceProperties	Les propriétés d’espace de noms pour l’espace de noms géré par la flotte.
Meta.V1.LabelSelector	Un sélecteur d’étiquettes est une requête d’étiquette sur un ensemble de ressources. Le résultat de matchLabels et de matchExpressions est ANDed. Un sélecteur d’étiquette vide correspond à tous les objets. Un sélecteur d’étiquette null ne correspond à aucun objet.
Meta.V1.LabelSelectorRequirement	Une exigence de sélecteur d’étiquette est un sélecteur qui contient des valeurs, une clé et un opérateur qui associe la clé et les valeurs.
NetworkPolicy	La politique réseau pour l’espace de noms géré.
Placement.V1.Affinity	L’affinité est un ensemble de règles d’ordonnancement d’affinité de cluster. D’autres choses à ajouter.
Placement.V1.ClusterAffinity	ClusterAffinity contient les règles d’ordonnancement d’affinité de cluster pour les ressources sélectionnées.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec définit l’état souhaité de ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy contient les règles permettant de sélectionner les clusters de membres cibles afin de placer les ressources sélectionnées. Notez que seuls les clusters à la fois joints et satisfaisant les règles seront sélectionnés. Vous ne pouvez spécifier au maximum qu’un des deux champs : NomsClusters et Affinité. Si aucun n’est spécifié, tous les clusters joints sont sélectionnés.
Placement.V1.PropertySelector	PropertySelector aide l’utilisateur à spécifier les exigences de propriété lors du choix des clusters pour le placement des ressources.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement est une exigence spécifique de propriété lors du choix de clusters pour le placement des ressources.
Placement.V1.Toleration	La tolérance permet à ClusterResourcePlacement de tolérer toute contamination correspondant à la triple <key,value,effect> en utilisant l’opérateur <>d’opérateur de correspondance.
PlacementProfile	Le profil de configuration pour le ClusterResourcePlacement par défaut pour le placement.
PlacementType	Type de placement. Cela peut être « PickAll », « PickN » ou « PickFixed ». Par défaut, c’est PickAll.
PolicyRule	Les valeurs possibles représentant différentes règles de politique réseau.
PropagationPolicy	La propagation sera utilisée pour approvisionner l’espace de noms au sein de la flotte.
PropagationType	Comment l’espace de noms sera provisionné parmi les membres de la flotte.
PropertySelectorOperator	L’opérateur spécifie la relation entre la valeur observée de la propriété spécifiée par un cluster et les valeurs données dans l’exigence.
ResourceQuota	Le quota de ressources pour l’espace de noms géré.
systemData	Métadonnées relatives à la création et à la dernière modification de la ressource.
TaintEffect	Effet indique l’effet de souillure à correspondre. Vide signifie que tous les effets de souillure correspondent. Lorsqu’elle est spécifiée, la seule valeur autorisée est NoSchedule.
TolerationOperator	L’opérateur représente la relation d’une clé à la valeur. Les opérateurs valides sont Exists et Equal. Par défaut, Égal. Exists est équivalent à joker pour la valeur, de sorte qu’un ClusterResourcePlacement peut tolérer toutes les impuretés d’une catégorie particulière.

AdoptionPolicy

Énumération

Action si l’espace de noms portant le même nom existe déjà.

Valeur	Description
Never	Si l’espace de noms existe déjà, ne prenez pas le contrôle de l’espace de noms existant à gérer par ARM.
IfIdentical	S’il existe un espace de noms identique, prenez en charge l’espace de noms existant à gérer par ARM.
Always	Prenez toujours le contrôle de l’espace de noms existant à gérer par ARM, même s’il n’est pas identique.

createdByType

Énumération

Type d’identité qui a créé la ressource.

Valeur	Description
User
Application
ManagedIdentity
Key

DeletePolicy

Énumération

Supprimer les options pour l’espace de noms géré ARM.

Valeur	Description
Keep	Supprimez la ressource ARM mais gardez l’espace de noms.
Delete	Supprimez à la fois la ressource ARM et l’espace de noms.

ErrorAdditionalInfo

Objet

Informations supplémentaires sur l’erreur de gestion des ressources.

Nom	Type	Description
info	object	Informations supplémentaires.
type	string	Type d’informations supplémentaire.

ErrorDetail

Objet

Détail de l’erreur.

Nom	Type	Description
additionalInfo	ErrorAdditionalInfo[]	Informations supplémentaires sur l’erreur.
code	string	Code d’erreur.
details	ErrorDetail[]	Détails de l’erreur.
message	string	Message d’erreur.
target	string	Cible d’erreur.

ErrorResponse

Objet

Réponse d’erreur

Nom	Type	Description
error	ErrorDetail	Objet d’erreur.

FleetManagedNamespace

Objet

Un espace de noms géré par la flotte.

Nom	Type	Description
eTag	string	Si eTag est fourni dans le corps de la réponse, il peut également être fourni en tant qu’en-tête conformément à la convention etag normale. Les balises d’entité sont utilisées pour comparer deux entités ou plus à partir de la même ressource demandée. HTTP/1.1 utilise des balises d’entité dans l’etag (section 14.19), If-Match (section 14.24), If-None-Match (section 14.26) et If-Range (section 14.27).
id	string (arm-id)	ID de ressource complet pour la ressource. Par exemple, « /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName} »
location	string	Emplacement géographique où réside la ressource
name	string	Nom de la ressource
properties	FleetManagedNamespaceProperties	Propriétés spécifiques à la ressource pour cette ressource.
systemData	systemData	Métadonnées Azure Resource Manager contenant les informations createdBy et modifiedBy.
tags	object	Balises de ressource.
type	string	Type de la ressource. Par exemple, « Microsoft.Compute/virtualMachines » ou « Microsoft.Storage/storageAccounts »

FleetManagedNamespaceProperties

Objet

Les propriétés d’un espace de noms géré par flotte.

Nom	Type	Description
adoptionPolicy	AdoptionPolicy	Action si l’espace de noms géré avec le même nom existe déjà. Par défaut, c’est Jamais.
deletePolicy	DeletePolicy	Supprimez les options d’un espace de noms géré par flotte. Par défaut, c’est Conserver.
managedNamespaceProperties	ManagedNamespaceProperties	Les propriétés d’espace de noms pour l’espace de noms géré par la flotte.
portalFqdn	string	Nom de domaine complet du portail Azure du hub Fleet.
propagationPolicy	PropagationPolicy	Le profil de la propagation pour créer l’espace de noms.
provisioningState	FleetManagedNamespaceProvisioningState	État de la dernière opération.
status	FleetManagedNamespaceStatus	Informations de statut de la dernière opération pour l’espace de noms géré par flotte.

FleetManagedNamespaceProvisioningState

Énumération

L’état de provisionnement de la ressource d’espace de noms géré par flotte

Valeur	Description
Succeeded	La ressource a été créée.
Failed	Échec de la création de ressources.
Canceled	La création de ressources a été annulée.
Creating	L’état de provisionnement d’un espace de noms géré par flotte en cours de création.
Updating	L’état de provisionnement d’un espace de noms géré par flotte en cours de mise à jour.
Deleting	L’état de provisionnement d’un espace de noms géré par flotte en train d’être supprimé.

FleetManagedNamespaceStatus

Objet

Informations de statut pour l’espace de noms géré par la flotte.

Nom	Type	Description
lastOperationError	ErrorDetail	La dernière erreur opérationnelle de l’espace de noms géré par flotte
lastOperationId	string	Le dernier identifiant d’opération pour l’espace de noms géré par la flotte

LabelSelectorOperator

Énumération

l’opérateur représente la relation d’une clé à un ensemble de valeurs. Les opérateurs valides sont In, NotIn, Exists et DoesNotExist.

Valeur	Description
In	Opérateur de sélection d’étiquettes en
NotIn	Opérateur de sélection d’étiquettes NotIn
Exists	Opérateur de sélection d’étiquettes existe
DoesNotExist	Opérateur de sélection d’étiquettes ExistePas

ManagedNamespaceProperties

Objet

Les propriétés d’espace de noms pour l’espace de noms géré par la flotte.

Nom	Type	Description
annotations	object	Les annotations pour l’espace de noms géré par la flotte.
defaultNetworkPolicy	NetworkPolicy	La politique réseau par défaut pour l’espace de noms géré par flotte.
defaultResourceQuota	ResourceQuota	Le quota de ressources par défaut pour l’espace de noms géré par flotte.
labels	object	Les étiquettes pour l’espace de noms géré par la flotte.

Meta.V1.LabelSelector

Objet

Un sélecteur d’étiquettes est une requête d’étiquette sur un ensemble de ressources. Le résultat de matchLabels et de matchExpressions est ANDed. Un sélecteur d’étiquette vide correspond à tous les objets. Un sélecteur d’étiquette null ne correspond à aucun objet.

Nom	Type	Description
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions est une liste des exigences de sélecteur d’étiquettes. Les exigences sont AND.
matchLabels	object	matchLabels est une application de paires {key,value}. Une seule {clé,value} dans le mappage matchLabels équivaut à un élément de matchExpressions, dont le champ de clé est « key », l’opérateur est « In », et le tableau de valeurs contient uniquement « value ». Les exigences sont AND.

Meta.V1.LabelSelectorRequirement

Objet

Une exigence de sélecteur d’étiquette est un sélecteur qui contient des valeurs, une clé et un opérateur qui associe la clé et les valeurs.

Nom	Type	Description
key	string	clé est la clé d’étiquette à laquelle le sélecteur s’applique.
operator	LabelSelectorOperator	l’opérateur représente la relation d’une clé à un ensemble de valeurs. Les opérateurs valides sont In, NotIn, Exists et DoesNotExist.
values	string[]	les valeurs sont un tableau de valeurs de chaîne. Si l’opérateur est In ou NotIn, le tableau de valeurs doit être non vide. Si l’opérateur existe ou DoesNotExist, le tableau de valeurs doit être vide. Ce tableau est remplacé lors d’un correctif de fusion stratégique.

NetworkPolicy

Objet

La politique réseau pour l’espace de noms géré.

Nom	Type	Description
egress	PolicyRule	La politique d’évacuation pour l’espace de noms géré.
ingress	PolicyRule	La politique d’entrée pour l’espace de noms géré.

Placement.V1.Affinity

Objet

L’affinité est un ensemble de règles d’ordonnancement d’affinité de cluster. D’autres choses à ajouter.

Nom	Type	Description
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity contient les règles d’ordonnancement d’affinité de cluster pour les ressources sélectionnées.

Placement.V1.ClusterAffinity

Objet

ClusterAffinity contient les règles d’ordonnancement d’affinité de cluster pour les ressources sélectionnées.

Nom	Type	Description
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Si les exigences d’affinité spécifiées par ce champ ne sont pas remplies au moment de la planification, la ressource ne sera pas programmée sur le cluster. Si les exigences d’affinité spécifiées par ce champ cessent d’être remplies à un moment donné après le placement (par exemple en raison d’une mise à jour), le système peut ou non tenter de retirer la ressource du cluster.

Placement.V1.ClusterResourcePlacementSpec

Objet

ClusterResourcePlacementSpec définit l’état souhaité de ClusterResourcePlacement.

Nom	Type	Description
policy	Placement.V1.PlacementPolicy	La politique définit comment sélectionner les clusters de membres pour placer les ressources sélectionnées. Si non spécifié, tous les groupes de membres joints sont sélectionnés.

Placement.V1.ClusterSelector

Objet

ClusterSelector

Nom	Type	Description
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms est une liste de termes de sélection de groupes. Les termes sont `ORed`.

Placement.V1.ClusterSelectorTerm

Objet

ClusterSelectorTerm

Nom	Type	Description
labelSelector	Meta.V1.LabelSelector	LabelSelector est une requête d’étiquettes sur tous les clusters de membres joints. Les clusters correspondant à la requête sont sélectionnés. Si vous spécifiez à la fois les sélecteurs d’étiquettes et de propriétés dans le même terme, les résultats sont ET.
propertySelector	Placement.V1.PropertySelector	PropertySelector est une requête de propriété couvrant tous les clusters membres joints. Les clusters correspondant à la requête sont sélectionnés. Si vous spécifiez à la fois les sélecteurs d’étiquettes et de propriétés dans le même terme, les résultats sont ET. À ce stade, PropertySelector ne peut être utilisé qu’avec `RequiredDuringSchedulingIgnoredDuringExecution` des termes d’affinité. Ce domaine est de niveau bêta ; Il est destiné à la fonctionnalité de planification basée sur la propriété et n’est fonctionnel que lorsqu’un fournisseur immobilier est activé dans le déploiement.

Placement.V1.PlacementPolicy

Objet

PlacementPolicy contient les règles permettant de sélectionner les clusters de membres cibles afin de placer les ressources sélectionnées. Notez que seuls les clusters à la fois joints et satisfaisant les règles seront sélectionnés. Vous ne pouvez spécifier au maximum qu’un des deux champs : NomsClusters et Affinité. Si aucun n’est spécifié, tous les clusters joints sont sélectionnés.

Nom	Type	Description
affinity	Placement.V1.Affinity	Affinity contient des règles d’ordonnancement d’affinité de cluster. Définit quels clusters membres placer les ressources sélectionnées. Valable uniquement si le type de placement est « PickAll » ou « PickN ».
clusterNames	string[]	ClusterNames contient une liste de noms de MemberCluster pour placer les ressources sélectionnées. Valable seulement si le type de placement est « PickFixed »
placementType	PlacementType	Type de placement. Cela peut être « PickAll », « PickN » ou « PickFixed ». Par défaut, c’est PickAll.
tolerations	Placement.V1.Toleration[]	Si spécifié, les tolérances de ClusterResourcePlacement. Les tolérances ne peuvent pas être mises à jour ni supprimées. Ce champ est de niveau bêta et concerne la caractéristique des contaminations et tolérances.

Placement.V1.PropertySelector

Objet

PropertySelector aide l’utilisateur à spécifier les exigences de propriété lors du choix des clusters pour le placement des ressources.

Nom	Type	Description
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions est un ensemble de PropertySelectorRequirements. Les exigences sont ET précisées.

Placement.V1.PropertySelectorRequirement

Objet

PropertySelectorRequirement est une exigence spécifique de propriété lors du choix de clusters pour le placement des ressources.

Nom	Type	Description
name	string	Le nom est le nom de la propriété ; ça devrait être un nom de label Kubernetes.
operator	PropertySelectorOperator	L’opérateur spécifie la relation entre la valeur observée de la propriété spécifiée par un cluster et les valeurs données dans l’exigence.
values	string[]	Les valeurs sont une liste de valeurs de la propriété spécifiée que Fleet comparera avec les valeurs observées des groupes membres individuels conformément à l’opérateur donné. À ce moment-là, chaque valeur devrait être une quantité Kubernetes. Pour plus d’informations, consultez https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Si l’opérateur est Gt (supérieur à), Ge (supérieur ou égal à), Lt (inférieur à cela), ou `Le` (inférieur ou égal à), Eq (égal à), ou Ne (ne), une valeur exacte doit être spécifiée dans la liste.

Placement.V1.Toleration

Objet

La tolérance permet à ClusterResourcePlacement de tolérer toute contamination correspondant à la triple <key,value,effect> en utilisant l’opérateur <>d’opérateur de correspondance.

Nom	Type	Description
effect	TaintEffect	Effet indique l’effet de souillure à correspondre. Vide signifie que tous les effets de souillure correspondent. Lorsqu’elle est spécifiée, la seule valeur autorisée est NoSchedule.
key	string	La clé est la clé de contamination à laquelle s’applique la tolérance. Vide signifie que toutes les clés de souillure correspondent. Si la clé est vide, l’opérateur doit être Existe ; Cette combinaison signifie correspondre toutes les valeurs et toutes les clés.
operator	TolerationOperator	L’opérateur représente la relation d’une clé à la valeur. Les opérateurs valides sont Exists et Equal. Par défaut, Égal. Exists est équivalent à joker pour la valeur, de sorte qu’un ClusterResourcePlacement peut tolérer toutes les impuretés d’une catégorie particulière.
value	string	La valeur est la valeur de la souillance à laquelle la tolérance correspond. Si l’opérateur est Exists, la valeur doit être vide, sinon simplement une chaîne régulière.

PlacementProfile

Objet

Le profil de configuration pour le ClusterResourcePlacement par défaut pour le placement.

Nom	Type	Description
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	La configuration par défaut de la politique ClusterResourcePlacement.

PlacementType

Énumération

Type de placement. Cela peut être « PickAll », « PickN » ou « PickFixed ». Par défaut, c’est PickAll.

Valeur	Description
PickAll	PickAll sélectionne tous les clusters qui respectent les règles.
PickFixed	PickFixed choisit un ensemble fixe de clusters.

PolicyRule

Énumération

Les valeurs possibles représentant différentes règles de politique réseau.

Valeur	Description
AllowAll	Autorisez tout le trafic réseau.
DenyAll	Refusez tout le trafic réseau.
AllowSameNamespace	Autorisez le trafic au sein du même espace de noms.

PropagationPolicy

Objet

La propagation sera utilisée pour approvisionner l’espace de noms au sein de la flotte.

Nom	Type	Description
placementProfile	PlacementProfile	Le profil à utiliser pour la propagation via le placement.
type	PropagationType	Le type de police à utiliser. Par défaut, c’est le placement.

PropagationType

Énumération

Comment l’espace de noms sera provisionné parmi les membres de la flotte.

Valeur	Description
Placement	Utilisation de ClusterResourcePlacement.

PropertySelectorOperator

Énumération

L’opérateur spécifie la relation entre la valeur observée de la propriété spécifiée par un cluster et les valeurs données dans l’exigence.

Valeur	Description
Gt	Gt dicte à la flotte de sélectionner un groupe si la valeur observée d’une propriété donnée est supérieure à la valeur spécifiée dans l’exigence.
Ge	Ge dicte à la flotte de sélectionner le cluster si la valeur observée d’une propriété donnée est supérieure ou égale à la valeur spécifiée dans l’exigence.
Eq	L’Équation dicte à la flotte de sélectionner le cluster si la valeur observée d’une propriété donnée est égale aux valeurs spécifiées dans l’exigence.
Ne	Ne dicte à la flotte de sélectionner un cluster si la valeur observée d’une propriété donnée n’est pas égale aux valeurs spécifiées dans l’exigence.
Lt	Lt dicte à la flotte de sélectionner un cluster si sa valeur observée d’une propriété donnée est inférieure à la valeur spécifiée dans l’exigence.
Le	Le dicte à Fleet de sélectionner un cluster si la valeur observée d’une propriété donnée est inférieure ou égale à la valeur spécifiée dans l’exigence.

ResourceQuota

Objet

Le quota de ressources pour l’espace de noms géré.

Nom	Type	Description
cpuLimit	string	La limite CPU pour l’espace de noms géré. Voir plus à l’adresse https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	La requête CPU pour l’espace de noms géré. Voir plus à l’adresse https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	La limite de mémoire pour l’espace de noms géré. Voir plus à l’adresse https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	La requête mémoire pour l’espace de noms géré. Voir plus à l’adresse https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Objet

Métadonnées relatives à la création et à la dernière modification de la ressource.

Nom	Type	Description
createdAt	string (date-time)	Horodatage de la création de ressources (UTC).
createdBy	string	Identité qui a créé la ressource.
createdByType	createdByType	Type d’identité qui a créé la ressource.
lastModifiedAt	string (date-time)	Horodatage de la dernière modification de ressource (UTC)
lastModifiedBy	string	Identité qui a modifié la ressource pour la dernière fois.
lastModifiedByType	createdByType	Type d’identité qui a modifié la ressource pour la dernière fois.

TaintEffect

Énumération

Effet indique l’effet de souillure à correspondre. Vide signifie que tous les effets de souillure correspondent. Lorsqu’elle est spécifiée, la seule valeur autorisée est NoSchedule.

Valeur	Description
NoSchedule	N’autorisez pas de nouveaux pods à être programmés sur le nœud à moins qu’ils ne tolèrent la contamination, mais laissez tous les pods soumis à Kubelet sans passer par le planificateur pour démarrer, et laissez tous les pods déjà en fonctionnement continuer à fonctionner. Imposé par le planificateur.

TolerationOperator

Énumération

L’opérateur représente la relation d’une clé à la valeur. Les opérateurs valides sont Exists et Equal. Par défaut, Égal. Exists est équivalent à joker pour la valeur, de sorte qu’un ClusterResourcePlacement peut tolérer toutes les impuretés d’une catégorie particulière.

Valeur	Description
Exists	Opérateur de tolérance existe
Equal	Opérateur de tolérance égal

Partager via

Fleet Managed Namespaces - Create Or Update

Paramètres URI

En-tête de la demande

Corps de la demande

Réponses

Sécurité

azure_auth

Étendues

Exemples

FleetManagedNamespaces_CreateOrUpdate

Exemple de requête

Exemple de réponse

Définitions

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