Fleet Managed Namespaces - List By Fleet

Servizio:

Fleet

Versione API:

2026-02-01-preview

Elenca le risorse di FleetManagedNamespace per Flotta

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

Parametri dell'URI

Nome	In	Necessario	Tipo	Descrizione
fleetName	path	True	string minLength: 1 maxLength: 63 pattern: ^[a-z0-9]([-a-z0-9]*[a-z0-9])?$	Nome della risorsa Fleet.
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Nome del gruppo di risorse. Il nome è insensibile alle maiuscole e minuscole.
subscriptionId	path	True	string (uuid)	ID della sottoscrizione di destinazione. Il valore deve essere un UUID.
api-version	query	True	string minLength: 1	Versione dell'API da usare per questa operazione.

Risposte

Nome	Tipo	Descrizione
200 OK	FleetManagedNamespaceListResult	Operazione Azure completata con successo.
Other Status Codes	ErrorResponse	Risposta di errore imprevista.

Sicurezza

azure_auth

Azure Active Directory OAuth2 Flow.

Tipo: oauth2
Flow: implicit
URL di autorizzazione: https://login.microsoftonline.com/common/oauth2/authorize

Ambiti

Nome	Descrizione
user_impersonation	rappresentare l'account utente

Esempio

FleetManagedNamespaces_ListByFleet

Esempio di richiesta

HTTP

GET https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rgfleets/providers/Microsoft.ContainerService/fleets/fleet1/managedNamespaces?api-version=2026-02-01-preview

Java

/**
 * Samples for FleetManagedNamespaces ListByFleet.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_ListByFleet.json
     */
    /**
     * Sample code: FleetManagedNamespaces_ListByFleet.
     * 
     * @param manager Entry point to ContainerServiceFleetManager.
     */
    public static void fleetManagedNamespacesListByFleet(
        com.azure.resourcemanager.containerservicefleet.ContainerServiceFleetManager manager) {
        manager.fleetManagedNamespaces().listByFleet("rgfleets", "fleet1", com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.containerservicefleet import ContainerServiceFleetMgmtClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-containerservicefleet
# USAGE
    python fleet_managed_namespaces_list_by_fleet.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.list_by_fleet(
        resource_group_name="rgfleets",
        fleet_name="fleet1",
    )
    for item in response:
        print(item)


# x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_ListByFleet.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armcontainerservicefleet_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservicefleet/armcontainerservicefleet/v3"
)

// Generated from example definition: 2026-02-01-preview/FleetManagedNamespaces_ListByFleet.json
func ExampleFleetManagedNamespacesClient_NewListByFleetPager() {
	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)
	}
	pager := clientFactory.NewFleetManagedNamespacesClient().NewListByFleetPager("rgfleets", "fleet1", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page = armcontainerservicefleet.FleetManagedNamespacesClientListByFleetResponse{
		// 	FleetManagedNamespaceListResult: armcontainerservicefleet.FleetManagedNamespaceListResult{
		// 		Value: []*armcontainerservicefleet.FleetManagedNamespace{
		// 			{
		// 				Properties: &armcontainerservicefleet.FleetManagedNamespaceProperties{
		// 					ProvisioningState: to.Ptr(armcontainerservicefleet.FleetManagedNamespaceProvisioningStateSucceeded),
		// 					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{
		// 						},
		// 					},
		// 					PortalFqdn: to.Ptr("fleet1-namespace1-abc123.flt.eastus.azmk8s.io"),
		// 				},
		// 				ETag: to.Ptr("\"EtagValue\""),
		// 				Tags: map[string]*string{
		// 					"tag1": to.Ptr("tagValue1"),
		// 				},
		// 				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}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://nextlink.sausage.com"),
		// 	},
		// }
	}
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { ContainerServiceFleetClient } = require("@azure/arm-containerservicefleet");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to list FleetManagedNamespace resources by Fleet
 *
 * @summary list FleetManagedNamespace resources by Fleet
 * x-ms-original-file: 2026-02-01-preview/FleetManagedNamespaces_ListByFleet.json
 */
async function fleetManagedNamespacesListByFleet() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new ContainerServiceFleetClient(credential, subscriptionId);
  const resArray = new Array();
  for await (const item of client.fleetManagedNamespaces.listByFleet("rgfleets", "fleet1")) {
    resArray.push(item);
  }

  console.log(resArray);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Risposta di esempio

Codice di stato:

200

{
  "value": [
    {
      "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": {}
        },
        "portalFqdn": "fleet1-namespace1-abc123.flt.eastus.azmk8s.io"
      },
      "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"
      }
    }
  ],
  "nextLink": "https://nextlink.sausage.com"
}

Definizioni

Nome	Descrizione
AdoptionPolicy	Azione se lo spazio dei nomi con lo stesso nome esiste già.
createdByType	Tipo di identità che ha creato la risorsa.
DeletePolicy	Elimina le opzioni per il namespace gestito ARM.
ErrorAdditionalInfo	Informazioni aggiuntive sull'errore di gestione delle risorse.
ErrorDetail	Dettagli dell'errore.
ErrorResponse	Risposta di errore
FleetManagedNamespace	Uno spazio di nomi gestito dalla flotta.
FleetManagedNamespaceListResult	La risposta di un'operazione con liste FleetManagedNamespace.
FleetManagedNamespaceProperties	Le proprietà di uno spazio di nomi gestiti dalla flotta.
FleetManagedNamespaceProvisioningState	Lo stato di approvvigionamento della risorsa namespace gestita dalla flotta
FleetManagedNamespaceStatus	Informazioni di stato per lo spazio di nomi gestito dalla flotta.
LabelSelectorOperator	operator rappresenta la relazione di una chiave con un set di valori. Gli operatori validi sono In, NotIn, Exists e DoesNotExist.
ManagedNamespaceProperties	Le proprietà dello spazio di nomi per lo spazio gestito dalla flotta.
Meta.V1.LabelSelector	Un selettore di etichette è una query di etichetta su un set di risorse. Il risultato di matchLabels e matchExpressions è ANDed. Un selettore di etichette vuoto corrisponde a tutti gli oggetti. Un selettore di etichette Null non corrisponde a alcun oggetto.
Meta.V1.LabelSelectorRequirement	Un requisito del selettore di etichette è un selettore che contiene valori, una chiave e un operatore che correla la chiave e i valori.
NetworkPolicy	La policy di rete per il namespace gestito.
Placement.V1.Affinity	L'affinità è un gruppo di regole di schedulazione per affinità di cluster. Aggiungeremo altro.
Placement.V1.ClusterAffinity	ClusterAffinity contiene regole di schedulazione di affinità di cluster per le risorse selezionate.
Placement.V1.ClusterResourcePlacementSpec	ClusterResourcePlacementSpec definisce lo stato desiderato di ClusterResourcePlacement.
Placement.V1.ClusterSelector	ClusterSelector
Placement.V1.ClusterSelectorTerm	ClusterSelectorTerm
Placement.V1.PlacementPolicy	PlacementPolicy contiene le regole per selezionare i cluster di membri target per posizionare le risorse selezionate. Si noti che verranno selezionati solo cluster che sono sia uniti che soddisfano le regole. Puoi specificare al massimo uno dei due campi: ClusterName e Affinity. Se nessuno viene specificato, tutti i cluster uniti vengono selezionati.
Placement.V1.PropertySelector	PropertySelector aiuta l'utente a specificare i requisiti di proprietà nella scelta dei cluster per il posizionamento delle risorse.
Placement.V1.PropertySelectorRequirement	PropertySelectorRequirement è un requisito specifico di proprietà quando si selezionano cluster per il posizionamento delle risorse.
Placement.V1.Toleration	La tolleranza permette a ClusterResourcePlacement di tollerare qualsiasi contaminazione che corrisponda al triplo <key,value,effect> usando l'operatore <>di abbinamento.
PlacementProfile	Il profilo di configurazione per il ClusterResourcePlacement predefinito per il posizionamento.
PlacementType	Tipo di collocamento. Può essere "PickAll", "PickN" o "PickFixed". Il predefinito è PickAll.
PolicyRule	I valori possibili rappresentano diverse regole di policy di rete.
PropagationPolicy	La propagazione da utilizzare per rifornire lo spazio di nomi all'interno della flotta.
PropagationType	Come verrà fornito il namespace tra i membri della flotta.
PropertySelectorOperator	L'operatore specifica la relazione tra il valore osservato di un cluster della proprietà specificata e i valori indicati nel requisito.
ResourceQuota	La quota di risorse per il namespace gestito.
systemData	Metadati relativi alla creazione e all'ultima modifica della risorsa.
TaintEffect	L'effetto indica l'effetto della contaminazione da corrispondere. Vuoto significa che corrispondono a tutti gli effetti di contaminazione. Quando specificato, l'unico valore consentito è NoSchedule.
TolerationOperator	L'operatore rappresenta la relazione di una chiave con il valore. Gli operatori validi sono Esistenti e Uguali. Di default è uguale. Exists è equivalente a wildcard per valore, così che un ClusterResourcePlacement può tollerare tutte le contaminazioni di una particolare categoria.

AdoptionPolicy

Enumerazione

Azione se lo spazio dei nomi con lo stesso nome esiste già.

Valore	Descrizione
Never	Se lo spazio dei nomi esiste già, non prendere il controllo dello spazio dei nomi esistente da gestire da ARM.
IfIdentical	Se esiste un Namespace identico, si assume il controllo dello Namespace esistente da gestire da ARM.
Always	Prendi sempre il controllo dello spazio di nomi esistente da gestire da ARM, anche se non è identico.

createdByType

Enumerazione

Tipo di identità che ha creato la risorsa.

Valore	Descrizione
User
Application
ManagedIdentity
Key

DeletePolicy

Enumerazione

Elimina le opzioni per il namespace gestito ARM.

Valore	Descrizione
Keep	Elimina la risorsa ARM ma mantieni lo spazio dei nomi.
Delete	Elimina sia la risorsa ARM che il namespace.

ErrorAdditionalInfo

Oggetto

Informazioni aggiuntive sull'errore di gestione delle risorse.

Nome	Tipo	Descrizione
info	object	Informazioni aggiuntive.
type	string	Tipo di informazioni aggiuntive.

ErrorDetail

Oggetto

Dettagli dell'errore.

Nome	Tipo	Descrizione
additionalInfo	ErrorAdditionalInfo[]	Informazioni aggiuntive sull'errore.
code	string	Codice di errore.
details	ErrorDetail[]	Dettagli dell'errore.
message	string	Messaggio di errore.
target	string	Destinazione dell'errore.

ErrorResponse

Oggetto

Risposta di errore

Nome	Tipo	Descrizione
error	ErrorDetail	Oggetto error.

FleetManagedNamespace

Oggetto

Uno spazio di nomi gestito dalla flotta.

Nome	Tipo	Descrizione
eTag	string	Se eTag viene fornito nel corpo della risposta, può anche essere fornito come intestazione in base alla normale convenzione etag. I tag di entità vengono usati per confrontare due o più entità dalla stessa risorsa richiesta. HTTP/1.1 usa i tag di entità nei campi di intestazione (sezione 14.19), If-Match (sezione 14.24), If-None-Match (sezione 14.26) e If-Range (sezione 14.27).
id	string (arm-id)	ID risorsa completo per la risorsa. Ad esempio, "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
location	string	Posizione geografica in cui risiede la risorsa
name	string	Nome della risorsa
properties	FleetManagedNamespaceProperties	Proprietà specifiche della risorsa.
systemData	systemData	Azure Resource Manager metadati contenenti informazioni createBy e modifiedBy.
tags	object	Tag di risorsa.
type	string	Tipo di risorsa. Ad esempio, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"

FleetManagedNamespaceListResult

Oggetto

La risposta di un'operazione con liste FleetManagedNamespace.

Nome	Tipo	Descrizione
nextLink	string (uri)	Collegamento alla pagina successiva di elementi
value	FleetManagedNamespace[]	Gli elementi FleetManagedNamespace presenti in questa pagina

FleetManagedNamespaceProperties

Oggetto

Le proprietà di uno spazio di nomi gestiti dalla flotta.

Nome	Tipo	Descrizione
adoptionPolicy	AdoptionPolicy	Azione se lo spazio di nomi gestito con lo stesso nome esiste già. Il default è Mai.
deletePolicy	DeletePolicy	Elimina le opzioni di uno spazio di nomi gestito dalla flotta. Il predefinito è Keep.
managedNamespaceProperties	ManagedNamespaceProperties	Le proprietà dello spazio di nomi per lo spazio gestito dalla flotta.
portalFqdn	string	FQDN del portale di Azure dell'hub Fleet.
propagationPolicy	PropagationPolicy	Il profilo della propagazione per creare il namespace.
provisioningState	FleetManagedNamespaceProvisioningState	Stato dell'ultima operazione.
status	FleetManagedNamespaceStatus	Informazioni sullo stato dell'ultima operazione per il namespace gestito della flotta.

FleetManagedNamespaceProvisioningState

Enumerazione

Lo stato di approvvigionamento della risorsa namespace gestita dalla flotta

Valore	Descrizione
Succeeded	La risorsa è stata creata.
Failed	Creazione della risorsa non riuscita.
Canceled	La creazione delle risorse è stata annullata.
Creating	Lo stato di approvvigionamento di uno spazio di nome gestito dalla flotta in fase di creazione.
Updating	Lo stato di provisioning di uno spazio di nomi gestito dalla flotta in fase di aggiornamento.
Deleting	Lo stato di provisioning di uno spazio di nomi gestito dalla flotta viene eliminato.

FleetManagedNamespaceStatus

Oggetto

Informazioni di stato per lo spazio di nomi gestito dalla flotta.

Nome	Tipo	Descrizione
lastOperationError	ErrorDetail	L'ultimo errore operativo dello spazio di nomi gestito dalla flotta
lastOperationId	string	L'ultimo ID operazione per il namespace gestito della flotta

LabelSelectorOperator

Enumerazione

operator rappresenta la relazione di una chiave con un set di valori. Gli operatori validi sono In, NotIn, Exists e DoesNotExist.

Valore	Descrizione
In	Operatore selettore di etichette in
NotIn	Operatore Selettore di Etichette NotIn
Exists	Esiste l'operatore del selettore di etichette
DoesNotExist	L'operatore selettore di etichette NonEsisteEsiste

ManagedNamespaceProperties

Oggetto

Le proprietà dello spazio di nomi per lo spazio gestito dalla flotta.

Nome	Tipo	Descrizione
annotations	object	Le annotazioni per lo spazio di nomi gestito dalla flotta.
defaultNetworkPolicy	NetworkPolicy	La politica di rete predefinita per il namespace gestito dalla flotta.
defaultResourceQuota	ResourceQuota	La quota di risorse predefinita per il namespace gestito dalla flotta.
labels	object	Le etichette per il namespace gestito dalla flotta.

Meta.V1.LabelSelector

Oggetto

Un selettore di etichette è una query di etichetta su un set di risorse. Il risultato di matchLabels e matchExpressions è ANDed. Un selettore di etichette vuoto corrisponde a tutti gli oggetti. Un selettore di etichette Null non corrisponde a alcun oggetto.

Nome	Tipo	Descrizione
matchExpressions	Meta.V1.LabelSelectorRequirement[]	matchExpressions è un elenco di requisiti del selettore di etichette. I requisiti sono ANDed.
matchLabels	object	matchLabels è una mappa di coppie {chiave,valore}. Una singola {chiave,value} nella mappa matchLabels equivale a un elemento di matchExpressions, il cui campo chiave è "key", l'operatore è "In" e la matrice di valori contiene solo "value". I requisiti sono ANDed.

Meta.V1.LabelSelectorRequirement

Oggetto

Un requisito del selettore di etichette è un selettore che contiene valori, una chiave e un operatore che correla la chiave e i valori.

Nome	Tipo	Descrizione
key	string	key è la chiave dell'etichetta a cui si applica il selettore.
operator	LabelSelectorOperator	operator rappresenta la relazione di una chiave con un set di valori. Gli operatori validi sono In, NotIn, Exists e DoesNotExist.
values	string[]	values è una matrice di valori stringa. Se l'operatore è In o NotIn, la matrice di valori deve essere non vuota. Se l'operatore è Exists o DoesNotExist, la matrice di valori deve essere vuota. Questa matrice viene sostituita durante una patch di unione strategica.

NetworkPolicy

Oggetto

La policy di rete per il namespace gestito.

Nome	Tipo	Descrizione
egress	PolicyRule	La politica di uscita per il namespace gestito.
ingress	PolicyRule	La politica di ingresso per il namespace gestito.

Placement.V1.Affinity

Oggetto

L'affinità è un gruppo di regole di schedulazione per affinità di cluster. Aggiungeremo altro.

Nome	Tipo	Descrizione
clusterAffinity	Placement.V1.ClusterAffinity	ClusterAffinity contiene regole di schedulazione di affinità di cluster per le risorse selezionate.

Placement.V1.ClusterAffinity

Oggetto

ClusterAffinity contiene regole di schedulazione di affinità di cluster per le risorse selezionate.

Nome	Tipo	Descrizione
requiredDuringSchedulingIgnoredDuringExecution	Placement.V1.ClusterSelector	Se i requisiti di affinità specificati da questo campo non vengono soddisfatti al momento della programmazione, la risorsa non sarà programmata sul cluster. Se i requisiti di affinità specificati da questo campo cessano di essere soddisfatti in un momento dopo il posizionamento (ad esempio a causa di un aggiornamento), il sistema potrebbe o meno tentare di rimuovere la risorsa dal cluster.

Placement.V1.ClusterResourcePlacementSpec

Oggetto

ClusterResourcePlacementSpec definisce lo stato desiderato di ClusterResourcePlacement.

Nome	Tipo	Descrizione
policy	Placement.V1.PlacementPolicy	La policy definisce come selezionare i cluster membri per collocare le risorse selezionate. Se non specificato, vengono selezionati tutti i cluster di membri uniti.

Placement.V1.ClusterSelector

Oggetto

ClusterSelector

Nome	Tipo	Descrizione
clusterSelectorTerms	Placement.V1.ClusterSelectorTerm[]	ClusterSelectorTerms è un elenco di termini selezionatori di cluster. I termini sono ORed.

Placement.V1.ClusterSelectorTerm

Oggetto

ClusterSelectorTerm

Nome	Tipo	Descrizione
labelSelector	Meta.V1.LabelSelector	LabelSelector è una query di etichette su tutti i cluster di membri uniti. Vengono selezionati cluster che corrispondono alla query. Se specifichi sia i selettori di etichette che quelli di proprietà nello stesso termine, i risultati sono E.
propertySelector	Placement.V1.PropertySelector	PropertySelector è una query di proprietà su tutti i cluster membri uniti. Vengono selezionati cluster che corrispondono alla query. Se specifichi sia i selettori di etichette che quelli di proprietà nello stesso termine, i risultati sono E. Al momento, PropertySelector può essere usato solo con RequiredDuringSchedulingIgnoredDuringExecution termini di affinità. Questo campo è a livello beta; È per la funzione di pianificazione basata sulla proprietà ed è funzionante solo quando un provider immobiliare è abilitato nella distribuzione.

Placement.V1.PlacementPolicy

Oggetto

PlacementPolicy contiene le regole per selezionare i cluster di membri target per posizionare le risorse selezionate. Si noti che verranno selezionati solo cluster che sono sia uniti che soddisfano le regole. Puoi specificare al massimo uno dei due campi: ClusterName e Affinity. Se nessuno viene specificato, tutti i cluster uniti vengono selezionati.

Nome	Tipo	Descrizione
affinity	Placement.V1.Affinity	Affinity contiene regole di schedulazione di affinità di cluster. Definisce quali cluster membri posizionare le risorse selezionate. Valido solo se il tipo di posizionamento è "PickAll" o "PickN".
clusterNames	string[]	ClusterNames contiene un elenco dei nomi di MemberCluster per posizionare le risorse selezionate. Valido solo se il tipo di posizionamento è "PickFixed"
placementType	PlacementType	Tipo di collocamento. Può essere "PickAll", "PickN" o "PickFixed". Il predefinito è PickAll.
tolerations	Placement.V1.Toleration[]	Se specificato, le Tolleranze del ClusterResourcePlacement. Le tolleranze non possono essere aggiornate o cancellate. Questo campo è di livello beta ed è per la caratteristica taints and tollers.

Placement.V1.PropertySelector

Oggetto

PropertySelector aiuta l'utente a specificare i requisiti di proprietà nella scelta dei cluster per il posizionamento delle risorse.

Nome	Tipo	Descrizione
matchExpressions	Placement.V1.PropertySelectorRequirement[]	MatchExpressions è un array di PropertySelectorRequirements. I requisiti sono AND.

Placement.V1.PropertySelectorRequirement

Oggetto

PropertySelectorRequirement è un requisito specifico di proprietà quando si selezionano cluster per il posizionamento delle risorse.

Nome	Tipo	Descrizione
name	string	Il nome è il nome della proprietà; dovrebbe essere un nome di etichetta Kubernetes.
operator	PropertySelectorOperator	L'operatore specifica la relazione tra il valore osservato di un cluster della proprietà specificata e i valori indicati nel requisito.
values	string[]	I valori sono un elenco dei valori della proprietà specificata che Fleet confronterà con i valori osservati dei singoli cluster membri in accordo con l'operatore specifico. In questo momento, ogni valore dovrebbe essere una quantità Kubernetes. Per altre informazioni, vedere https://pkg.go.dev/k8s.io/apimachinery/pkg/api/resource#Quantity. Se l'operatore è Gt (maggiore di), Ge (maggiore o uguale a), Lt (minore di), o Le (minore o uguale a), Eq (uguale a), o Ne (ne), deve essere specificato esattamente un valore nell'elenco.

Placement.V1.Toleration

Oggetto

La tolleranza permette a ClusterResourcePlacement di tollerare qualsiasi contaminazione che corrisponda al triplo <key,value,effect> usando l'operatore <>di abbinamento.

Nome	Tipo	Descrizione
effect	TaintEffect	L'effetto indica l'effetto della contaminazione da corrispondere. Vuoto significa che corrispondono a tutti gli effetti di contaminazione. Quando specificato, l'unico valore consentito è NoSchedule.
key	string	La chiave è la chiave di contaminazione a cui si applica la tolleranza. Vuoto significa che corrispondono a tutte le chiavi di contaminazione. Se la chiave è vuota, l'operatore deve essere Exists; Questa combinazione significa che tutti i valori e tutte le chiavi sono abbinate.
operator	TolerationOperator	L'operatore rappresenta la relazione di una chiave con il valore. Gli operatori validi sono Esistenti e Uguali. Di default è uguale. Exists è equivalente a wildcard per valore, così che un ClusterResourcePlacement può tollerare tutte le contaminazioni di una particolare categoria.
value	string	Il valore è il valore di contaminazione a cui la tolleranza corrisponde. Se l'operatore è Exists, il valore dovrebbe essere vuoto, altrimenti solo una stringa regolare.

PlacementProfile

Oggetto

Il profilo di configurazione per il ClusterResourcePlacement predefinito per il posizionamento.

Nome	Tipo	Descrizione
defaultClusterResourcePlacement	Placement.V1.ClusterResourcePlacementSpec	La configurazione predefinita della policy ClusterResourcePlacement.

PlacementType

Enumerazione

Tipo di collocamento. Può essere "PickAll", "PickN" o "PickFixed". Il predefinito è PickAll.

Valore	Descrizione
PickAll	PickAll seleziona tutti i cluster che soddisfano le regole.
PickFixed	PickFixed sceglie un insieme fisso di cluster.

PolicyRule

Enumerazione

I valori possibili rappresentano diverse regole di policy di rete.

Valore	Descrizione
AllowAll	Consenti tutto il traffico di rete.
DenyAll	Nega tutto il traffico di rete.
AllowSameNamespace	Consenti il traffico all'interno dello stesso spazio dei nomi.

PropagationPolicy

Oggetto

La propagazione da utilizzare per rifornire lo spazio di nomi all'interno della flotta.

Nome	Tipo	Descrizione
placementProfile	PlacementProfile	Il profilo da utilizzare per la propagazione tramite posizionamento.
type	PropagationType	Il tipo di polizza da utilizzare. Il predefinito è il posizionamento.

PropagationType

Enumerazione

Come verrà fornito il namespace tra i membri della flotta.

Valore	Descrizione
Placement	Utilizzo di ClusterResourcePlacement.

PropertySelectorOperator

Enumerazione

L'operatore specifica la relazione tra il valore osservato di un cluster della proprietà specificata e i valori indicati nel requisito.

Valore	Descrizione
Gt	Gt impone che la flotta selezioni il cluster se il valore osservato di una data proprietà è maggiore del valore specificato nel requisito.
Ge	Ge impone alla Flotta di selezionare il cluster se il suo valore osservato di una data proprietà è maggiore o uguale al valore specificato nel requisito.
Eq	L'EQ impone alla Flotta di selezionare il cluster se il valore osservato di una determinata proprietà è uguale ai valori specificati nel requisito.
Ne	Ne impone alla Flotta di selezionare il cluster se il suo valore osservato di una data proprietà non è uguale ai valori specificati nel requisito.
Lt	Lt impone alla Flotta di selezionare il cluster se il valore osservato di una data proprietà è inferiore al valore specificato nel requisito.
Le	Le impone alla Flotta di selezionare il cluster se il valore osservato di una data proprietà è inferiore o uguale al valore specificato nel requisito.

ResourceQuota

Oggetto

La quota di risorse per il namespace gestito.

Nome	Tipo	Descrizione
cpuLimit	string	Il limite della CPU per il namespace gestito. Per altre informazioni, vedere https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
cpuRequest	string	La richiesta della CPU per il namespace gestito. Per altre informazioni, vedere https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-cpu
memoryLimit	string	Il limite di memoria per il namespace gestito. Per altre informazioni, vedere https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
memoryRequest	string	La richiesta di memoria per il namespace gestito. Per altre informazioni, vedere https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory

systemData

Oggetto

Metadati relativi alla creazione e all'ultima modifica della risorsa.

Nome	Tipo	Descrizione
createdAt	string (date-time)	Timestamp della creazione della risorsa (UTC).
createdBy	string	Identità che ha creato la risorsa.
createdByType	createdByType	Tipo di identità che ha creato la risorsa.
lastModifiedAt	string (date-time)	Timestamp dell'ultima modifica della risorsa (UTC)
lastModifiedBy	string	Identità che ha modificato l'ultima volta la risorsa.
lastModifiedByType	createdByType	Tipo di identità che ha modificato l'ultima volta la risorsa.

TaintEffect

Enumerazione

L'effetto indica l'effetto della contaminazione da corrispondere. Vuoto significa che corrispondono a tutti gli effetti di contaminazione. Quando specificato, l'unico valore consentito è NoSchedule.

Valore	Descrizione
NoSchedule	Non permettere che nuovi pod vengano programmati sul nodo a meno che non tolleri il taint, ma consente a tutti i pod inviati a Kubelet senza passare dal scheduler per avviarsi, e consente a tutti i pod già in funzione di continuare a funzionare. Impostato dal programmatore.

TolerationOperator

Enumerazione

L'operatore rappresenta la relazione di una chiave con il valore. Gli operatori validi sono Esistenti e Uguali. Di default è uguale. Exists è equivalente a wildcard per valore, così che un ClusterResourcePlacement può tollerare tutte le contaminazioni di una particolare categoria.

Valore	Descrizione
Exists	Esiste un operatore di tolleranza
Equal	Operatore di tolleranza uguale