armcontainerservice

package module
v6.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 19, 2024 License: MIT Imports: 15 Imported by: 9

README

Azure Container Service Module for Go

The armcontainerservice module provides operations for working with Azure Container Service.

Source code

Getting started

Prerequisites

  • an Azure subscription
  • Go 1.18 or above (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Container Service module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v6

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Container Service. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure Container Service module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armcontainerservice.NewClientFactory(<subscription ID>, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armcontainerservice.NewClientFactory(<subscription ID>, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewAgentPoolsClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

More sample code

Major Version Upgrade

Go uses semantic import versioning to ensure a good backward compatibility for modules. For Azure Go management SDK, we usually upgrade module version according to cooresponding service's API version. Regarding it could be a complicated experience for major version upgrade, we will try our best to keep the SDK API stable and release new version in backward compatible way. However, if any unavoidable breaking changes and a new major version releases for SDK modules, you could use these commands under your module folder to upgrade:

go install github.com/icholy/gomajor@latest
gomajor get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute@latest

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Container Service label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AbsoluteMonthlySchedule 

type AbsoluteMonthlySchedule struct {
	// REQUIRED; The date of the month.
	DayOfMonth *int32

	// REQUIRED; Specifies the number of months between each set of occurrences.
	IntervalMonths *int32
}

AbsoluteMonthlySchedule - For schedules like: 'recur every month on the 15th' or 'recur every 3 months on the 20th'.

func (AbsoluteMonthlySchedule) MarshalJSON 

func (a AbsoluteMonthlySchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AbsoluteMonthlySchedule.

func (*AbsoluteMonthlySchedule) UnmarshalJSON 

func (a *AbsoluteMonthlySchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AbsoluteMonthlySchedule.

type AccessProfile 

type AccessProfile struct {
	// Base64-encoded Kubernetes configuration file.
	KubeConfig []byte
}

AccessProfile - Profile for enabling a user to access a managed cluster.

func (AccessProfile) MarshalJSON 

func (a AccessProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AccessProfile.

func (*AccessProfile) UnmarshalJSON 

func (a *AccessProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AccessProfile.

type AdvancedNetworking added in v6.3.0 

type AdvancedNetworking struct {
	// Indicates the enablement of Advanced Networking functionalities of observability and security on AKS clusters. When this
	// is set to true, all observability and security features will be set to enabled
	// unless explicitly disabled. If not specified, the default is false.
	Enabled *bool

	// Observability profile to enable advanced network metrics and flow logs with historical contexts.
	Observability *AdvancedNetworkingObservability

	// Security profile to enable security features on cilium based cluster.
	Security *AdvancedNetworkingSecurity
}

AdvancedNetworking - Advanced Networking profile for enabling observability and security feature suite on a cluster. For more information see aka.ms/aksadvancednetworking.

func (AdvancedNetworking) MarshalJSON added in v6.3.0 

func (a AdvancedNetworking) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdvancedNetworking.

func (*AdvancedNetworking) UnmarshalJSON added in v6.3.0 

func (a *AdvancedNetworking) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdvancedNetworking.

type AdvancedNetworkingObservability added in v6.3.0 

type AdvancedNetworkingObservability struct {
	// Indicates the enablement of Advanced Networking observability functionalities on clusters.
	Enabled *bool
}

AdvancedNetworkingObservability - Observability profile to enable advanced network metrics and flow logs with historical contexts.

func (AdvancedNetworkingObservability) MarshalJSON added in v6.3.0 

func (a AdvancedNetworkingObservability) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdvancedNetworkingObservability.

func (*AdvancedNetworkingObservability) UnmarshalJSON added in v6.3.0 

func (a *AdvancedNetworkingObservability) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdvancedNetworkingObservability.

type AdvancedNetworkingSecurity added in v6.3.0 

type AdvancedNetworkingSecurity struct {
	// This feature allows user to configure network policy based on DNS (FQDN) names. It can be enabled only on cilium based
	// clusters. If not specified, the default is false.
	Enabled *bool
}

AdvancedNetworkingSecurity - Security profile to enable security features on cilium based cluster.

func (AdvancedNetworkingSecurity) MarshalJSON added in v6.3.0 

func (a AdvancedNetworkingSecurity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AdvancedNetworkingSecurity.

func (*AdvancedNetworkingSecurity) UnmarshalJSON added in v6.3.0 

func (a *AdvancedNetworkingSecurity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AdvancedNetworkingSecurity.

type AgentPool 

type AgentPool struct {
	// Properties of an agent pool.
	Properties *ManagedClusterAgentPoolProfileProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; The name of the resource that is unique within a resource group. This name can be used to access the resource.
	Name *string

	// READ-ONLY; Resource type
	Type *string
}

AgentPool - Agent Pool.

func (AgentPool) MarshalJSON 

func (a AgentPool) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPool.

func (*AgentPool) UnmarshalJSON 

func (a *AgentPool) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPool.

type AgentPoolAvailableVersions 

type AgentPoolAvailableVersions struct {
	// REQUIRED; Properties of agent pool available versions.
	Properties *AgentPoolAvailableVersionsProperties

	// READ-ONLY; The ID of the agent pool version list.
	ID *string

	// READ-ONLY; The name of the agent pool version list.
	Name *string

	// READ-ONLY; Type of the agent pool version list.
	Type *string
}

AgentPoolAvailableVersions - The list of available versions for an agent pool.

func (AgentPoolAvailableVersions) MarshalJSON 

func (a AgentPoolAvailableVersions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolAvailableVersions.

func (*AgentPoolAvailableVersions) UnmarshalJSON 

func (a *AgentPoolAvailableVersions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolAvailableVersions.

type AgentPoolAvailableVersionsProperties 

type AgentPoolAvailableVersionsProperties struct {
	// List of versions available for agent pool.
	AgentPoolVersions []*AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem
}

AgentPoolAvailableVersionsProperties - The list of available agent pool versions.

func (AgentPoolAvailableVersionsProperties) MarshalJSON 

func (a AgentPoolAvailableVersionsProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolAvailableVersionsProperties.

func (*AgentPoolAvailableVersionsProperties) UnmarshalJSON 

func (a *AgentPoolAvailableVersionsProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolAvailableVersionsProperties.

type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem 

type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem struct {
	// Whether this version is the default agent pool version.
	Default *bool

	// Whether Kubernetes version is currently in preview.
	IsPreview *bool

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string
}

func (AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem) MarshalJSON 

func (a AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem.

func (*AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem) UnmarshalJSON 

func (a *AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem.

type AgentPoolDeleteMachinesParameter added in v6.1.0 

type AgentPoolDeleteMachinesParameter struct {
	// REQUIRED; The agent pool machine names.
	MachineNames []*string
}

AgentPoolDeleteMachinesParameter - Specifies a list of machine names from the agent pool to be deleted.

func (AgentPoolDeleteMachinesParameter) MarshalJSON added in v6.1.0 

func (a AgentPoolDeleteMachinesParameter) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolDeleteMachinesParameter.

func (*AgentPoolDeleteMachinesParameter) UnmarshalJSON added in v6.1.0 

func (a *AgentPoolDeleteMachinesParameter) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolDeleteMachinesParameter.

type AgentPoolListResult 

type AgentPoolListResult struct {
	// The list of agent pools.
	Value []*AgentPool

	// READ-ONLY; The URL to get the next set of agent pool results.
	NextLink *string
}

AgentPoolListResult - The response from the List Agent Pools operation.

func (AgentPoolListResult) MarshalJSON 

func (a AgentPoolListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolListResult.

func (*AgentPoolListResult) UnmarshalJSON 

func (a *AgentPoolListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolListResult.

type AgentPoolMode 

type AgentPoolMode string

AgentPoolMode - A cluster must have at least one 'System' Agent Pool at all times. For additional information on agent pool restrictions and best practices, see: https://docs.microsoft.com/azure/aks/use-system-pools 

const (
	// AgentPoolModeSystem - System agent pools are primarily for hosting critical system pods such as CoreDNS and metrics-server.
	// System agent pools osType must be Linux. System agent pools VM SKU must have at least 2vCPUs and 4GB of memory.
	AgentPoolModeSystem AgentPoolMode = "System"
	// AgentPoolModeUser - User agent pools are primarily for hosting your application pods.
	AgentPoolModeUser AgentPoolMode = "User"
)

func PossibleAgentPoolModeValues 

func PossibleAgentPoolModeValues() []AgentPoolMode

PossibleAgentPoolModeValues returns the possible values for the AgentPoolMode const type.

type AgentPoolNetworkProfile 

type AgentPoolNetworkProfile struct {
	// The port ranges that are allowed to access. The specified ranges are allowed to overlap.
	AllowedHostPorts []*PortRange

	// The IDs of the application security groups which agent pool will associate when created.
	ApplicationSecurityGroups []*string

	// IPTags of instance-level public IPs.
	NodePublicIPTags []*IPTag
}

AgentPoolNetworkProfile - Network settings of an agent pool.

func (AgentPoolNetworkProfile) MarshalJSON 

func (a AgentPoolNetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolNetworkProfile.

func (*AgentPoolNetworkProfile) UnmarshalJSON 

func (a *AgentPoolNetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolNetworkProfile.

type AgentPoolSecurityProfile added in v6.1.0 

type AgentPoolSecurityProfile struct {
	// Secure Boot is a feature of Trusted Launch which ensures that only signed operating systems and drivers can boot. For more
	// details, see aka.ms/aks/trustedlaunch. If not specified, the default is
	// false.
	EnableSecureBoot *bool

	// vTPM is a Trusted Launch feature for configuring a dedicated secure vault for keys and measurements held locally on the
	// node. For more details, see aka.ms/aks/trustedlaunch. If not specified, the
	// default is false.
	EnableVTPM *bool
}

AgentPoolSecurityProfile - The security settings of an agent pool.

func (AgentPoolSecurityProfile) MarshalJSON added in v6.1.0 

func (a AgentPoolSecurityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolSecurityProfile.

func (*AgentPoolSecurityProfile) UnmarshalJSON added in v6.1.0 

func (a *AgentPoolSecurityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolSecurityProfile.

type AgentPoolType 

type AgentPoolType string

AgentPoolType - The type of Agent Pool. 

const (
	// AgentPoolTypeAvailabilitySet - Use of this is strongly discouraged.
	AgentPoolTypeAvailabilitySet AgentPoolType = "AvailabilitySet"
	// AgentPoolTypeVirtualMachineScaleSets - Create an Agent Pool backed by a Virtual Machine Scale Set.
	AgentPoolTypeVirtualMachineScaleSets AgentPoolType = "VirtualMachineScaleSets"
)

func PossibleAgentPoolTypeValues 

func PossibleAgentPoolTypeValues() []AgentPoolType

PossibleAgentPoolTypeValues returns the possible values for the AgentPoolType const type.

type AgentPoolUpgradeProfile 

type AgentPoolUpgradeProfile struct {
	// REQUIRED; The properties of the agent pool upgrade profile.
	Properties *AgentPoolUpgradeProfileProperties

	// READ-ONLY; The ID of the agent pool upgrade profile.
	ID *string

	// READ-ONLY; The name of the agent pool upgrade profile.
	Name *string

	// READ-ONLY; The type of the agent pool upgrade profile.
	Type *string
}

AgentPoolUpgradeProfile - The list of available upgrades for an agent pool.

func (AgentPoolUpgradeProfile) MarshalJSON 

func (a AgentPoolUpgradeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolUpgradeProfile.

func (*AgentPoolUpgradeProfile) UnmarshalJSON 

func (a *AgentPoolUpgradeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolUpgradeProfile.

type AgentPoolUpgradeProfileProperties 

type AgentPoolUpgradeProfileProperties struct {
	// REQUIRED; The Kubernetes version (major.minor.patch).
	KubernetesVersion *string

	// REQUIRED; The operating system type. The default is Linux.
	OSType *OSType

	// The latest AKS supported node image version.
	LatestNodeImageVersion *string

	// List of orchestrator types and versions available for upgrade.
	Upgrades []*AgentPoolUpgradeProfilePropertiesUpgradesItem
}

AgentPoolUpgradeProfileProperties - The list of available upgrade versions.

func (AgentPoolUpgradeProfileProperties) MarshalJSON 

func (a AgentPoolUpgradeProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolUpgradeProfileProperties.

func (*AgentPoolUpgradeProfileProperties) UnmarshalJSON 

func (a *AgentPoolUpgradeProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolUpgradeProfileProperties.

type AgentPoolUpgradeProfilePropertiesUpgradesItem 

type AgentPoolUpgradeProfilePropertiesUpgradesItem struct {
	// Whether the Kubernetes version is currently in preview.
	IsPreview *bool

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string
}

func (AgentPoolUpgradeProfilePropertiesUpgradesItem) MarshalJSON 

func (a AgentPoolUpgradeProfilePropertiesUpgradesItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolUpgradeProfilePropertiesUpgradesItem.

func (*AgentPoolUpgradeProfilePropertiesUpgradesItem) UnmarshalJSON 

func (a *AgentPoolUpgradeProfilePropertiesUpgradesItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolUpgradeProfilePropertiesUpgradesItem.

type AgentPoolUpgradeSettings 

type AgentPoolUpgradeSettings struct {
	// The amount of time (in minutes) to wait on eviction of pods and graceful termination per node. This eviction wait time
	// honors waiting on pod disruption budgets. If this time is exceeded, the upgrade
	// fails. If not specified, the default is 30 minutes.
	DrainTimeoutInMinutes *int32

	// This can either be set to an integer (e.g. '5') or a percentage (e.g. '50%'). If a percentage is specified, it is the percentage
	// of the total agent pool size at the time of the upgrade. For
	// percentages, fractional nodes are rounded up. If not specified, the default is 1. For more information, including best
	// practices, see:
	// https://docs.microsoft.com/azure/aks/upgrade-cluster#customize-node-surge-upgrade
	MaxSurge *string

	// The amount of time (in minutes) to wait after draining a node and before reimaging it and moving on to next node. If not
	// specified, the default is 0 minutes.
	NodeSoakDurationInMinutes *int32
}

AgentPoolUpgradeSettings - Settings for upgrading an agentpool

func (AgentPoolUpgradeSettings) MarshalJSON 

func (a AgentPoolUpgradeSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolUpgradeSettings.

func (*AgentPoolUpgradeSettings) UnmarshalJSON 

func (a *AgentPoolUpgradeSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolUpgradeSettings.

type AgentPoolWindowsProfile 

type AgentPoolWindowsProfile struct {
	// The default value is false. Outbound NAT can only be disabled if the cluster outboundType is NAT Gateway and the Windows
	// agent pool does not have node public IP enabled.
	DisableOutboundNat *bool
}

AgentPoolWindowsProfile - The Windows agent pool's specific profile.

func (AgentPoolWindowsProfile) MarshalJSON 

func (a AgentPoolWindowsProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AgentPoolWindowsProfile.

func (*AgentPoolWindowsProfile) UnmarshalJSON 

func (a *AgentPoolWindowsProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AgentPoolWindowsProfile.

type AgentPoolsClient 

type AgentPoolsClient struct {
	// contains filtered or unexported fields
}

AgentPoolsClient contains the methods for the AgentPools group. Don't use this type directly, use NewAgentPoolsClient() instead.

func NewAgentPoolsClient 

func NewAgentPoolsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AgentPoolsClient, error)

NewAgentPoolsClient creates a new instance of AgentPoolsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*AgentPoolsClient) BeginAbortLatestOperation 

func (client *AgentPoolsClient) BeginAbortLatestOperation(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, options *AgentPoolsClientBeginAbortLatestOperationOptions) (*runtime.Poller[AgentPoolsClientAbortLatestOperationResponse], error)

BeginAbortLatestOperation - Aborts the currently running operation on the agent pool. The Agent Pool will be moved to a Canceling state and eventually to a Canceled state when cancellation finishes. If the operation completes before cancellation can take place, a 409 error code is returned. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - AgentPoolsClientBeginAbortLatestOperationOptions contains the optional parameters for the AgentPoolsClient.BeginAbortLatestOperation method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsAbortOperation.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginAbortLatestOperation(ctx, "rg1", "clustername1", "agentpool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AgentPoolsClient) BeginCreateOrUpdate 

func (client *AgentPoolsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, parameters AgentPool, options *AgentPoolsClientBeginCreateOrUpdateOptions) (*runtime.Poller[AgentPoolsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an agent pool in the specified managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • parameters - The agent pool to create or update.
  • options - AgentPoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the AgentPoolsClient.BeginCreateOrUpdate method.
Example (CreateAgentPoolUsingAnAgentPoolSnapshot)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_Snapshot.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count: to.Ptr[int32](3),
		CreationData: &armcontainerservice.CreationData{
			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
		},
		EnableFIPS:          to.Ptr(true),
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CreationData: &armcontainerservice.CreationData{
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
// 		},
// 		CurrentOrchestratorVersion: to.Ptr("1.19.6"),
// 		EnableFIPS: to.Ptr(true),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.19.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithCapacityReservationGroup)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_CRG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		CapacityReservationGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/CapacityReservationGroups/crg1"),
		Count:                      to.Ptr[int32](3),
		OrchestratorVersion:        to.Ptr(""),
		OSType:                     to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:                     to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		CapacityReservationGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/CapacityReservationGroups/crg1"),
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.9.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithDedicatedHostGroup)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_DedicatedHostGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		HostGroupID:         to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		HostGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.19.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithEncryptionAtHostEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_EnableEncryptionAtHost.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:                  to.Ptr[int32](3),
		EnableEncryptionAtHost: to.Ptr(true),
		OrchestratorVersion:    to.Ptr(""),
		OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:                 to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.13"),
// 		EnableEncryptionAtHost: to.Ptr(true),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.17.13"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithEphemeralOsDisk)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_Ephemeral.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		OrchestratorVersion: to.Ptr(""),
		OSDiskSizeGB:        to.Ptr[int32](64),
		OSDiskType:          to.Ptr(armcontainerservice.OSDiskTypeEphemeral),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.8"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.17.8"),
// 		OSDiskSizeGB: to.Ptr[int32](64),
// 		OSDiskType: to.Ptr(armcontainerservice.OSDiskTypeEphemeral),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithFipsEnabledOs)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_EnableFIPS.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		EnableFIPS:          to.Ptr(true),
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.19.6"),
// 		EnableFIPS: to.Ptr(true),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.19.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithGpumig)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_GPUMIG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:              to.Ptr[int32](3),
		GpuInstanceProfile: to.Ptr(armcontainerservice.GPUInstanceProfileMIG2G),
		KubeletConfig: &armcontainerservice.KubeletConfig{
			AllowedUnsafeSysctls: []*string{
				to.Ptr("kernel.msg*"),
				to.Ptr("net.core.somaxconn")},
			CPUCfsQuota:           to.Ptr(true),
			CPUCfsQuotaPeriod:     to.Ptr("200ms"),
			CPUManagerPolicy:      to.Ptr("static"),
			FailSwapOn:            to.Ptr(false),
			ImageGcHighThreshold:  to.Ptr[int32](90),
			ImageGcLowThreshold:   to.Ptr[int32](70),
			TopologyManagerPolicy: to.Ptr("best-effort"),
		},
		LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
			SwapFileSizeMB: to.Ptr[int32](1500),
			Sysctls: &armcontainerservice.SysctlConfig{
				KernelThreadsMax:        to.Ptr[int32](99999),
				NetCoreWmemDefault:      to.Ptr[int32](12345),
				NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
				NetIPv4TCPTwReuse:       to.Ptr(true),
			},
			TransparentHugePageDefrag:  to.Ptr("madvise"),
			TransparentHugePageEnabled: to.Ptr("always"),
		},
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_ND96asr_v4"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.8"),
// 		GpuInstanceProfile: to.Ptr(armcontainerservice.GPUInstanceProfileMIG2G),
// 		KubeletConfig: &armcontainerservice.KubeletConfig{
// 			AllowedUnsafeSysctls: []*string{
// 				to.Ptr("kernel.msg*"),
// 				to.Ptr("net.core.somaxconn")},
// 				CPUCfsQuota: to.Ptr(true),
// 				CPUCfsQuotaPeriod: to.Ptr("200ms"),
// 				CPUManagerPolicy: to.Ptr("static"),
// 				FailSwapOn: to.Ptr(false),
// 				ImageGcHighThreshold: to.Ptr[int32](90),
// 				ImageGcLowThreshold: to.Ptr[int32](70),
// 				TopologyManagerPolicy: to.Ptr("best-effort"),
// 			},
// 			LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
// 				SwapFileSizeMB: to.Ptr[int32](1500),
// 				Sysctls: &armcontainerservice.SysctlConfig{
// 					KernelThreadsMax: to.Ptr[int32](99999),
// 					NetCoreWmemDefault: to.Ptr[int32](12345),
// 					NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
// 					NetIPv4TCPTwReuse: to.Ptr(true),
// 				},
// 				TransparentHugePageDefrag: to.Ptr("madvise"),
// 				TransparentHugePageEnabled: to.Ptr("always"),
// 			},
// 			MaxPods: to.Ptr[int32](110),
// 			OrchestratorVersion: to.Ptr("1.17.8"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			VMSize: to.Ptr("Standard_ND96asr_v4"),
// 		},
// 	}

Output:
Example (CreateAgentPoolWithKrustletAndTheWasiRuntime)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_WasmWasi.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		Mode:                to.Ptr(armcontainerservice.AgentPoolModeUser),
		OrchestratorVersion: to.Ptr(""),
		OSDiskSizeGB:        to.Ptr[int32](64),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
		WorkloadRuntime:     to.Ptr(armcontainerservice.WorkloadRuntimeWasmWasi),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.8"),
// 		MaxPods: to.Ptr[int32](110),
// 		Mode: to.Ptr(armcontainerservice.AgentPoolModeUser),
// 		OrchestratorVersion: to.Ptr("1.17.8"),
// 		OSDiskSizeGB: to.Ptr[int32](64),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 		WorkloadRuntime: to.Ptr(armcontainerservice.WorkloadRuntimeWasmWasi),
// 	},
// }

Output:
Example (CreateAgentPoolWithKubeletConfigAndLinuxOsConfig)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_CustomNodeConfig.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count: to.Ptr[int32](3),
		KubeletConfig: &armcontainerservice.KubeletConfig{
			AllowedUnsafeSysctls: []*string{
				to.Ptr("kernel.msg*"),
				to.Ptr("net.core.somaxconn")},
			CPUCfsQuota:           to.Ptr(true),
			CPUCfsQuotaPeriod:     to.Ptr("200ms"),
			CPUManagerPolicy:      to.Ptr("static"),
			FailSwapOn:            to.Ptr(false),
			ImageGcHighThreshold:  to.Ptr[int32](90),
			ImageGcLowThreshold:   to.Ptr[int32](70),
			TopologyManagerPolicy: to.Ptr("best-effort"),
		},
		LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
			SwapFileSizeMB: to.Ptr[int32](1500),
			Sysctls: &armcontainerservice.SysctlConfig{
				KernelThreadsMax:        to.Ptr[int32](99999),
				NetCoreWmemDefault:      to.Ptr[int32](12345),
				NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
				NetIPv4TCPTwReuse:       to.Ptr(true),
			},
			TransparentHugePageDefrag:  to.Ptr("madvise"),
			TransparentHugePageEnabled: to.Ptr("always"),
		},
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.8"),
// 		KubeletConfig: &armcontainerservice.KubeletConfig{
// 			AllowedUnsafeSysctls: []*string{
// 				to.Ptr("kernel.msg*"),
// 				to.Ptr("net.core.somaxconn")},
// 				CPUCfsQuota: to.Ptr(true),
// 				CPUCfsQuotaPeriod: to.Ptr("200ms"),
// 				CPUManagerPolicy: to.Ptr("static"),
// 				FailSwapOn: to.Ptr(false),
// 				ImageGcHighThreshold: to.Ptr[int32](90),
// 				ImageGcLowThreshold: to.Ptr[int32](70),
// 				TopologyManagerPolicy: to.Ptr("best-effort"),
// 			},
// 			LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
// 				SwapFileSizeMB: to.Ptr[int32](1500),
// 				Sysctls: &armcontainerservice.SysctlConfig{
// 					KernelThreadsMax: to.Ptr[int32](99999),
// 					NetCoreWmemDefault: to.Ptr[int32](12345),
// 					NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
// 					NetIPv4TCPTwReuse: to.Ptr(true),
// 				},
// 				TransparentHugePageDefrag: to.Ptr("madvise"),
// 				TransparentHugePageEnabled: to.Ptr("always"),
// 			},
// 			MaxPods: to.Ptr[int32](110),
// 			OrchestratorVersion: to.Ptr("1.17.8"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			VMSize: to.Ptr("Standard_DS2_v2"),
// 		},
// 	}

Output:
Example (CreateAgentPoolWithOssku)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_OSSKU.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count: to.Ptr[int32](3),
		KubeletConfig: &armcontainerservice.KubeletConfig{
			AllowedUnsafeSysctls: []*string{
				to.Ptr("kernel.msg*"),
				to.Ptr("net.core.somaxconn")},
			CPUCfsQuota:           to.Ptr(true),
			CPUCfsQuotaPeriod:     to.Ptr("200ms"),
			CPUManagerPolicy:      to.Ptr("static"),
			FailSwapOn:            to.Ptr(false),
			ImageGcHighThreshold:  to.Ptr[int32](90),
			ImageGcLowThreshold:   to.Ptr[int32](70),
			TopologyManagerPolicy: to.Ptr("best-effort"),
		},
		LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
			SwapFileSizeMB: to.Ptr[int32](1500),
			Sysctls: &armcontainerservice.SysctlConfig{
				KernelThreadsMax:        to.Ptr[int32](99999),
				NetCoreWmemDefault:      to.Ptr[int32](12345),
				NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
				NetIPv4TCPTwReuse:       to.Ptr(true),
			},
			TransparentHugePageDefrag:  to.Ptr("madvise"),
			TransparentHugePageEnabled: to.Ptr("always"),
		},
		OrchestratorVersion: to.Ptr(""),
		OSSKU:               to.Ptr(armcontainerservice.OSSKUAzureLinux),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.8"),
// 		KubeletConfig: &armcontainerservice.KubeletConfig{
// 			AllowedUnsafeSysctls: []*string{
// 				to.Ptr("kernel.msg*"),
// 				to.Ptr("net.core.somaxconn")},
// 				CPUCfsQuota: to.Ptr(true),
// 				CPUCfsQuotaPeriod: to.Ptr("200ms"),
// 				CPUManagerPolicy: to.Ptr("static"),
// 				FailSwapOn: to.Ptr(false),
// 				ImageGcHighThreshold: to.Ptr[int32](90),
// 				ImageGcLowThreshold: to.Ptr[int32](70),
// 				TopologyManagerPolicy: to.Ptr("best-effort"),
// 			},
// 			LinuxOSConfig: &armcontainerservice.LinuxOSConfig{
// 				SwapFileSizeMB: to.Ptr[int32](1500),
// 				Sysctls: &armcontainerservice.SysctlConfig{
// 					KernelThreadsMax: to.Ptr[int32](99999),
// 					NetCoreWmemDefault: to.Ptr[int32](12345),
// 					NetIPv4IPLocalPortRange: to.Ptr("20000 60000"),
// 					NetIPv4TCPTwReuse: to.Ptr(true),
// 				},
// 				TransparentHugePageDefrag: to.Ptr("madvise"),
// 				TransparentHugePageEnabled: to.Ptr("always"),
// 			},
// 			MaxPods: to.Ptr[int32](110),
// 			OrchestratorVersion: to.Ptr("1.17.8"),
// 			OSSKU: to.Ptr(armcontainerservice.OSSKUAzureLinux),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			VMSize: to.Ptr("Standard_DS2_v2"),
// 		},
// 	}

Output:
Example (CreateAgentPoolWithPpg)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_PPG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:                     to.Ptr[int32](3),
		OrchestratorVersion:       to.Ptr(""),
		OSType:                    to.Ptr(armcontainerservice.OSTypeLinux),
		ProximityPlacementGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
		VMSize:                    to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.9.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ProximityPlacementGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithUltraSsdEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_EnableUltraSSD.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		EnableUltraSSD:      to.Ptr(true),
		OrchestratorVersion: to.Ptr(""),
		OSType:              to.Ptr(armcontainerservice.OSTypeLinux),
		VMSize:              to.Ptr("Standard_DS2_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.17.13"),
// 		EnableUltraSSD: to.Ptr(true),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.17.13"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_DS2_v2"),
// 	},
// }

Output:
Example (CreateAgentPoolWithWindowsOssku)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_WindowsOSSKU.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "wnp2", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		OrchestratorVersion: to.Ptr("1.23.3"),
		OSSKU:               to.Ptr(armcontainerservice.OSSKUWindows2022),
		OSType:              to.Ptr(armcontainerservice.OSTypeWindows),
		VMSize:              to.Ptr("Standard_D4s_v3"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("wnp2"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/wnp2"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.23.3"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.23.3"),
// 		OSSKU: to.Ptr(armcontainerservice.OSSKUWindows2022),
// 		OSType: to.Ptr(armcontainerservice.OSTypeWindows),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_D4s_v3"),
// 	},
// }

Output:
Example (CreateSpotAgentPool)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_Spot.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count: to.Ptr[int32](3),
		NodeLabels: map[string]*string{
			"key1": to.Ptr("val1"),
		},
		NodeTaints: []*string{
			to.Ptr("Key1=Value1:NoSchedule")},
		OrchestratorVersion:    to.Ptr(""),
		OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
		ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
		ScaleSetPriority:       to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
		Tags: map[string]*string{
			"name1": to.Ptr("val1"),
		},
		VMSize: to.Ptr("Standard_DS1_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		MaxPods: to.Ptr[int32](110),
// 		NodeLabels: map[string]*string{
// 			"key1": to.Ptr("val1"),
// 		},
// 		NodeTaints: []*string{
// 			to.Ptr("Key1=Value1:NoSchedule")},
// 			OrchestratorVersion: to.Ptr("1.9.6"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
// 			ScaleSetPriority: to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
// 			SpotMaxPrice: to.Ptr[float32](-1),
// 			Tags: map[string]*string{
// 				"name1": to.Ptr("val1"),
// 			},
// 			VMSize: to.Ptr("Standard_DS1_v2"),
// 		},
// 	}

Output:
Example (CreateUpdateAgentPool)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count: to.Ptr[int32](3),
		Mode:  to.Ptr(armcontainerservice.AgentPoolModeUser),
		NodeLabels: map[string]*string{
			"key1": to.Ptr("val1"),
		},
		NodeTaints: []*string{
			to.Ptr("Key1=Value1:NoSchedule")},
		OrchestratorVersion:    to.Ptr(""),
		OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
		ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
		ScaleSetPriority:       to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
		Tags: map[string]*string{
			"name1": to.Ptr("val1"),
		},
		VMSize: to.Ptr("Standard_DS1_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		MaxPods: to.Ptr[int32](110),
// 		Mode: to.Ptr(armcontainerservice.AgentPoolModeUser),
// 		NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 		NodeLabels: map[string]*string{
// 			"key1": to.Ptr("val1"),
// 		},
// 		NodeTaints: []*string{
// 			to.Ptr("Key1=Value1:NoSchedule")},
// 			OrchestratorVersion: to.Ptr("1.9.6"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
// 			ScaleSetPriority: to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
// 			Tags: map[string]*string{
// 				"name1": to.Ptr("val1"),
// 			},
// 			VMSize: to.Ptr("Standard_DS1_v2"),
// 		},
// 	}

Output:
Example (CreateWindowsAgentPoolWithDisablingOutboundNat)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsCreate_WindowsDisableOutboundNAT.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "wnp2", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:               to.Ptr[int32](3),
		OrchestratorVersion: to.Ptr("1.23.8"),
		OSSKU:               to.Ptr(armcontainerservice.OSSKUWindows2022),
		OSType:              to.Ptr(armcontainerservice.OSTypeWindows),
		VMSize:              to.Ptr("Standard_D4s_v3"),
		WindowsProfile: &armcontainerservice.AgentPoolWindowsProfile{
			DisableOutboundNat: to.Ptr(true),
		},
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("wnp2"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/wnp2"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.23.8"),
// 		MaxPods: to.Ptr[int32](110),
// 		OrchestratorVersion: to.Ptr("1.23.8"),
// 		OSSKU: to.Ptr(armcontainerservice.OSSKUWindows2022),
// 		OSType: to.Ptr(armcontainerservice.OSTypeWindows),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		VMSize: to.Ptr("Standard_D4s_v3"),
// 		WindowsProfile: &armcontainerservice.AgentPoolWindowsProfile{
// 			DisableOutboundNat: to.Ptr(true),
// 		},
// 	},
// }

Output:
Example (StartAgentPool)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPools_Start.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		PowerState: &armcontainerservice.PowerState{
			Code: to.Ptr(armcontainerservice.CodeRunning),
		},
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](50),
// 		EnableAutoScaling: to.Ptr(true),
// 		MaxCount: to.Ptr[int32](55),
// 		MinCount: to.Ptr[int32](3),
// 		PowerState: &armcontainerservice.PowerState{
// 			Code: to.Ptr(armcontainerservice.CodeRunning),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:
Example (StopAgentPool)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPools_Stop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		PowerState: &armcontainerservice.PowerState{
			Code: to.Ptr(armcontainerservice.CodeStopped),
		},
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](0),
// 		EnableAutoScaling: to.Ptr(false),
// 		PowerState: &armcontainerservice.PowerState{
// 			Code: to.Ptr(armcontainerservice.CodeStopped),
// 		},
// 		ProvisioningState: to.Ptr("Succeeded"),
// 	},
// }

Output:
Example (UpdateAgentPool)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPools_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPool{
	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
		Count:             to.Ptr[int32](3),
		EnableAutoScaling: to.Ptr(true),
		MaxCount:          to.Ptr[int32](2),
		MinCount:          to.Ptr[int32](2),
		NodeTaints: []*string{
			to.Ptr("Key1=Value1:NoSchedule")},
		OrchestratorVersion:    to.Ptr(""),
		OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
		ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
		ScaleSetPriority:       to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
		VMSize:                 to.Ptr("Standard_DS1_v2"),
	},
}, &armcontainerservice.AgentPoolsClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		EnableAutoScaling: to.Ptr(true),
// 		MaxCount: to.Ptr[int32](2),
// 		MaxPods: to.Ptr[int32](110),
// 		MinCount: to.Ptr[int32](2),
// 		NodeTaints: []*string{
// 			to.Ptr("Key1=Value1:NoSchedule")},
// 			OrchestratorVersion: to.Ptr("1.9.6"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			ProvisioningState: to.Ptr("Succeeded"),
// 			ScaleSetEvictionPolicy: to.Ptr(armcontainerservice.ScaleSetEvictionPolicyDelete),
// 			ScaleSetPriority: to.Ptr(armcontainerservice.ScaleSetPrioritySpot),
// 			VMSize: to.Ptr("Standard_DS1_v2"),
// 		},
// 	}

Output:

func (*AgentPoolsClient) BeginDelete 

func (client *AgentPoolsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, options *AgentPoolsClientBeginDeleteOptions) (*runtime.Poller[AgentPoolsClientDeleteResponse], error)

BeginDelete - Deletes an agent pool in the specified managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - AgentPoolsClientBeginDeleteOptions contains the optional parameters for the AgentPoolsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginDelete(ctx, "rg1", "clustername1", "agentpool1", &armcontainerservice.AgentPoolsClientBeginDeleteOptions{IgnorePodDisruptionBudget: nil,
	IfMatch: nil,
})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AgentPoolsClient) BeginDeleteMachines added in v6.1.0 

func (client *AgentPoolsClient) BeginDeleteMachines(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, machines AgentPoolDeleteMachinesParameter, options *AgentPoolsClientBeginDeleteMachinesOptions) (*runtime.Poller[AgentPoolsClientDeleteMachinesResponse], error)

BeginDeleteMachines - Deletes specific machines in an agent pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • machines - A list of machines from the agent pool to be deleted.
  • options - AgentPoolsClientBeginDeleteMachinesOptions contains the optional parameters for the AgentPoolsClient.BeginDeleteMachines method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsDeleteMachines.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginDeleteMachines(ctx, "rg1", "clustername1", "agentpool1", armcontainerservice.AgentPoolDeleteMachinesParameter{
	MachineNames: []*string{
		to.Ptr("aks-nodepool1-42263519-vmss00000a"),
		to.Ptr("aks-nodepool1-42263519-vmss00000b")},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AgentPoolsClient) BeginUpgradeNodeImageVersion 

func (client *AgentPoolsClient) BeginUpgradeNodeImageVersion(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, options *AgentPoolsClientBeginUpgradeNodeImageVersionOptions) (*runtime.Poller[AgentPoolsClientUpgradeNodeImageVersionResponse], error)

BeginUpgradeNodeImageVersion - Upgrading the node image version of an agent pool applies the newest OS and runtime updates to the nodes. AKS provides one new image per week with the latest updates. For more details on node image versions, see: https://docs.microsoft.com/azure/aks/node-image-upgrade If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - AgentPoolsClientBeginUpgradeNodeImageVersionOptions contains the optional parameters for the AgentPoolsClient.BeginUpgradeNodeImageVersion method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsUpgradeNodeImageVersion.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewAgentPoolsClient().BeginUpgradeNodeImageVersion(ctx, "rg1", "clustername1", "agentpool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*AgentPoolsClient) Get 

func (client *AgentPoolsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, options *AgentPoolsClientGetOptions) (AgentPoolsClientGetResponse, error)

Get - Gets the specified managed cluster agent pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - AgentPoolsClientGetOptions contains the optional parameters for the AgentPoolsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAgentPoolsClient().Get(ctx, "rg1", "clustername1", "agentpool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.AgentPool = armcontainerservice.AgentPool{
// 	Name: to.Ptr("agentpool1"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
// 	Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
// 		Count: to.Ptr[int32](3),
// 		CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 		ETag: to.Ptr("ebwiyfneowv"),
// 		MaxPods: to.Ptr[int32](110),
// 		NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 		OrchestratorVersion: to.Ptr("1.9.6"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		UpgradeSettings: &armcontainerservice.AgentPoolUpgradeSettings{
// 			MaxSurge: to.Ptr("33%"),
// 		},
// 		VMSize: to.Ptr("Standard_DS1_v2"),
// 	},
// }

Output:

func (*AgentPoolsClient) GetAvailableAgentPoolVersions 

func (client *AgentPoolsClient) GetAvailableAgentPoolVersions(ctx context.Context, resourceGroupName string, resourceName string, options *AgentPoolsClientGetAvailableAgentPoolVersionsOptions) (AgentPoolsClientGetAvailableAgentPoolVersionsResponse, error)

GetAvailableAgentPoolVersions - See supported Kubernetes versions [https://docs.microsoft.com/azure/aks/supported-kubernetes-versions] for more details about the version lifecycle. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - AgentPoolsClientGetAvailableAgentPoolVersionsOptions contains the optional parameters for the AgentPoolsClient.GetAvailableAgentPoolVersions method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsGetAgentPoolAvailableVersions.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAgentPoolsClient().GetAvailableAgentPoolVersions(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.AgentPoolAvailableVersions = armcontainerservice.AgentPoolAvailableVersions{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/availableAgentpoolVersions"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/availableagentpoolversions"),
// 	Properties: &armcontainerservice.AgentPoolAvailableVersionsProperties{
// 		AgentPoolVersions: []*armcontainerservice.AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem{
// 			{
// 				KubernetesVersion: to.Ptr("1.12.7"),
// 			},
// 			{
// 				KubernetesVersion: to.Ptr("1.12.8"),
// 			},
// 			{
// 				Default: to.Ptr(true),
// 				IsPreview: to.Ptr(true),
// 				KubernetesVersion: to.Ptr("1.13.5"),
// 		}},
// 	},
// }

Output:

func (*AgentPoolsClient) GetUpgradeProfile 

func (client *AgentPoolsClient) GetUpgradeProfile(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, options *AgentPoolsClientGetUpgradeProfileOptions) (AgentPoolsClientGetUpgradeProfileResponse, error)

GetUpgradeProfile - Gets the upgrade profile for an agent pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - AgentPoolsClientGetUpgradeProfileOptions contains the optional parameters for the AgentPoolsClient.GetUpgradeProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsGetUpgradeProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewAgentPoolsClient().GetUpgradeProfile(ctx, "rg1", "clustername1", "agentpool1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.AgentPoolUpgradeProfile = armcontainerservice.AgentPoolUpgradeProfile{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/upgradeProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1/upgradeprofiles/default"),
// 	Properties: &armcontainerservice.AgentPoolUpgradeProfileProperties{
// 		KubernetesVersion: to.Ptr("1.12.8"),
// 		LatestNodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		Upgrades: []*armcontainerservice.AgentPoolUpgradeProfilePropertiesUpgradesItem{
// 			{
// 				KubernetesVersion: to.Ptr("1.13.5"),
// 		}},
// 	},
// }

Output:

func (*AgentPoolsClient) NewListPager 

func (client *AgentPoolsClient) NewListPager(resourceGroupName string, resourceName string, options *AgentPoolsClientListOptions) *runtime.Pager[AgentPoolsClientListResponse]

NewListPager - Gets a list of agent pools in the specified managed cluster.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - AgentPoolsClientListOptions contains the optional parameters for the AgentPoolsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/AgentPoolsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewAgentPoolsClient().NewListPager("rg1", "clustername1", 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.AgentPoolListResult = armcontainerservice.AgentPoolListResult{
	// 	Value: []*armcontainerservice.AgentPool{
	// 		{
	// 			Name: to.Ptr("agentpool1"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/agentPools/agentpool1"),
	// 			Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
	// 				Count: to.Ptr[int32](3),
	// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
	// 				ETag: to.Ptr("ewnfuib"),
	// 				MaxPods: to.Ptr[int32](110),
	// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
	// 				OrchestratorVersion: to.Ptr("1.9.6"),
	// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				VMSize: to.Ptr("Standard_DS1_v2"),
	// 			},
	// 	}},
	// }
}

Output:

type AgentPoolsClientAbortLatestOperationResponse 

type AgentPoolsClientAbortLatestOperationResponse struct {
}

AgentPoolsClientAbortLatestOperationResponse contains the response from method AgentPoolsClient.BeginAbortLatestOperation.

type AgentPoolsClientBeginAbortLatestOperationOptions 

type AgentPoolsClientBeginAbortLatestOperationOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AgentPoolsClientBeginAbortLatestOperationOptions contains the optional parameters for the AgentPoolsClient.BeginAbortLatestOperation method.

type AgentPoolsClientBeginCreateOrUpdateOptions 

type AgentPoolsClientBeginCreateOrUpdateOptions struct {
	// The request should only proceed if an entity matches this string.
	IfMatch *string

	// The request should only proceed if no entity matches this string.
	IfNoneMatch *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

AgentPoolsClientBeginCreateOrUpdateOptions contains the optional parameters for the AgentPoolsClient.BeginCreateOrUpdate method.

type AgentPoolsClientBeginDeleteMachinesOptions added in v6.1.0 

type AgentPoolsClientBeginDeleteMachinesOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AgentPoolsClientBeginDeleteMachinesOptions contains the optional parameters for the AgentPoolsClient.BeginDeleteMachines method.

type AgentPoolsClientBeginDeleteOptions 

type AgentPoolsClientBeginDeleteOptions struct {
	// The request should only proceed if an entity matches this string.
	IfMatch *string

	// ignore-pod-disruption-budget=true to delete those pods on a node without considering Pod Disruption Budget
	IgnorePodDisruptionBudget *bool

	// Resumes the LRO from the provided token.
	ResumeToken string
}

AgentPoolsClientBeginDeleteOptions contains the optional parameters for the AgentPoolsClient.BeginDelete method.

type AgentPoolsClientBeginUpgradeNodeImageVersionOptions 

type AgentPoolsClientBeginUpgradeNodeImageVersionOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

AgentPoolsClientBeginUpgradeNodeImageVersionOptions contains the optional parameters for the AgentPoolsClient.BeginUpgradeNodeImageVersion method.

type AgentPoolsClientCreateOrUpdateResponse 

type AgentPoolsClientCreateOrUpdateResponse struct {
	// Agent Pool.
	AgentPool
}

AgentPoolsClientCreateOrUpdateResponse contains the response from method AgentPoolsClient.BeginCreateOrUpdate.

type AgentPoolsClientDeleteMachinesResponse added in v6.1.0 

type AgentPoolsClientDeleteMachinesResponse struct {
}

AgentPoolsClientDeleteMachinesResponse contains the response from method AgentPoolsClient.BeginDeleteMachines.

type AgentPoolsClientDeleteResponse 

type AgentPoolsClientDeleteResponse struct {
}

AgentPoolsClientDeleteResponse contains the response from method AgentPoolsClient.BeginDelete.

type AgentPoolsClientGetAvailableAgentPoolVersionsOptions 

type AgentPoolsClientGetAvailableAgentPoolVersionsOptions struct {
}

AgentPoolsClientGetAvailableAgentPoolVersionsOptions contains the optional parameters for the AgentPoolsClient.GetAvailableAgentPoolVersions method.

type AgentPoolsClientGetAvailableAgentPoolVersionsResponse 

type AgentPoolsClientGetAvailableAgentPoolVersionsResponse struct {
	// The list of available versions for an agent pool.
	AgentPoolAvailableVersions
}

AgentPoolsClientGetAvailableAgentPoolVersionsResponse contains the response from method AgentPoolsClient.GetAvailableAgentPoolVersions.

type AgentPoolsClientGetOptions 

type AgentPoolsClientGetOptions struct {
}

AgentPoolsClientGetOptions contains the optional parameters for the AgentPoolsClient.Get method.

type AgentPoolsClientGetResponse 

type AgentPoolsClientGetResponse struct {
	// Agent Pool.
	AgentPool
}

AgentPoolsClientGetResponse contains the response from method AgentPoolsClient.Get.

type AgentPoolsClientGetUpgradeProfileOptions 

type AgentPoolsClientGetUpgradeProfileOptions struct {
}

AgentPoolsClientGetUpgradeProfileOptions contains the optional parameters for the AgentPoolsClient.GetUpgradeProfile method.

type AgentPoolsClientGetUpgradeProfileResponse 

type AgentPoolsClientGetUpgradeProfileResponse struct {
	// The list of available upgrades for an agent pool.
	AgentPoolUpgradeProfile
}

AgentPoolsClientGetUpgradeProfileResponse contains the response from method AgentPoolsClient.GetUpgradeProfile.

type AgentPoolsClientListOptions 

type AgentPoolsClientListOptions struct {
}

AgentPoolsClientListOptions contains the optional parameters for the AgentPoolsClient.NewListPager method.

type AgentPoolsClientListResponse 

type AgentPoolsClientListResponse struct {
	// The response from the List Agent Pools operation.
	AgentPoolListResult
}

AgentPoolsClientListResponse contains the response from method AgentPoolsClient.NewListPager.

type AgentPoolsClientUpgradeNodeImageVersionResponse 

type AgentPoolsClientUpgradeNodeImageVersionResponse struct {
	// Agent Pool.
	AgentPool
}

AgentPoolsClientUpgradeNodeImageVersionResponse contains the response from method AgentPoolsClient.BeginUpgradeNodeImageVersion.

type AzureKeyVaultKms 

type AzureKeyVaultKms struct {
	// Whether to enable Azure Key Vault key management service. The default is false.
	Enabled *bool

	// Identifier of Azure Key Vault key. See key identifier format [https://docs.microsoft.com/en-us/azure/key-vault/general/about-keys-secrets-certificates#vault-name-and-object-name]
	// for more details.
	// When Azure Key Vault key management service is enabled, this field is required and must be a valid key identifier. When
	// Azure Key Vault key management service is disabled, leave the field empty.
	KeyID *string

	// Network access of key vault. The possible values are Public and Private. Public means the key vault allows public access
	// from all networks. Private means the key vault disables public access and
	// enables private link. The default value is Public.
	KeyVaultNetworkAccess *KeyVaultNetworkAccessTypes

	// Resource ID of key vault. When keyVaultNetworkAccess is Private, this field is required and must be a valid resource ID.
	// When keyVaultNetworkAccess is Public, leave the field empty.
	KeyVaultResourceID *string
}

AzureKeyVaultKms - Azure Key Vault key management service settings for the security profile.

func (AzureKeyVaultKms) MarshalJSON 

func (a AzureKeyVaultKms) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type AzureKeyVaultKms.

func (*AzureKeyVaultKms) UnmarshalJSON 

func (a *AzureKeyVaultKms) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type AzureKeyVaultKms.

type BackendPoolType 

type BackendPoolType string

BackendPoolType - The type of the managed inbound Load Balancer BackendPool. 

const (
	// BackendPoolTypeNodeIP - The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend.
	BackendPoolTypeNodeIP BackendPoolType = "NodeIP"
	// BackendPoolTypeNodeIPConfiguration - The type of the managed inbound Load Balancer BackendPool. https://cloud-provider-azure.sigs.k8s.io/topics/loadbalancer/#configure-load-balancer-backend.
	BackendPoolTypeNodeIPConfiguration BackendPoolType = "NodeIPConfiguration"
)

func PossibleBackendPoolTypeValues 

func PossibleBackendPoolTypeValues() []BackendPoolType

PossibleBackendPoolTypeValues returns the possible values for the BackendPoolType const type.

type ClientFactory 

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory 

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewAgentPoolsClient 

func (c *ClientFactory) NewAgentPoolsClient() *AgentPoolsClient

NewAgentPoolsClient creates a new instance of AgentPoolsClient.

func (*ClientFactory) NewMachinesClient added in v6.1.0 

func (c *ClientFactory) NewMachinesClient() *MachinesClient

NewMachinesClient creates a new instance of MachinesClient.

func (*ClientFactory) NewMaintenanceConfigurationsClient 

func (c *ClientFactory) NewMaintenanceConfigurationsClient() *MaintenanceConfigurationsClient

NewMaintenanceConfigurationsClient creates a new instance of MaintenanceConfigurationsClient.

func (*ClientFactory) NewManagedClustersClient 

func (c *ClientFactory) NewManagedClustersClient() *ManagedClustersClient

NewManagedClustersClient creates a new instance of ManagedClustersClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPrivateEndpointConnectionsClient 

func (c *ClientFactory) NewPrivateEndpointConnectionsClient() *PrivateEndpointConnectionsClient

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient.

func (*ClientFactory) NewPrivateLinkResourcesClient 

func (c *ClientFactory) NewPrivateLinkResourcesClient() *PrivateLinkResourcesClient

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient.

func (*ClientFactory) NewResolvePrivateLinkServiceIDClient 

func (c *ClientFactory) NewResolvePrivateLinkServiceIDClient() *ResolvePrivateLinkServiceIDClient

NewResolvePrivateLinkServiceIDClient creates a new instance of ResolvePrivateLinkServiceIDClient.

func (*ClientFactory) NewSnapshotsClient 

func (c *ClientFactory) NewSnapshotsClient() *SnapshotsClient

NewSnapshotsClient creates a new instance of SnapshotsClient.

func (*ClientFactory) NewTrustedAccessRoleBindingsClient 

func (c *ClientFactory) NewTrustedAccessRoleBindingsClient() *TrustedAccessRoleBindingsClient

NewTrustedAccessRoleBindingsClient creates a new instance of TrustedAccessRoleBindingsClient.

func (*ClientFactory) NewTrustedAccessRolesClient 

func (c *ClientFactory) NewTrustedAccessRolesClient() *TrustedAccessRolesClient

NewTrustedAccessRolesClient creates a new instance of TrustedAccessRolesClient.

type ClusterUpgradeSettings 

type ClusterUpgradeSettings struct {
	// Settings for overrides.
	OverrideSettings *UpgradeOverrideSettings
}

ClusterUpgradeSettings - Settings for upgrading a cluster.

func (ClusterUpgradeSettings) MarshalJSON 

func (c ClusterUpgradeSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ClusterUpgradeSettings.

func (*ClusterUpgradeSettings) UnmarshalJSON 

func (c *ClusterUpgradeSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterUpgradeSettings.

type Code 

type Code string

Code - Tells whether the cluster is Running or Stopped 

const (
	// CodeRunning - The cluster is running.
	CodeRunning Code = "Running"
	// CodeStopped - The cluster is stopped.
	CodeStopped Code = "Stopped"
)

func PossibleCodeValues 

func PossibleCodeValues() []Code

PossibleCodeValues returns the possible values for the Code const type.

type CommandResultProperties 

type CommandResultProperties struct {
	// READ-ONLY; The exit code of the command
	ExitCode *int32

	// READ-ONLY; The time when the command finished.
	FinishedAt *time.Time

	// READ-ONLY; The command output.
	Logs *string

	// READ-ONLY; provisioning State
	ProvisioningState *string

	// READ-ONLY; An explanation of why provisioningState is set to failed (if so).
	Reason *string

	// READ-ONLY; The time when the command started.
	StartedAt *time.Time
}

CommandResultProperties - The results of a run command

func (CommandResultProperties) MarshalJSON 

func (c CommandResultProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CommandResultProperties.

func (*CommandResultProperties) UnmarshalJSON 

func (c *CommandResultProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CommandResultProperties.

type CompatibleVersions 

type CompatibleVersions struct {
	// The product/service name.
	Name *string

	// Product/service versions compatible with a service mesh add-on revision.
	Versions []*string
}

CompatibleVersions - Version information about a product/service that is compatible with a service mesh revision.

func (CompatibleVersions) MarshalJSON 

func (c CompatibleVersions) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CompatibleVersions.

func (*CompatibleVersions) UnmarshalJSON 

func (c *CompatibleVersions) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CompatibleVersions.

type ConnectionStatus 

type ConnectionStatus string

ConnectionStatus - The private link service connection status. 

const (
	ConnectionStatusApproved     ConnectionStatus = "Approved"
	ConnectionStatusDisconnected ConnectionStatus = "Disconnected"
	ConnectionStatusPending      ConnectionStatus = "Pending"
	ConnectionStatusRejected     ConnectionStatus = "Rejected"
)

func PossibleConnectionStatusValues 

func PossibleConnectionStatusValues() []ConnectionStatus

PossibleConnectionStatusValues returns the possible values for the ConnectionStatus const type.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type CreationData 

type CreationData struct {
	// This is the ARM ID of the source object to be used to create the target object.
	SourceResourceID *string
}

CreationData - Data used when creating a target resource from a source resource.

func (CreationData) MarshalJSON 

func (c CreationData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CreationData.

func (*CreationData) UnmarshalJSON 

func (c *CreationData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CreationData.

type CredentialResult 

type CredentialResult struct {
	// READ-ONLY; The name of the credential.
	Name *string

	// READ-ONLY; Base64-encoded Kubernetes configuration file.
	Value []byte
}

CredentialResult - The credential result response.

func (CredentialResult) MarshalJSON 

func (c CredentialResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CredentialResult.

func (*CredentialResult) UnmarshalJSON 

func (c *CredentialResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CredentialResult.

type CredentialResults 

type CredentialResults struct {
	// READ-ONLY; Base64-encoded Kubernetes configuration file.
	Kubeconfigs []*CredentialResult
}

CredentialResults - The list credential result response.

func (CredentialResults) MarshalJSON 

func (c CredentialResults) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type CredentialResults.

func (*CredentialResults) UnmarshalJSON 

func (c *CredentialResults) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type CredentialResults.

type DailySchedule 

type DailySchedule struct {
	// REQUIRED; Specifies the number of days between each set of occurrences.
	IntervalDays *int32
}

DailySchedule - For schedules like: 'recur every day' or 'recur every 3 days'.

func (DailySchedule) MarshalJSON 

func (d DailySchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DailySchedule.

func (*DailySchedule) UnmarshalJSON 

func (d *DailySchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DailySchedule.

type DateSpan 

type DateSpan struct {
	// REQUIRED; The end date of the date span.
	End *time.Time

	// REQUIRED; The start date of the date span.
	Start *time.Time
}

DateSpan - For example, between '2022-12-23' and '2023-01-05'.

func (DateSpan) MarshalJSON 

func (d DateSpan) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DateSpan.

func (*DateSpan) UnmarshalJSON 

func (d *DateSpan) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DateSpan.

type DelegatedResource 

type DelegatedResource struct {
	// The source resource location - internal use only.
	Location *string

	// The delegation id of the referral delegation (optional) - internal use only.
	ReferralResource *string

	// The ARM resource id of the delegated resource - internal use only.
	ResourceID *string

	// The tenant id of the delegated resource - internal use only.
	TenantID *string
}

DelegatedResource - Delegated resource properties - internal use only.

func (DelegatedResource) MarshalJSON 

func (d DelegatedResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type DelegatedResource.

func (*DelegatedResource) UnmarshalJSON 

func (d *DelegatedResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type DelegatedResource.

type EndpointDependency 

type EndpointDependency struct {
	// The domain name of the dependency.
	DomainName *string

	// The Ports and Protocols used when connecting to domainName.
	EndpointDetails []*EndpointDetail
}

EndpointDependency - A domain name that AKS agent nodes are reaching at.

func (EndpointDependency) MarshalJSON 

func (e EndpointDependency) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointDependency.

func (*EndpointDependency) UnmarshalJSON 

func (e *EndpointDependency) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointDependency.

type EndpointDetail 

type EndpointDetail struct {
	// Description of the detail
	Description *string

	// An IP Address that Domain Name currently resolves to.
	IPAddress *string

	// The port an endpoint is connected to.
	Port *int32

	// The protocol used for connection
	Protocol *string
}

EndpointDetail - connect information from the AKS agent nodes to a single endpoint.

func (EndpointDetail) MarshalJSON 

func (e EndpointDetail) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EndpointDetail.

func (*EndpointDetail) UnmarshalJSON 

func (e *EndpointDetail) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EndpointDetail.

type Expander 

type Expander string

Expander - If not specified, the default is 'random'. See expanders [https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders] for more information. 

const (
	// ExpanderLeastWaste - Selects the node group that will have the least idle CPU (if tied, unused memory) after scale-up.
	// This is useful when you have different classes of nodes, for example, high CPU or high memory nodes, and only want to expand
	// those when there are pending pods that need a lot of those resources.
	ExpanderLeastWaste Expander = "least-waste"
	// ExpanderMostPods - Selects the node group that would be able to schedule the most pods when scaling up. This is useful
	// when you are using nodeSelector to make sure certain pods land on certain nodes. Note that this won't cause the autoscaler
	// to select bigger nodes vs. smaller, as it can add multiple smaller nodes at once.
	ExpanderMostPods Expander = "most-pods"
	// ExpanderPriority - Selects the node group that has the highest priority assigned by the user. It's configuration is described
	// in more details [here](https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/expander/priority/readme.md).
	ExpanderPriority Expander = "priority"
	// ExpanderRandom - Used when you don't have a particular need for the node groups to scale differently.
	ExpanderRandom Expander = "random"
)

func PossibleExpanderValues 

func PossibleExpanderValues() []Expander

PossibleExpanderValues returns the possible values for the Expander const type.

type ExtendedLocation 

type ExtendedLocation struct {
	// The name of the extended location.
	Name *string

	// The type of the extended location.
	Type *ExtendedLocationTypes
}

ExtendedLocation - The complex type of the extended location.

func (ExtendedLocation) MarshalJSON 

func (e ExtendedLocation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ExtendedLocation.

func (*ExtendedLocation) UnmarshalJSON 

func (e *ExtendedLocation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ExtendedLocation.

type ExtendedLocationTypes 

type ExtendedLocationTypes string

ExtendedLocationTypes - The type of extendedLocation. 

const (
	ExtendedLocationTypesEdgeZone ExtendedLocationTypes = "EdgeZone"
)

func PossibleExtendedLocationTypesValues 

func PossibleExtendedLocationTypesValues() []ExtendedLocationTypes

PossibleExtendedLocationTypesValues returns the possible values for the ExtendedLocationTypes const type.

type Format 

type Format string
const (
	// FormatAzure - Return azure auth-provider kubeconfig. This format is deprecated in v1.22 and will be fully removed in v1.26.
	// See: https://aka.ms/k8s/changes-1-26.
	FormatAzure Format = "azure"
	// FormatExec - Return exec format kubeconfig. This format requires kubelogin binary in the path.
	FormatExec Format = "exec"
)

func PossibleFormatValues 

func PossibleFormatValues() []Format

PossibleFormatValues returns the possible values for the Format const type.

type GPUInstanceProfile 

type GPUInstanceProfile string

GPUInstanceProfile - GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU. 

const (
	GPUInstanceProfileMIG1G GPUInstanceProfile = "MIG1g"
	GPUInstanceProfileMIG2G GPUInstanceProfile = "MIG2g"
	GPUInstanceProfileMIG3G GPUInstanceProfile = "MIG3g"
	GPUInstanceProfileMIG4G GPUInstanceProfile = "MIG4g"
	GPUInstanceProfileMIG7G GPUInstanceProfile = "MIG7g"
)

func PossibleGPUInstanceProfileValues 

func PossibleGPUInstanceProfileValues() []GPUInstanceProfile

PossibleGPUInstanceProfileValues returns the possible values for the GPUInstanceProfile const type.

type IPFamily 

type IPFamily string

IPFamily - The IP version to use for cluster networking and IP assignment. 

const (
	IPFamilyIPv4 IPFamily = "IPv4"
	IPFamilyIPv6 IPFamily = "IPv6"
)

func PossibleIPFamilyValues 

func PossibleIPFamilyValues() []IPFamily

PossibleIPFamilyValues returns the possible values for the IPFamily const type.

type IPTag 

type IPTag struct {
	// The IP tag type. Example: RoutingPreference.
	IPTagType *string

	// The value of the IP tag associated with the public IP. Example: Internet.
	Tag *string
}

IPTag - Contains the IPTag associated with the object.

func (IPTag) MarshalJSON 

func (i IPTag) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IPTag.

func (*IPTag) UnmarshalJSON 

func (i *IPTag) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IPTag.

type IstioCertificateAuthority 

type IstioCertificateAuthority struct {
	// Plugin certificates information for Service Mesh.
	Plugin *IstioPluginCertificateAuthority
}

IstioCertificateAuthority - Istio Service Mesh Certificate Authority (CA) configuration. For now, we only support plugin certificates as described here https://aka.ms/asm-plugin-ca

func (IstioCertificateAuthority) MarshalJSON 

func (i IstioCertificateAuthority) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioCertificateAuthority.

func (*IstioCertificateAuthority) UnmarshalJSON 

func (i *IstioCertificateAuthority) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioCertificateAuthority.

type IstioComponents 

type IstioComponents struct {
	// Istio egress gateways.
	EgressGateways []*IstioEgressGateway

	// Istio ingress gateways.
	IngressGateways []*IstioIngressGateway
}

IstioComponents - Istio components configuration.

func (IstioComponents) MarshalJSON 

func (i IstioComponents) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioComponents.

func (*IstioComponents) UnmarshalJSON 

func (i *IstioComponents) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioComponents.

type IstioEgressGateway 

type IstioEgressGateway struct {
	// REQUIRED; Whether to enable the egress gateway.
	Enabled *bool
}

IstioEgressGateway - Istio egress gateway configuration.

func (IstioEgressGateway) MarshalJSON 

func (i IstioEgressGateway) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioEgressGateway.

func (*IstioEgressGateway) UnmarshalJSON 

func (i *IstioEgressGateway) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioEgressGateway.

type IstioIngressGateway 

type IstioIngressGateway struct {
	// REQUIRED; Whether to enable the ingress gateway.
	Enabled *bool

	// REQUIRED; Mode of an ingress gateway.
	Mode *IstioIngressGatewayMode
}

IstioIngressGateway - Istio ingress gateway configuration. For now, we support up to one external ingress gateway named aks-istio-ingressgateway-external and one internal ingress gateway named aks-istio-ingressgateway-internal.

func (IstioIngressGateway) MarshalJSON 

func (i IstioIngressGateway) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioIngressGateway.

func (*IstioIngressGateway) UnmarshalJSON 

func (i *IstioIngressGateway) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioIngressGateway.

type IstioIngressGatewayMode 

type IstioIngressGatewayMode string

IstioIngressGatewayMode - Mode of an ingress gateway. 

const (
	// IstioIngressGatewayModeExternal - The ingress gateway is assigned a public IP address and is publicly accessible.
	IstioIngressGatewayModeExternal IstioIngressGatewayMode = "External"
	// IstioIngressGatewayModeInternal - The ingress gateway is assigned an internal IP address and cannot is accessed publicly.
	IstioIngressGatewayModeInternal IstioIngressGatewayMode = "Internal"
)

func PossibleIstioIngressGatewayModeValues 

func PossibleIstioIngressGatewayModeValues() []IstioIngressGatewayMode

PossibleIstioIngressGatewayModeValues returns the possible values for the IstioIngressGatewayMode const type.

type IstioPluginCertificateAuthority 

type IstioPluginCertificateAuthority struct {
	// Certificate chain object name in Azure Key Vault.
	CertChainObjectName *string

	// Intermediate certificate object name in Azure Key Vault.
	CertObjectName *string

	// Intermediate certificate private key object name in Azure Key Vault.
	KeyObjectName *string

	// The resource ID of the Key Vault.
	KeyVaultID *string

	// Root certificate object name in Azure Key Vault.
	RootCertObjectName *string
}

IstioPluginCertificateAuthority - Plugin certificates information for Service Mesh.

func (IstioPluginCertificateAuthority) MarshalJSON 

func (i IstioPluginCertificateAuthority) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioPluginCertificateAuthority.

func (*IstioPluginCertificateAuthority) UnmarshalJSON 

func (i *IstioPluginCertificateAuthority) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioPluginCertificateAuthority.

type IstioServiceMesh 

type IstioServiceMesh struct {
	// Istio Service Mesh Certificate Authority (CA) configuration. For now, we only support plugin certificates as described
	// here https://aka.ms/asm-plugin-ca
	CertificateAuthority *IstioCertificateAuthority

	// Istio components configuration.
	Components *IstioComponents

	// The list of revisions of the Istio control plane. When an upgrade is not in progress, this holds one value. When canary
	// upgrade is in progress, this can only hold two consecutive values. For more
	// information, see: https://learn.microsoft.com/en-us/azure/aks/istio-upgrade
	Revisions []*string
}

IstioServiceMesh - Istio service mesh configuration.

func (IstioServiceMesh) MarshalJSON 

func (i IstioServiceMesh) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IstioServiceMesh.

func (*IstioServiceMesh) UnmarshalJSON 

func (i *IstioServiceMesh) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IstioServiceMesh.

type KeyVaultNetworkAccessTypes 

type KeyVaultNetworkAccessTypes string

KeyVaultNetworkAccessTypes - Network access of key vault. The possible values are Public and Private. Public means the key vault allows public access from all networks. Private means the key vault disables public access and enables private link. The default value is Public. 

const (
	KeyVaultNetworkAccessTypesPrivate KeyVaultNetworkAccessTypes = "Private"
	KeyVaultNetworkAccessTypesPublic  KeyVaultNetworkAccessTypes = "Public"
)

func PossibleKeyVaultNetworkAccessTypesValues 

func PossibleKeyVaultNetworkAccessTypesValues() []KeyVaultNetworkAccessTypes

PossibleKeyVaultNetworkAccessTypesValues returns the possible values for the KeyVaultNetworkAccessTypes const type.

type KubeletConfig 

type KubeletConfig struct {
	// Allowed list of unsafe sysctls or unsafe sysctl patterns (ending in *).
	AllowedUnsafeSysctls []*string

	// The default is true.
	CPUCfsQuota *bool

	// The default is '100ms.' Valid values are a sequence of decimal numbers with an optional fraction and a unit suffix. For
	// example: '300ms', '2h45m'. Supported units are 'ns', 'us', 'ms', 's', 'm', and
	// 'h'.
	CPUCfsQuotaPeriod *string

	// The default is 'none'. See Kubernetes CPU management policies [https://kubernetes.io/docs/tasks/administer-cluster/cpu-management-policies/#cpu-management-policies]
	// for more information. Allowed
	// values are 'none' and 'static'.
	CPUManagerPolicy *string

	// The maximum number of container log files that can be present for a container. The number must be ≥ 2.
	ContainerLogMaxFiles *int32

	// The maximum size (e.g. 10Mi) of container log file before it is rotated.
	ContainerLogMaxSizeMB *int32

	// If set to true it will make the Kubelet fail to start if swap is enabled on the node.
	FailSwapOn *bool

	// To disable image garbage collection, set to 100. The default is 85%
	ImageGcHighThreshold *int32

	// This cannot be set higher than imageGcHighThreshold. The default is 80%
	ImageGcLowThreshold *int32

	// The maximum number of processes per pod.
	PodMaxPids *int32

	// For more information see Kubernetes Topology Manager [https://kubernetes.io/docs/tasks/administer-cluster/topology-manager].
	// The default is 'none'. Allowed values are 'none', 'best-effort',
	// 'restricted', and 'single-numa-node'.
	TopologyManagerPolicy *string
}

KubeletConfig - See AKS custom node configuration [https://docs.microsoft.com/azure/aks/custom-node-configuration] for more details.

func (KubeletConfig) MarshalJSON 

func (k KubeletConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KubeletConfig.

func (*KubeletConfig) UnmarshalJSON 

func (k *KubeletConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KubeletConfig.

type KubeletDiskType 

type KubeletDiskType string

KubeletDiskType - Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage. 

const (
	// KubeletDiskTypeOS - Kubelet will use the OS disk for its data.
	KubeletDiskTypeOS KubeletDiskType = "OS"
	// KubeletDiskTypeTemporary - Kubelet will use the temporary disk for its data.
	KubeletDiskTypeTemporary KubeletDiskType = "Temporary"
)

func PossibleKubeletDiskTypeValues 

func PossibleKubeletDiskTypeValues() []KubeletDiskType

PossibleKubeletDiskTypeValues returns the possible values for the KubeletDiskType const type.

type KubernetesPatchVersion 

type KubernetesPatchVersion struct {
	// Possible upgrade path for given patch version
	Upgrades []*string
}

KubernetesPatchVersion - Kubernetes patch version profile

func (KubernetesPatchVersion) MarshalJSON 

func (k KubernetesPatchVersion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KubernetesPatchVersion.

func (*KubernetesPatchVersion) UnmarshalJSON 

func (k *KubernetesPatchVersion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesPatchVersion.

type KubernetesSupportPlan 

type KubernetesSupportPlan string

KubernetesSupportPlan - Different support tiers for AKS managed clusters 

const (
	// KubernetesSupportPlanAKSLongTermSupport - Support for the version extended past the KubernetesOfficial support of 1 year.
	// AKS continues to patch CVEs for another 1 year, for a total of 2 years of support.
	KubernetesSupportPlanAKSLongTermSupport KubernetesSupportPlan = "AKSLongTermSupport"
	// KubernetesSupportPlanKubernetesOfficial - Support for the version is the same as for the open source Kubernetes offering.
	// Official Kubernetes open source community support versions for 1 year after release.
	KubernetesSupportPlanKubernetesOfficial KubernetesSupportPlan = "KubernetesOfficial"
)

func PossibleKubernetesSupportPlanValues 

func PossibleKubernetesSupportPlanValues() []KubernetesSupportPlan

PossibleKubernetesSupportPlanValues returns the possible values for the KubernetesSupportPlan const type.

type KubernetesVersion 

type KubernetesVersion struct {
	// Capabilities on this Kubernetes version.
	Capabilities *KubernetesVersionCapabilities

	// Whether this version is default.
	IsDefault *bool

	// Whether this version is in preview mode.
	IsPreview *bool

	// Patch versions of Kubernetes release
	PatchVersions map[string]*KubernetesPatchVersion

	// major.minor version of Kubernetes release
	Version *string
}

KubernetesVersion - Kubernetes version profile for given major.minor release.

func (KubernetesVersion) MarshalJSON 

func (k KubernetesVersion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KubernetesVersion.

func (*KubernetesVersion) UnmarshalJSON 

func (k *KubernetesVersion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesVersion.

type KubernetesVersionCapabilities 

type KubernetesVersionCapabilities struct {
	SupportPlan []*KubernetesSupportPlan
}

KubernetesVersionCapabilities - Capabilities on this Kubernetes version.

func (KubernetesVersionCapabilities) MarshalJSON 

func (k KubernetesVersionCapabilities) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KubernetesVersionCapabilities.

func (*KubernetesVersionCapabilities) UnmarshalJSON 

func (k *KubernetesVersionCapabilities) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesVersionCapabilities.

type KubernetesVersionListResult 

type KubernetesVersionListResult struct {
	// Array of AKS supported Kubernetes versions.
	Values []*KubernetesVersion
}

KubernetesVersionListResult - Hold values properties, which is array of KubernetesVersion

func (KubernetesVersionListResult) MarshalJSON 

func (k KubernetesVersionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type KubernetesVersionListResult.

func (*KubernetesVersionListResult) UnmarshalJSON 

func (k *KubernetesVersionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type KubernetesVersionListResult.

type LicenseType 

type LicenseType string

LicenseType - The license type to use for Windows VMs. See Azure Hybrid User Benefits [https://azure.microsoft.com/pricing/hybrid-benefit/faq/] for more details. 

const (
	// LicenseTypeNone - No additional licensing is applied.
	LicenseTypeNone LicenseType = "None"
	// LicenseTypeWindowsServer - Enables Azure Hybrid User Benefits for Windows VMs.
	LicenseTypeWindowsServer LicenseType = "Windows_Server"
)

func PossibleLicenseTypeValues 

func PossibleLicenseTypeValues() []LicenseType

PossibleLicenseTypeValues returns the possible values for the LicenseType const type.

type LinuxOSConfig 

type LinuxOSConfig struct {
	// The size in MB of a swap file that will be created on each node.
	SwapFileSizeMB *int32

	// Sysctl settings for Linux agent nodes.
	Sysctls *SysctlConfig

	// Valid values are 'always', 'defer', 'defer+madvise', 'madvise' and 'never'. The default is 'madvise'. For more information
	// see Transparent Hugepages
	// [https://www.kernel.org/doc/html/latest/admin-guide/mm/transhuge.html#admin-guide-transhuge].
	TransparentHugePageDefrag *string

	// Valid values are 'always', 'madvise', and 'never'. The default is 'always'. For more information see Transparent Hugepages
	// [https://www.kernel.org/doc/html/latest/admin-guide/mm/transhuge.html#admin-guide-transhuge].
	TransparentHugePageEnabled *string
}

LinuxOSConfig - See AKS custom node configuration [https://docs.microsoft.com/azure/aks/custom-node-configuration] for more details.

func (LinuxOSConfig) MarshalJSON 

func (l LinuxOSConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinuxOSConfig.

func (*LinuxOSConfig) UnmarshalJSON 

func (l *LinuxOSConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinuxOSConfig.

type LinuxProfile 

type LinuxProfile struct {
	// REQUIRED; The administrator username to use for Linux VMs.
	AdminUsername *string

	// REQUIRED; The SSH configuration for Linux-based VMs running on Azure.
	SSH *SSHConfiguration
}

LinuxProfile - Profile for Linux VMs in the container service cluster.

func (LinuxProfile) MarshalJSON 

func (l LinuxProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LinuxProfile.

func (*LinuxProfile) UnmarshalJSON 

func (l *LinuxProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LinuxProfile.

type LoadBalancerSKU 

type LoadBalancerSKU string

LoadBalancerSKU - The default is 'standard'. See Azure Load Balancer SKUs [https://docs.microsoft.com/azure/load-balancer/skus] for more information about the differences between load balancer SKUs. 

const (
	// LoadBalancerSKUBasic - Use a basic Load Balancer with limited functionality.
	LoadBalancerSKUBasic LoadBalancerSKU = "basic"
	// LoadBalancerSKUStandard - Use a a standard Load Balancer. This is the recommended Load Balancer SKU. For more information
	// about on working with the load balancer in the managed cluster, see the [standard Load Balancer](https://docs.microsoft.com/azure/aks/load-balancer-standard)
	// article.
	LoadBalancerSKUStandard LoadBalancerSKU = "standard"
)

func PossibleLoadBalancerSKUValues 

func PossibleLoadBalancerSKUValues() []LoadBalancerSKU

PossibleLoadBalancerSKUValues returns the possible values for the LoadBalancerSKU const type.

type Machine added in v6.1.0 

type Machine struct {
	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; The name of the resource that is unique within a resource group. This name can be used to access the resource.
	Name *string

	// READ-ONLY; The properties of the machine
	Properties *MachineProperties

	// READ-ONLY; Resource type
	Type *string
}

Machine - A machine. Contains details about the underlying virtual machine. A machine may be visible here but not in kubectl get nodes; if so it may be because the machine has not been registered with the Kubernetes API Server yet.

func (Machine) MarshalJSON added in v6.1.0 

func (m Machine) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Machine.

func (*Machine) UnmarshalJSON added in v6.1.0 

func (m *Machine) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Machine.

type MachineIPAddress added in v6.1.0 

type MachineIPAddress struct {
	// READ-ONLY; To determine if address belongs IPv4 or IPv6 family
	Family *IPFamily

	// READ-ONLY; IPv4 or IPv6 address of the machine
	IP *string
}

MachineIPAddress - The machine IP address details.

func (MachineIPAddress) MarshalJSON added in v6.1.0 

func (m MachineIPAddress) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MachineIPAddress.

func (*MachineIPAddress) UnmarshalJSON added in v6.1.0 

func (m *MachineIPAddress) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MachineIPAddress.

type MachineListResult added in v6.1.0 

type MachineListResult struct {
	// The list of Machines in cluster.
	Value []*Machine

	// READ-ONLY; The URL to get the next set of machine results.
	NextLink *string
}

MachineListResult - The response from the List Machines operation.

func (MachineListResult) MarshalJSON added in v6.1.0 

func (m MachineListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MachineListResult.

func (*MachineListResult) UnmarshalJSON added in v6.1.0 

func (m *MachineListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MachineListResult.

type MachineNetworkProperties added in v6.1.0 

type MachineNetworkProperties struct {
	// READ-ONLY; IPv4, IPv6 addresses of the machine
	IPAddresses []*MachineIPAddress
}

MachineNetworkProperties - network properties of the machine

func (MachineNetworkProperties) MarshalJSON added in v6.1.0 

func (m MachineNetworkProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MachineNetworkProperties.

func (*MachineNetworkProperties) UnmarshalJSON added in v6.1.0 

func (m *MachineNetworkProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MachineNetworkProperties.

type MachineProperties added in v6.1.0 

type MachineProperties struct {
	// READ-ONLY; network properties of the machine
	Network *MachineNetworkProperties

	// READ-ONLY; Azure resource id of the machine. It can be used to GET underlying VM Instance
	ResourceID *string
}

MachineProperties - The properties of the machine

func (MachineProperties) MarshalJSON added in v6.1.0 

func (m MachineProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MachineProperties.

func (*MachineProperties) UnmarshalJSON added in v6.1.0 

func (m *MachineProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MachineProperties.

type MachinesClient added in v6.1.0 

type MachinesClient struct {
	// contains filtered or unexported fields
}

MachinesClient contains the methods for the Machines group. Don't use this type directly, use NewMachinesClient() instead.

func NewMachinesClient added in v6.1.0 

func NewMachinesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MachinesClient, error)

NewMachinesClient creates a new instance of MachinesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MachinesClient) Get added in v6.1.0 

func (client *MachinesClient) Get(ctx context.Context, resourceGroupName string, resourceName string, agentPoolName string, machineName string, options *MachinesClientGetOptions) (MachinesClientGetResponse, error)

Get - Get a specific machine in the specified agent pool. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • machineName - host name of the machine
  • options - MachinesClientGetOptions contains the optional parameters for the MachinesClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MachineGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMachinesClient().Get(ctx, "rg1", "clustername1", "agentpool1", "aks-nodepool1-42263519-vmss00000t", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.Machine = armcontainerservice.Machine{
// 	Name: to.Ptr("aks-nodepool1-25481572-vmss000000"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/machines"),
// 	ID: to.Ptr("/subscriptions/26fe00f8-9173-4872-9134-bb1d2e00343a/resourceGroups/dummyRG/providers/Microsoft.ContainerService/managedClusters/round/agentPools/nodepool1/machines/aks-nodepool1-25481572-vmss000000"),
// 	Properties: &armcontainerservice.MachineProperties{
// 		Network: &armcontainerservice.MachineNetworkProperties{
// 			IPAddresses: []*armcontainerservice.MachineIPAddress{
// 				{
// 					Family: to.Ptr(armcontainerservice.IPFamilyIPv4),
// 					IP: to.Ptr("172.20.2.4"),
// 				},
// 				{
// 					Family: to.Ptr(armcontainerservice.IPFamilyIPv4),
// 					IP: to.Ptr("10.0.0.1"),
// 			}},
// 		},
// 		ResourceID: to.Ptr("/subscriptions/26fe00f8-9173-4872-9134-bb1d2e00343a/resourceGroups/dummyRG/providers/Microsoft.Compute/virtualMachineScaleSets/aks-nodepool1-25481572-vmss/virtualMachines/0"),
// 	},
// }

Output:

func (*MachinesClient) NewListPager added in v6.1.0 

func (client *MachinesClient) NewListPager(resourceGroupName string, resourceName string, agentPoolName string, options *MachinesClientListOptions) *runtime.Pager[MachinesClientListResponse]

NewListPager - Gets a list of machines in the specified agent pool.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • agentPoolName - The name of the agent pool.
  • options - MachinesClientListOptions contains the optional parameters for the MachinesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MachineList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMachinesClient().NewListPager("rg1", "clustername1", "agentpool1", 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.MachineListResult = armcontainerservice.MachineListResult{
	// 	Value: []*armcontainerservice.Machine{
	// 		{
	// 			Name: to.Ptr("aks-nodepool1-25481572-vmss000000"),
	// 			Type: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/machines"),
	// 			ID: to.Ptr("/subscriptions/26fe00f8-9173-4872-9134-bb1d2e00343a/resourceGroups/dummyRG/providers/Microsoft.ContainerService/managedClusters/round/agentPools/nodepool1/machines/aks-nodepool1-25481572-vmss000000"),
	// 			Properties: &armcontainerservice.MachineProperties{
	// 				Network: &armcontainerservice.MachineNetworkProperties{
	// 					IPAddresses: []*armcontainerservice.MachineIPAddress{
	// 						{
	// 							Family: to.Ptr(armcontainerservice.IPFamilyIPv4),
	// 							IP: to.Ptr("172.20.2.4"),
	// 						},
	// 						{
	// 							Family: to.Ptr(armcontainerservice.IPFamilyIPv4),
	// 							IP: to.Ptr("10.0.0.1"),
	// 					}},
	// 				},
	// 				ResourceID: to.Ptr("/subscriptions/26fe00f8-9173-4872-9134-bb1d2e00343a/resourceGroups/dummyRG/providers/Microsoft.Compute/virtualMachineScaleSets/aks-nodepool1-25481572-vmss/virtualMachines/0"),
	// 			},
	// 	}},
	// }
}

Output:

type MachinesClientGetOptions added in v6.1.0 

type MachinesClientGetOptions struct {
}

MachinesClientGetOptions contains the optional parameters for the MachinesClient.Get method.

type MachinesClientGetResponse added in v6.1.0 

type MachinesClientGetResponse struct {
	// A machine. Contains details about the underlying virtual machine. A machine may be visible here but not in kubectl get
	// nodes; if so it may be because the machine has not been registered with the Kubernetes API Server yet.
	Machine
}

MachinesClientGetResponse contains the response from method MachinesClient.Get.

type MachinesClientListOptions added in v6.1.0 

type MachinesClientListOptions struct {
}

MachinesClientListOptions contains the optional parameters for the MachinesClient.NewListPager method.

type MachinesClientListResponse added in v6.1.0 

type MachinesClientListResponse struct {
	// The response from the List Machines operation.
	MachineListResult
}

MachinesClientListResponse contains the response from method MachinesClient.NewListPager.

type MaintenanceConfiguration 

type MaintenanceConfiguration struct {
	// Properties of a default maintenance configuration.
	Properties *MaintenanceConfigurationProperties

	// READ-ONLY; Resource ID.
	ID *string

	// READ-ONLY; The name of the resource that is unique within a resource group. This name can be used to access the resource.
	Name *string

	// READ-ONLY; The system metadata relating to this resource.
	SystemData *SystemData

	// READ-ONLY; Resource type
	Type *string
}

MaintenanceConfiguration - See planned maintenance [https://docs.microsoft.com/azure/aks/planned-maintenance] for more information about planned maintenance.

func (MaintenanceConfiguration) MarshalJSON 

func (m MaintenanceConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceConfiguration.

func (*MaintenanceConfiguration) UnmarshalJSON 

func (m *MaintenanceConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceConfiguration.

type MaintenanceConfigurationListResult 

type MaintenanceConfigurationListResult struct {
	// The list of maintenance configurations.
	Value []*MaintenanceConfiguration

	// READ-ONLY; The URL to get the next set of maintenance configuration results.
	NextLink *string
}

MaintenanceConfigurationListResult - The response from the List maintenance configurations operation.

func (MaintenanceConfigurationListResult) MarshalJSON 

func (m MaintenanceConfigurationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceConfigurationListResult.

func (*MaintenanceConfigurationListResult) UnmarshalJSON 

func (m *MaintenanceConfigurationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceConfigurationListResult.

type MaintenanceConfigurationProperties 

type MaintenanceConfigurationProperties struct {
	// Maintenance window for the maintenance configuration.
	MaintenanceWindow *MaintenanceWindow

	// Time slots on which upgrade is not allowed.
	NotAllowedTime []*TimeSpan

	// If two array entries specify the same day of the week, the applied configuration is the union of times in both entries.
	TimeInWeek []*TimeInWeek
}

MaintenanceConfigurationProperties - Properties used to configure planned maintenance for a Managed Cluster.

func (MaintenanceConfigurationProperties) MarshalJSON 

func (m MaintenanceConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceConfigurationProperties.

func (*MaintenanceConfigurationProperties) UnmarshalJSON 

func (m *MaintenanceConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceConfigurationProperties.

type MaintenanceConfigurationsClient 

type MaintenanceConfigurationsClient struct {
	// contains filtered or unexported fields
}

MaintenanceConfigurationsClient contains the methods for the MaintenanceConfigurations group. Don't use this type directly, use NewMaintenanceConfigurationsClient() instead.

func NewMaintenanceConfigurationsClient 

func NewMaintenanceConfigurationsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*MaintenanceConfigurationsClient, error)

NewMaintenanceConfigurationsClient creates a new instance of MaintenanceConfigurationsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*MaintenanceConfigurationsClient) CreateOrUpdate 

func (client *MaintenanceConfigurationsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, configName string, parameters MaintenanceConfiguration, options *MaintenanceConfigurationsClientCreateOrUpdateOptions) (MaintenanceConfigurationsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates a maintenance configuration in the specified managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • configName - The name of the maintenance configuration.
  • parameters - The maintenance configuration to create or update.
  • options - MaintenanceConfigurationsClientCreateOrUpdateOptions contains the optional parameters for the MaintenanceConfigurationsClient.CreateOrUpdate method.
Example (CreateUpdateMaintenanceConfiguration)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsCreate_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMaintenanceConfigurationsClient().CreateOrUpdate(ctx, "rg1", "clustername1", "default", armcontainerservice.MaintenanceConfiguration{
	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
		NotAllowedTime: []*armcontainerservice.TimeSpan{
			{
				End:   to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-30T12:00:00.000Z"); return t }()),
				Start: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-26T03:00:00.000Z"); return t }()),
			}},
		TimeInWeek: []*armcontainerservice.TimeInWeek{
			{
				Day: to.Ptr(armcontainerservice.WeekDayMonday),
				HourSlots: []*int32{
					to.Ptr[int32](1),
					to.Ptr[int32](2)},
			}},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MaintenanceConfiguration = armcontainerservice.MaintenanceConfiguration{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/maintenanceConfigurations"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/default"),
// 	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
// 		NotAllowedTime: []*armcontainerservice.TimeSpan{
// 			{
// 				End: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-30T12:00:00.000Z"); return t}()),
// 				Start: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-26T03:00:00.000Z"); return t}()),
// 		}},
// 		TimeInWeek: []*armcontainerservice.TimeInWeek{
// 			{
// 				Day: to.Ptr(armcontainerservice.WeekDayMonday),
// 				HourSlots: []*int32{
// 					to.Ptr[int32](1),
// 					to.Ptr[int32](2)},
// 			}},
// 		},
// 		SystemData: &armcontainerservice.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 			CreatedBy: to.Ptr("user1"),
// 			CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
// 			LastModifiedBy: to.Ptr("user2"),
// 			LastModifiedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (CreateUpdateMaintenanceConfigurationWithMaintenanceWindow)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsCreate_Update_MaintenanceWindow.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMaintenanceConfigurationsClient().CreateOrUpdate(ctx, "rg1", "clustername1", "aksManagedAutoUpgradeSchedule", armcontainerservice.MaintenanceConfiguration{
	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
		MaintenanceWindow: &armcontainerservice.MaintenanceWindow{
			DurationHours: to.Ptr[int32](10),
			NotAllowedDates: []*armcontainerservice.DateSpan{
				{
					End:   to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-25"); return t }()),
					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-18"); return t }()),
				},
				{
					End:   to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2024-01-05"); return t }()),
					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-12-23"); return t }()),
				}},
			Schedule: &armcontainerservice.Schedule{
				RelativeMonthly: &armcontainerservice.RelativeMonthlySchedule{
					DayOfWeek:      to.Ptr(armcontainerservice.WeekDayMonday),
					IntervalMonths: to.Ptr[int32](3),
					WeekIndex:      to.Ptr(armcontainerservice.TypeFirst),
				},
			},
			StartDate: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-01-01"); return t }()),
			StartTime: to.Ptr("08:30"),
			UTCOffset: to.Ptr("+05:30"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MaintenanceConfiguration = armcontainerservice.MaintenanceConfiguration{
// 	Name: to.Ptr("aksManagedAutoUpgradeSchedule"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/aksManagedAutoUpgradeSchedule"),
// 	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
// 		MaintenanceWindow: &armcontainerservice.MaintenanceWindow{
// 			DurationHours: to.Ptr[int32](10),
// 			NotAllowedDates: []*armcontainerservice.DateSpan{
// 				{
// 					End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-25"); return t}()),
// 					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-18"); return t}()),
// 				},
// 				{
// 					End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2024-01-05"); return t}()),
// 					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-12-23"); return t}()),
// 			}},
// 			Schedule: &armcontainerservice.Schedule{
// 				Weekly: &armcontainerservice.WeeklySchedule{
// 					DayOfWeek: to.Ptr(armcontainerservice.WeekDayMonday),
// 					IntervalWeeks: to.Ptr[int32](3),
// 				},
// 			},
// 			StartDate: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-01-01"); return t}()),
// 			StartTime: to.Ptr("08:30"),
// 			UTCOffset: to.Ptr("+05:30"),
// 		},
// 	},
// }

Output:

func (*MaintenanceConfigurationsClient) Delete 

func (client *MaintenanceConfigurationsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, configName string, options *MaintenanceConfigurationsClientDeleteOptions) (MaintenanceConfigurationsClientDeleteResponse, error)

Delete - Deletes a maintenance configuration. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • configName - The name of the maintenance configuration.
  • options - MaintenanceConfigurationsClientDeleteOptions contains the optional parameters for the MaintenanceConfigurationsClient.Delete method.
Example (DeleteMaintenanceConfiguration)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewMaintenanceConfigurationsClient().Delete(ctx, "rg1", "clustername1", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:
Example (DeleteMaintenanceConfigurationForNodeOsUpgrade)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsDelete_MaintenanceWindow.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewMaintenanceConfigurationsClient().Delete(ctx, "rg1", "clustername1", "aksManagedNodeOSUpgradeSchedule", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*MaintenanceConfigurationsClient) Get 

func (client *MaintenanceConfigurationsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, configName string, options *MaintenanceConfigurationsClientGetOptions) (MaintenanceConfigurationsClientGetResponse, error)

Get - Gets the specified maintenance configuration of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • configName - The name of the maintenance configuration.
  • options - MaintenanceConfigurationsClientGetOptions contains the optional parameters for the MaintenanceConfigurationsClient.Get method.
Example (GetMaintenanceConfiguration)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMaintenanceConfigurationsClient().Get(ctx, "rg1", "clustername1", "default", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MaintenanceConfiguration = armcontainerservice.MaintenanceConfiguration{
// 	Name: to.Ptr("default"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/default"),
// 	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
// 		NotAllowedTime: []*armcontainerservice.TimeSpan{
// 			{
// 				End: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-30T12:00:00.000Z"); return t}()),
// 				Start: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-26T03:00:00.000Z"); return t}()),
// 		}},
// 		TimeInWeek: []*armcontainerservice.TimeInWeek{
// 			{
// 				Day: to.Ptr(armcontainerservice.WeekDayMonday),
// 				HourSlots: []*int32{
// 					to.Ptr[int32](1),
// 					to.Ptr[int32](2)},
// 			}},
// 		},
// 		SystemData: &armcontainerservice.SystemData{
// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-01T17:18:19.123Z"); return t}()),
// 			CreatedBy: to.Ptr("user1"),
// 			CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-01-02T17:18:19.123Z"); return t}()),
// 			LastModifiedBy: to.Ptr("user2"),
// 			LastModifiedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 		},
// 	}

Output:
Example (GetMaintenanceConfigurationConfiguredWithMaintenanceWindow)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsGet_MaintenanceWindow.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewMaintenanceConfigurationsClient().Get(ctx, "rg1", "clustername1", "aksManagedNodeOSUpgradeSchedule", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MaintenanceConfiguration = armcontainerservice.MaintenanceConfiguration{
// 	Name: to.Ptr("aksManagedNodeOSUpgradeSchedule"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/aksManagedNodeOSUpgradeSchedule"),
// 	Properties: &armcontainerservice.MaintenanceConfigurationProperties{
// 		MaintenanceWindow: &armcontainerservice.MaintenanceWindow{
// 			DurationHours: to.Ptr[int32](4),
// 			NotAllowedDates: []*armcontainerservice.DateSpan{
// 				{
// 					End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-25"); return t}()),
// 					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-18"); return t}()),
// 				},
// 				{
// 					End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2024-01-05"); return t}()),
// 					Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-12-23"); return t}()),
// 			}},
// 			Schedule: &armcontainerservice.Schedule{
// 				Daily: &armcontainerservice.DailySchedule{
// 					IntervalDays: to.Ptr[int32](3),
// 				},
// 			},
// 			StartDate: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-01-01"); return t}()),
// 			StartTime: to.Ptr("09:30"),
// 			UTCOffset: to.Ptr("-07:00"),
// 		},
// 	},
// }

Output:

func (*MaintenanceConfigurationsClient) NewListByManagedClusterPager 

func (client *MaintenanceConfigurationsClient) NewListByManagedClusterPager(resourceGroupName string, resourceName string, options *MaintenanceConfigurationsClientListByManagedClusterOptions) *runtime.Pager[MaintenanceConfigurationsClientListByManagedClusterResponse]

NewListByManagedClusterPager - Gets a list of maintenance configurations in the specified managed cluster.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - MaintenanceConfigurationsClientListByManagedClusterOptions contains the optional parameters for the MaintenanceConfigurationsClient.NewListByManagedClusterPager method.
Example (ListMaintenanceConfigurationsByManagedCluster)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMaintenanceConfigurationsClient().NewListByManagedClusterPager("rg1", "clustername1", 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.MaintenanceConfigurationListResult = armcontainerservice.MaintenanceConfigurationListResult{
	// 	Value: []*armcontainerservice.MaintenanceConfiguration{
	// 		{
	// 			Name: to.Ptr("default"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/default"),
	// 			Properties: &armcontainerservice.MaintenanceConfigurationProperties{
	// 				NotAllowedTime: []*armcontainerservice.TimeSpan{
	// 					{
	// 						End: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-30T12:00:00.000Z"); return t}()),
	// 						Start: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-26T03:00:00.000Z"); return t}()),
	// 				}},
	// 				TimeInWeek: []*armcontainerservice.TimeInWeek{
	// 					{
	// 						Day: to.Ptr(armcontainerservice.WeekDayMonday),
	// 						HourSlots: []*int32{
	// 							to.Ptr[int32](1),
	// 							to.Ptr[int32](2)},
	// 					}},
	// 				},
	// 		}},
	// 	}
}

Output:
Example (ListMaintenanceConfigurationsConfiguredWithMaintenanceWindowByManagedCluster)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/MaintenanceConfigurationsList_MaintenanceWindow.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewMaintenanceConfigurationsClient().NewListByManagedClusterPager("rg1", "clustername1", 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.MaintenanceConfigurationListResult = armcontainerservice.MaintenanceConfigurationListResult{
	// 	Value: []*armcontainerservice.MaintenanceConfiguration{
	// 		{
	// 			Name: to.Ptr("aksManagedNodeOSUpgradeSchedule"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/aksManagedNodeOSUpgradeSchedule"),
	// 			Properties: &armcontainerservice.MaintenanceConfigurationProperties{
	// 				MaintenanceWindow: &armcontainerservice.MaintenanceWindow{
	// 					DurationHours: to.Ptr[int32](10),
	// 					Schedule: &armcontainerservice.Schedule{
	// 						Daily: &armcontainerservice.DailySchedule{
	// 							IntervalDays: to.Ptr[int32](5),
	// 						},
	// 					},
	// 					StartDate: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-01-01"); return t}()),
	// 					StartTime: to.Ptr("13:30"),
	// 					UTCOffset: to.Ptr("-07:00"),
	// 				},
	// 			},
	// 		},
	// 		{
	// 			Name: to.Ptr("aksManagedAutoUpgradeSchedule"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/maintenanceConfigurations/aksManagedAutoUpgradeSchedule"),
	// 			Properties: &armcontainerservice.MaintenanceConfigurationProperties{
	// 				MaintenanceWindow: &armcontainerservice.MaintenanceWindow{
	// 					DurationHours: to.Ptr[int32](5),
	// 					NotAllowedDates: []*armcontainerservice.DateSpan{
	// 						{
	// 							End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-25"); return t}()),
	// 							Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-02-18"); return t}()),
	// 						},
	// 						{
	// 							End: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2024-01-05"); return t}()),
	// 							Start: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-12-23"); return t}()),
	// 					}},
	// 					Schedule: &armcontainerservice.Schedule{
	// 						AbsoluteMonthly: &armcontainerservice.AbsoluteMonthlySchedule{
	// 							DayOfMonth: to.Ptr[int32](15),
	// 							IntervalMonths: to.Ptr[int32](3),
	// 						},
	// 					},
	// 					StartDate: to.Ptr(func() time.Time { t, _ := time.Parse("2006-01-02", "2023-01-01"); return t}()),
	// 					StartTime: to.Ptr("08:30"),
	// 					UTCOffset: to.Ptr("+00:00"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type MaintenanceConfigurationsClientCreateOrUpdateOptions 

type MaintenanceConfigurationsClientCreateOrUpdateOptions struct {
}

MaintenanceConfigurationsClientCreateOrUpdateOptions contains the optional parameters for the MaintenanceConfigurationsClient.CreateOrUpdate method.

type MaintenanceConfigurationsClientCreateOrUpdateResponse 

type MaintenanceConfigurationsClientCreateOrUpdateResponse struct {
	// See [planned maintenance](https://docs.microsoft.com/azure/aks/planned-maintenance) for more information about planned
	// maintenance.
	MaintenanceConfiguration
}

MaintenanceConfigurationsClientCreateOrUpdateResponse contains the response from method MaintenanceConfigurationsClient.CreateOrUpdate.

type MaintenanceConfigurationsClientDeleteOptions 

type MaintenanceConfigurationsClientDeleteOptions struct {
}

MaintenanceConfigurationsClientDeleteOptions contains the optional parameters for the MaintenanceConfigurationsClient.Delete method.

type MaintenanceConfigurationsClientDeleteResponse 

type MaintenanceConfigurationsClientDeleteResponse struct {
}

MaintenanceConfigurationsClientDeleteResponse contains the response from method MaintenanceConfigurationsClient.Delete.

type MaintenanceConfigurationsClientGetOptions 

type MaintenanceConfigurationsClientGetOptions struct {
}

MaintenanceConfigurationsClientGetOptions contains the optional parameters for the MaintenanceConfigurationsClient.Get method.

type MaintenanceConfigurationsClientGetResponse 

type MaintenanceConfigurationsClientGetResponse struct {
	// See [planned maintenance](https://docs.microsoft.com/azure/aks/planned-maintenance) for more information about planned
	// maintenance.
	MaintenanceConfiguration
}

MaintenanceConfigurationsClientGetResponse contains the response from method MaintenanceConfigurationsClient.Get.

type MaintenanceConfigurationsClientListByManagedClusterOptions 

type MaintenanceConfigurationsClientListByManagedClusterOptions struct {
}

MaintenanceConfigurationsClientListByManagedClusterOptions contains the optional parameters for the MaintenanceConfigurationsClient.NewListByManagedClusterPager method.

type MaintenanceConfigurationsClientListByManagedClusterResponse 

type MaintenanceConfigurationsClientListByManagedClusterResponse struct {
	// The response from the List maintenance configurations operation.
	MaintenanceConfigurationListResult
}

MaintenanceConfigurationsClientListByManagedClusterResponse contains the response from method MaintenanceConfigurationsClient.NewListByManagedClusterPager.

type MaintenanceWindow 

type MaintenanceWindow struct {
	// REQUIRED; Length of maintenance window range from 4 to 24 hours.
	DurationHours *int32

	// REQUIRED; Recurrence schedule for the maintenance window.
	Schedule *Schedule

	// REQUIRED; The start time of the maintenance window. Accepted values are from '00:00' to '23:59'. 'utcOffset' applies to
	// this field. For example: '02:00' with 'utcOffset: +02:00' means UTC time '00:00'.
	StartTime *string

	// Date ranges on which upgrade is not allowed. 'utcOffset' applies to this field. For example, with 'utcOffset: +02:00' and
	// 'dateSpan' being '2022-12-23' to '2023-01-03', maintenance will be blocked
	// from '2022-12-22 22:00' to '2023-01-03 22:00' in UTC time.
	NotAllowedDates []*DateSpan

	// The date the maintenance window activates. If the current date is before this date, the maintenance window is inactive
	// and will not be used for upgrades. If not specified, the maintenance window will
	// be active right away.
	StartDate *time.Time

	// The UTC offset in format +/-HH:mm. For example, '+05:30' for IST and '-07:00' for PST. If not specified, the default is
	// '+00:00'.
	UTCOffset *string
}

MaintenanceWindow - Maintenance window used to configure scheduled auto-upgrade for a Managed Cluster.

func (MaintenanceWindow) MarshalJSON 

func (m MaintenanceWindow) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MaintenanceWindow.

func (*MaintenanceWindow) UnmarshalJSON 

func (m *MaintenanceWindow) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MaintenanceWindow.

type ManagedCluster 

type ManagedCluster struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// The extended location of the Virtual Machine.
	ExtendedLocation *ExtendedLocation

	// The identity of the managed cluster, if configured.
	Identity *ManagedClusterIdentity

	// Properties of a managed cluster.
	Properties *ManagedClusterProperties

	// The managed cluster SKU.
	SKU *ManagedClusterSKU

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Unique read-only string used to implement optimistic concurrency. The eTag value will change when the resource
	// is updated. Specify an if-match or if-none-match header with the eTag value for a
	// subsequent request to enable optimistic concurrency per the normal etag convention.
	ETag *string

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

ManagedCluster - Managed cluster.

func (ManagedCluster) MarshalJSON 

func (m ManagedCluster) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedCluster.

func (*ManagedCluster) UnmarshalJSON 

func (m *ManagedCluster) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedCluster.

type ManagedClusterAADProfile 

type ManagedClusterAADProfile struct {
	// The list of AAD group object IDs that will have admin role of the cluster.
	AdminGroupObjectIDs []*string

	// (DEPRECATED) The client AAD application ID. Learn more at https://aka.ms/aks/aad-legacy.
	ClientAppID *string

	// Whether to enable Azure RBAC for Kubernetes authorization.
	EnableAzureRBAC *bool

	// Whether to enable managed AAD.
	Managed *bool

	// (DEPRECATED) The server AAD application ID. Learn more at https://aka.ms/aks/aad-legacy.
	ServerAppID *string

	// (DEPRECATED) The server AAD application secret. Learn more at https://aka.ms/aks/aad-legacy.
	ServerAppSecret *string

	// The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
	TenantID *string
}

ManagedClusterAADProfile - For more details see managed AAD on AKS [https://docs.microsoft.com/azure/aks/managed-aad].

func (ManagedClusterAADProfile) MarshalJSON 

func (m ManagedClusterAADProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAADProfile.

func (*ManagedClusterAADProfile) UnmarshalJSON 

func (m *ManagedClusterAADProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAADProfile.

type ManagedClusterAPIServerAccessProfile 

type ManagedClusterAPIServerAccessProfile struct {
	// IP ranges are specified in CIDR format, e.g. 137.117.106.88/29. This feature is not compatible with clusters that use Public
	// IP Per Node, or clusters that are using a Basic Load Balancer. For more
	// information see API server authorized IP ranges [https://docs.microsoft.com/azure/aks/api-server-authorized-ip-ranges].
	AuthorizedIPRanges []*string

	// Whether to disable run command for the cluster or not.
	DisableRunCommand *bool

	// For more details, see Creating a private AKS cluster [https://docs.microsoft.com/azure/aks/private-clusters].
	EnablePrivateCluster *bool

	// Whether to create additional public FQDN for private cluster or not.
	EnablePrivateClusterPublicFQDN *bool

	// The default is System. For more details see configure private DNS zone [https://docs.microsoft.com/azure/aks/private-clusters#configure-private-dns-zone].
	// Allowed values are 'system' and 'none'.
	PrivateDNSZone *string
}

ManagedClusterAPIServerAccessProfile - Access profile for managed cluster API server.

func (ManagedClusterAPIServerAccessProfile) MarshalJSON 

func (m ManagedClusterAPIServerAccessProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAPIServerAccessProfile.

func (*ManagedClusterAPIServerAccessProfile) UnmarshalJSON 

func (m *ManagedClusterAPIServerAccessProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAPIServerAccessProfile.

type ManagedClusterAccessProfile 

type ManagedClusterAccessProfile struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// AccessProfile of a managed cluster.
	Properties *AccessProfile

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

ManagedClusterAccessProfile - Managed cluster Access Profile.

func (ManagedClusterAccessProfile) MarshalJSON 

func (m ManagedClusterAccessProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAccessProfile.

func (*ManagedClusterAccessProfile) UnmarshalJSON 

func (m *ManagedClusterAccessProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAccessProfile.

type ManagedClusterAddonProfile 

type ManagedClusterAddonProfile struct {
	// REQUIRED; Whether the add-on is enabled or not.
	Enabled *bool

	// Key-value pairs for configuring an add-on.
	Config map[string]*string

	// READ-ONLY; Information of user assigned identity used by this add-on.
	Identity *ManagedClusterAddonProfileIdentity
}

ManagedClusterAddonProfile - A Kubernetes add-on profile for a managed cluster.

func (ManagedClusterAddonProfile) MarshalJSON 

func (m ManagedClusterAddonProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAddonProfile.

func (*ManagedClusterAddonProfile) UnmarshalJSON 

func (m *ManagedClusterAddonProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAddonProfile.

type ManagedClusterAddonProfileIdentity 

type ManagedClusterAddonProfileIdentity struct {
	// The client ID of the user assigned identity.
	ClientID *string

	// The object ID of the user assigned identity.
	ObjectID *string

	// The resource ID of the user assigned identity.
	ResourceID *string
}

ManagedClusterAddonProfileIdentity - Information of user assigned identity used by this add-on.

func (ManagedClusterAddonProfileIdentity) MarshalJSON 

func (m ManagedClusterAddonProfileIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAddonProfileIdentity.

func (*ManagedClusterAddonProfileIdentity) UnmarshalJSON 

func (m *ManagedClusterAddonProfileIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAddonProfileIdentity.

type ManagedClusterAgentPoolProfile 

type ManagedClusterAgentPoolProfile struct {
	// REQUIRED; Windows agent pool names must be 6 characters or less.
	Name *string

	// The list of Availability zones to use for nodes. This can only be specified if the AgentPoolType property is 'VirtualMachineScaleSets'.
	AvailabilityZones []*string

	// AKS will associate the specified agent pool with the Capacity Reservation Group.
	CapacityReservationGroupID *string

	// Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 1000 (inclusive) for user
	// pools and in the range of 1 to 1000 (inclusive) for system pools. The default
	// value is 1.
	Count *int32

	// CreationData to be used to specify the source Snapshot ID if the node pool will be created/upgraded using a snapshot.
	CreationData *CreationData

	// Whether to enable auto-scaler
	EnableAutoScaling *bool

	// This is only supported on certain VM sizes and in certain Azure regions. For more information, see: https://docs.microsoft.com/azure/aks/enable-host-encryption
	EnableEncryptionAtHost *bool

	// See Add a FIPS-enabled node pool [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#add-a-fips-enabled-node-pool-preview]
	// for more details.
	EnableFIPS *bool

	// Some scenarios may require nodes in a node pool to receive their own dedicated public IP addresses. A common scenario is
	// for gaming workloads, where a console needs to make a direct connection to a
	// cloud virtual machine to minimize hops. For more information see assigning a public IP per node
	// [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#assign-a-public-ip-per-node-for-your-node-pools]. The default
	// is false.
	EnableNodePublicIP *bool

	// Whether to enable UltraSSD
	EnableUltraSSD *bool

	// GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU.
	GpuInstanceProfile *GPUInstanceProfile

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/hostGroups/{hostGroupName}.
	// For more information see Azure dedicated hosts
	// [https://docs.microsoft.com/azure/virtual-machines/dedicated-hosts].
	HostGroupID *string

	// The Kubelet configuration on the agent pool nodes.
	KubeletConfig *KubeletConfig

	// Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage.
	KubeletDiskType *KubeletDiskType

	// The OS configuration of Linux agent nodes.
	LinuxOSConfig *LinuxOSConfig

	// The maximum number of nodes for auto-scaling
	MaxCount *int32

	// The maximum number of pods that can run on a node.
	MaxPods *int32

	// The minimum number of nodes for auto-scaling
	MinCount *int32

	// A cluster must have at least one 'System' Agent Pool at all times. For additional information on agent pool restrictions
	// and best practices, see: https://docs.microsoft.com/azure/aks/use-system-pools
	Mode *AgentPoolMode

	// Network-related settings of an agent pool.
	NetworkProfile *AgentPoolNetworkProfile

	// The node labels to be persisted across all nodes in agent pool.
	NodeLabels map[string]*string

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}
	NodePublicIPPrefixID *string

	// The taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
	NodeTaints []*string

	// OS Disk Size in GB to be used to specify the disk size for every machine in the master/agent pool. If you specify 0, it
	// will apply the default osDisk size according to the vmSize specified.
	OSDiskSizeGB *int32

	// The default is 'Ephemeral' if the VM supports it and has a cache disk larger than the requested OSDiskSizeGB. Otherwise,
	// defaults to 'Managed'. May not be changed after creation. For more information
	// see Ephemeral OS [https://docs.microsoft.com/azure/aks/cluster-configuration#ephemeral-os].
	OSDiskType *OSDiskType

	// Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019 when
	// Kubernetes = 1.25 if OSType is Windows.
	OSSKU *OSSKU

	// The operating system type. The default is Linux.
	OSType *OSType

	// Both patch version (e.g. 1.20.13) and (e.g. 1.20) are supported. When is specified, the latest supported GA patch version
	// is chosen automatically. Updating the cluster with the same once it has been
	// created (e.g. 1.14.x -> 1.14) will not trigger an upgrade, even if a newer patch version is available. As a best practice,
	// you should upgrade all node pools in an AKS cluster to the same Kubernetes
	// version. The node pool version must have the same major version as the control plane. The node pool minor version must
	// be within two minor versions of the control plane version. The node pool version
	// cannot be greater than the control plane version. For more information see upgrading a node pool [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#upgrade-a-node-pool].
	OrchestratorVersion *string

	// If omitted, pod IPs are statically assigned on the node subnet (see vnetSubnetID for more details). This is of the form:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}
	PodSubnetID *string

	// When an Agent Pool is first created it is initially Running. The Agent Pool can be stopped by setting this field to Stopped.
	// A stopped Agent Pool stops all of its VMs and does not accrue billing
	// charges. An Agent Pool can only be stopped if it is Running and provisioning state is Succeeded
	PowerState *PowerState

	// The ID for Proximity Placement Group.
	ProximityPlacementGroupID *string

	// This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
	ScaleDownMode *ScaleDownMode

	// This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
	ScaleSetEvictionPolicy *ScaleSetEvictionPolicy

	// The Virtual Machine Scale Set priority. If not specified, the default is 'Regular'.
	ScaleSetPriority *ScaleSetPriority

	// The security settings of an agent pool.
	SecurityProfile *AgentPoolSecurityProfile

	// Possible values are any decimal value greater than zero or -1 which indicates the willingness to pay any on-demand price.
	// For more details on spot pricing, see spot VMs pricing
	// [https://docs.microsoft.com/azure/virtual-machines/spot-vms#pricing]
	SpotMaxPrice *float32

	// The tags to be persisted on the agent pool virtual machine scale set.
	Tags map[string]*string

	// The type of Agent Pool.
	Type *AgentPoolType

	// Settings for upgrading the agentpool
	UpgradeSettings *AgentPoolUpgradeSettings

	// VM size availability varies by region. If a node contains insufficient compute resources (memory, cpu, etc) pods might
	// fail to run correctly. For more details on restricted VM sizes, see:
	// https://docs.microsoft.com/azure/aks/quotas-skus-regions
	VMSize *string

	// If this is not specified, a VNET and subnet will be generated and used. If no podSubnetID is specified, this applies to
	// nodes and pods, otherwise it applies to just nodes. This is of the form:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}
	VnetSubnetID *string

	// The Windows agent pool's specific profile.
	WindowsProfile *AgentPoolWindowsProfile

	// Determines the type of workload a node can run.
	WorkloadRuntime *WorkloadRuntime

	// READ-ONLY; If orchestratorVersion is a fully specified version , this field will be exactly equal to it. If orchestratorVersion
	// is , this field will contain the full version being used.
	CurrentOrchestratorVersion *string

	// READ-ONLY; Unique read-only string used to implement optimistic concurrency. The eTag value will change when the resource
	// is updated. Specify an if-match or if-none-match header with the eTag value for a
	// subsequent request to enable optimistic concurrency per the normal etag convention.
	ETag *string

	// READ-ONLY; The version of node image
	NodeImageVersion *string

	// READ-ONLY; The current deployment or provisioning state.
	ProvisioningState *string
}

ManagedClusterAgentPoolProfile - Profile for the container service agent pool.

func (ManagedClusterAgentPoolProfile) MarshalJSON 

func (m ManagedClusterAgentPoolProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAgentPoolProfile.

func (*ManagedClusterAgentPoolProfile) UnmarshalJSON 

func (m *ManagedClusterAgentPoolProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAgentPoolProfile.

type ManagedClusterAgentPoolProfileProperties 

type ManagedClusterAgentPoolProfileProperties struct {
	// The list of Availability zones to use for nodes. This can only be specified if the AgentPoolType property is 'VirtualMachineScaleSets'.
	AvailabilityZones []*string

	// AKS will associate the specified agent pool with the Capacity Reservation Group.
	CapacityReservationGroupID *string

	// Number of agents (VMs) to host docker containers. Allowed values must be in the range of 0 to 1000 (inclusive) for user
	// pools and in the range of 1 to 1000 (inclusive) for system pools. The default
	// value is 1.
	Count *int32

	// CreationData to be used to specify the source Snapshot ID if the node pool will be created/upgraded using a snapshot.
	CreationData *CreationData

	// Whether to enable auto-scaler
	EnableAutoScaling *bool

	// This is only supported on certain VM sizes and in certain Azure regions. For more information, see: https://docs.microsoft.com/azure/aks/enable-host-encryption
	EnableEncryptionAtHost *bool

	// See Add a FIPS-enabled node pool [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#add-a-fips-enabled-node-pool-preview]
	// for more details.
	EnableFIPS *bool

	// Some scenarios may require nodes in a node pool to receive their own dedicated public IP addresses. A common scenario is
	// for gaming workloads, where a console needs to make a direct connection to a
	// cloud virtual machine to minimize hops. For more information see assigning a public IP per node
	// [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#assign-a-public-ip-per-node-for-your-node-pools]. The default
	// is false.
	EnableNodePublicIP *bool

	// Whether to enable UltraSSD
	EnableUltraSSD *bool

	// GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU.
	GpuInstanceProfile *GPUInstanceProfile

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/hostGroups/{hostGroupName}.
	// For more information see Azure dedicated hosts
	// [https://docs.microsoft.com/azure/virtual-machines/dedicated-hosts].
	HostGroupID *string

	// The Kubelet configuration on the agent pool nodes.
	KubeletConfig *KubeletConfig

	// Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage.
	KubeletDiskType *KubeletDiskType

	// The OS configuration of Linux agent nodes.
	LinuxOSConfig *LinuxOSConfig

	// The maximum number of nodes for auto-scaling
	MaxCount *int32

	// The maximum number of pods that can run on a node.
	MaxPods *int32

	// The minimum number of nodes for auto-scaling
	MinCount *int32

	// A cluster must have at least one 'System' Agent Pool at all times. For additional information on agent pool restrictions
	// and best practices, see: https://docs.microsoft.com/azure/aks/use-system-pools
	Mode *AgentPoolMode

	// Network-related settings of an agent pool.
	NetworkProfile *AgentPoolNetworkProfile

	// The node labels to be persisted across all nodes in agent pool.
	NodeLabels map[string]*string

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}
	NodePublicIPPrefixID *string

	// The taints added to new nodes during node pool create and scale. For example, key=value:NoSchedule.
	NodeTaints []*string

	// OS Disk Size in GB to be used to specify the disk size for every machine in the master/agent pool. If you specify 0, it
	// will apply the default osDisk size according to the vmSize specified.
	OSDiskSizeGB *int32

	// The default is 'Ephemeral' if the VM supports it and has a cache disk larger than the requested OSDiskSizeGB. Otherwise,
	// defaults to 'Managed'. May not be changed after creation. For more information
	// see Ephemeral OS [https://docs.microsoft.com/azure/aks/cluster-configuration#ephemeral-os].
	OSDiskType *OSDiskType

	// Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019 when
	// Kubernetes = 1.25 if OSType is Windows.
	OSSKU *OSSKU

	// The operating system type. The default is Linux.
	OSType *OSType

	// Both patch version (e.g. 1.20.13) and (e.g. 1.20) are supported. When is specified, the latest supported GA patch version
	// is chosen automatically. Updating the cluster with the same once it has been
	// created (e.g. 1.14.x -> 1.14) will not trigger an upgrade, even if a newer patch version is available. As a best practice,
	// you should upgrade all node pools in an AKS cluster to the same Kubernetes
	// version. The node pool version must have the same major version as the control plane. The node pool minor version must
	// be within two minor versions of the control plane version. The node pool version
	// cannot be greater than the control plane version. For more information see upgrading a node pool [https://docs.microsoft.com/azure/aks/use-multiple-node-pools#upgrade-a-node-pool].
	OrchestratorVersion *string

	// If omitted, pod IPs are statically assigned on the node subnet (see vnetSubnetID for more details). This is of the form:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}
	PodSubnetID *string

	// When an Agent Pool is first created it is initially Running. The Agent Pool can be stopped by setting this field to Stopped.
	// A stopped Agent Pool stops all of its VMs and does not accrue billing
	// charges. An Agent Pool can only be stopped if it is Running and provisioning state is Succeeded
	PowerState *PowerState

	// The ID for Proximity Placement Group.
	ProximityPlacementGroupID *string

	// This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
	ScaleDownMode *ScaleDownMode

	// This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
	ScaleSetEvictionPolicy *ScaleSetEvictionPolicy

	// The Virtual Machine Scale Set priority. If not specified, the default is 'Regular'.
	ScaleSetPriority *ScaleSetPriority

	// The security settings of an agent pool.
	SecurityProfile *AgentPoolSecurityProfile

	// Possible values are any decimal value greater than zero or -1 which indicates the willingness to pay any on-demand price.
	// For more details on spot pricing, see spot VMs pricing
	// [https://docs.microsoft.com/azure/virtual-machines/spot-vms#pricing]
	SpotMaxPrice *float32

	// The tags to be persisted on the agent pool virtual machine scale set.
	Tags map[string]*string

	// The type of Agent Pool.
	Type *AgentPoolType

	// Settings for upgrading the agentpool
	UpgradeSettings *AgentPoolUpgradeSettings

	// VM size availability varies by region. If a node contains insufficient compute resources (memory, cpu, etc) pods might
	// fail to run correctly. For more details on restricted VM sizes, see:
	// https://docs.microsoft.com/azure/aks/quotas-skus-regions
	VMSize *string

	// If this is not specified, a VNET and subnet will be generated and used. If no podSubnetID is specified, this applies to
	// nodes and pods, otherwise it applies to just nodes. This is of the form:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}
	VnetSubnetID *string

	// The Windows agent pool's specific profile.
	WindowsProfile *AgentPoolWindowsProfile

	// Determines the type of workload a node can run.
	WorkloadRuntime *WorkloadRuntime

	// READ-ONLY; If orchestratorVersion is a fully specified version , this field will be exactly equal to it. If orchestratorVersion
	// is , this field will contain the full version being used.
	CurrentOrchestratorVersion *string

	// READ-ONLY; Unique read-only string used to implement optimistic concurrency. The eTag value will change when the resource
	// is updated. Specify an if-match or if-none-match header with the eTag value for a
	// subsequent request to enable optimistic concurrency per the normal etag convention.
	ETag *string

	// READ-ONLY; The version of node image
	NodeImageVersion *string

	// READ-ONLY; The current deployment or provisioning state.
	ProvisioningState *string
}

ManagedClusterAgentPoolProfileProperties - Properties for the container service agent pool profile.

func (ManagedClusterAgentPoolProfileProperties) MarshalJSON 

func (m ManagedClusterAgentPoolProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAgentPoolProfileProperties.

func (*ManagedClusterAgentPoolProfileProperties) UnmarshalJSON 

func (m *ManagedClusterAgentPoolProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAgentPoolProfileProperties.

type ManagedClusterAutoUpgradeProfile 

type ManagedClusterAutoUpgradeProfile struct {
	// Manner in which the OS on your nodes is updated. The default is NodeImage.
	NodeOSUpgradeChannel *NodeOSUpgradeChannel

	// For more information see setting the AKS cluster auto-upgrade channel [https://docs.microsoft.com/azure/aks/upgrade-cluster#set-auto-upgrade-channel].
	UpgradeChannel *UpgradeChannel
}

ManagedClusterAutoUpgradeProfile - Auto upgrade profile for a managed cluster.

func (ManagedClusterAutoUpgradeProfile) MarshalJSON 

func (m ManagedClusterAutoUpgradeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAutoUpgradeProfile.

func (*ManagedClusterAutoUpgradeProfile) UnmarshalJSON 

func (m *ManagedClusterAutoUpgradeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAutoUpgradeProfile.

type ManagedClusterAzureMonitorProfile 

type ManagedClusterAzureMonitorProfile struct {
	// Metrics profile for the Azure Monitor managed service for Prometheus addon. Collect out-of-the-box Kubernetes infrastructure
	// metrics to send to an Azure Monitor Workspace and configure additional
	// scraping for custom targets. See aka.ms/AzureManagedPrometheus for an overview.
	Metrics *ManagedClusterAzureMonitorProfileMetrics
}

ManagedClusterAzureMonitorProfile - Azure Monitor addon profiles for monitoring the managed cluster.

func (ManagedClusterAzureMonitorProfile) MarshalJSON 

func (m ManagedClusterAzureMonitorProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAzureMonitorProfile.

func (*ManagedClusterAzureMonitorProfile) UnmarshalJSON 

func (m *ManagedClusterAzureMonitorProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAzureMonitorProfile.

type ManagedClusterAzureMonitorProfileKubeStateMetrics 

type ManagedClusterAzureMonitorProfileKubeStateMetrics struct {
	// Comma-separated list of Kubernetes annotation keys that will be used in the resource's labels metric (Example: 'namespaces=[kubernetes.io/team,…],pods=[kubernetes.io/team],…').
	// By default the metric
	// contains only resource name and namespace labels.
	MetricAnnotationsAllowList *string

	// Comma-separated list of additional Kubernetes label keys that will be used in the resource's labels metric (Example: 'namespaces=[k8s-label-1,k8s-label-n,…],pods=[app],…').
	// By default the metric
	// contains only resource name and namespace labels.
	MetricLabelsAllowlist *string
}

ManagedClusterAzureMonitorProfileKubeStateMetrics - Kube State Metrics profile for the Azure Managed Prometheus addon. These optional settings are for the kube-state-metrics pod that is deployed with the addon. See aka.ms/AzureManagedPrometheus-optional-parameters for details.

func (ManagedClusterAzureMonitorProfileKubeStateMetrics) MarshalJSON 

func (m ManagedClusterAzureMonitorProfileKubeStateMetrics) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAzureMonitorProfileKubeStateMetrics.

func (*ManagedClusterAzureMonitorProfileKubeStateMetrics) UnmarshalJSON 

func (m *ManagedClusterAzureMonitorProfileKubeStateMetrics) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAzureMonitorProfileKubeStateMetrics.

type ManagedClusterAzureMonitorProfileMetrics 

type ManagedClusterAzureMonitorProfileMetrics struct {
	// REQUIRED; Whether to enable or disable the Azure Managed Prometheus addon for Prometheus monitoring. See aka.ms/AzureManagedPrometheus-aks-enable
	// for details on enabling and disabling.
	Enabled *bool

	// Kube State Metrics profile for the Azure Managed Prometheus addon. These optional settings are for the kube-state-metrics
	// pod that is deployed with the addon. See
	// aka.ms/AzureManagedPrometheus-optional-parameters for details.
	KubeStateMetrics *ManagedClusterAzureMonitorProfileKubeStateMetrics
}

ManagedClusterAzureMonitorProfileMetrics - Metrics profile for the Azure Monitor managed service for Prometheus addon. Collect out-of-the-box Kubernetes infrastructure metrics to send to an Azure Monitor Workspace and configure additional scraping for custom targets. See aka.ms/AzureManagedPrometheus for an overview.

func (ManagedClusterAzureMonitorProfileMetrics) MarshalJSON 

func (m ManagedClusterAzureMonitorProfileMetrics) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAzureMonitorProfileMetrics.

func (*ManagedClusterAzureMonitorProfileMetrics) UnmarshalJSON 

func (m *ManagedClusterAzureMonitorProfileMetrics) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterAzureMonitorProfileMetrics.

type ManagedClusterCostAnalysis 

type ManagedClusterCostAnalysis struct {
	// The Managed Cluster sku.tier must be set to 'Standard' or 'Premium' to enable this feature. Enabling this will add Kubernetes
	// Namespace and Deployment details to the Cost Analysis views in the Azure
	// portal. If not specified, the default is false. For more information see aka.ms/aks/docs/cost-analysis.
	Enabled *bool
}

ManagedClusterCostAnalysis - The cost analysis configuration for the cluster

func (ManagedClusterCostAnalysis) MarshalJSON 

func (m ManagedClusterCostAnalysis) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterCostAnalysis.

func (*ManagedClusterCostAnalysis) UnmarshalJSON 

func (m *ManagedClusterCostAnalysis) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterCostAnalysis.

type ManagedClusterHTTPProxyConfig 

type ManagedClusterHTTPProxyConfig struct {
	// The HTTP proxy server endpoint to use.
	HTTPProxy *string

	// The HTTPS proxy server endpoint to use.
	HTTPSProxy *string

	// The endpoints that should not go through proxy.
	NoProxy []*string

	// Alternative CA cert to use for connecting to proxy servers.
	TrustedCa *string
}

ManagedClusterHTTPProxyConfig - Cluster HTTP proxy configuration.

func (ManagedClusterHTTPProxyConfig) MarshalJSON 

func (m ManagedClusterHTTPProxyConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterHTTPProxyConfig.

func (*ManagedClusterHTTPProxyConfig) UnmarshalJSON 

func (m *ManagedClusterHTTPProxyConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterHTTPProxyConfig.

type ManagedClusterIdentity 

type ManagedClusterIdentity struct {
	// The delegated identity resources assigned to this managed cluster. This can only be set by another Azure Resource Provider,
	// and managed cluster only accept one delegated identity resource. Internal
	// use only.
	DelegatedResources map[string]*DelegatedResource

	// For more information see use managed identities in AKS [https://docs.microsoft.com/azure/aks/use-managed-identity].
	Type *ResourceIdentityType

	// The keys must be ARM resource IDs in the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
	UserAssignedIdentities map[string]*ManagedServiceIdentityUserAssignedIdentitiesValue

	// READ-ONLY; The principal id of the system assigned identity which is used by master components.
	PrincipalID *string

	// READ-ONLY; The tenant id of the system assigned identity which is used by master components.
	TenantID *string
}

ManagedClusterIdentity - Identity for the managed cluster.

func (ManagedClusterIdentity) MarshalJSON 

func (m ManagedClusterIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterIdentity.

func (*ManagedClusterIdentity) UnmarshalJSON 

func (m *ManagedClusterIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterIdentity.

type ManagedClusterIngressProfile 

type ManagedClusterIngressProfile struct {
	// App Routing settings for the ingress profile. You can find an overview and onboarding guide for this feature at
	// https://learn.microsoft.com/en-us/azure/aks/app-routing?tabs=default%2Cdeploy-app-default.
	WebAppRouting *ManagedClusterIngressProfileWebAppRouting
}

ManagedClusterIngressProfile - Ingress profile for the container service cluster.

func (ManagedClusterIngressProfile) MarshalJSON 

func (m ManagedClusterIngressProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterIngressProfile.

func (*ManagedClusterIngressProfile) UnmarshalJSON 

func (m *ManagedClusterIngressProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterIngressProfile.

type ManagedClusterIngressProfileWebAppRouting 

type ManagedClusterIngressProfileWebAppRouting struct {
	// Resource IDs of the DNS zones to be associated with the Application Routing add-on. Used only when Application Routing
	// add-on is enabled. Public and private DNS zones can be in different resource
	// groups, but all public DNS zones must be in the same resource group and all private DNS zones must be in the same resource
	// group.
	DNSZoneResourceIDs []*string

	// Whether to enable the Application Routing add-on.
	Enabled *bool

	// READ-ONLY; Managed identity of the Application Routing add-on. This is the identity that should be granted permissions,
	// for example, to manage the associated Azure DNS resource and get certificates from Azure
	// Key Vault. See this overview of the add-on [https://learn.microsoft.com/en-us/azure/aks/web-app-routing?tabs=with-osm]
	// for more instructions.
	Identity *UserAssignedIdentity
}

ManagedClusterIngressProfileWebAppRouting - Application Routing add-on settings for the ingress profile.

func (ManagedClusterIngressProfileWebAppRouting) MarshalJSON 

func (m ManagedClusterIngressProfileWebAppRouting) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterIngressProfileWebAppRouting.

func (*ManagedClusterIngressProfileWebAppRouting) UnmarshalJSON 

func (m *ManagedClusterIngressProfileWebAppRouting) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterIngressProfileWebAppRouting.

type ManagedClusterListResult 

type ManagedClusterListResult struct {
	// The list of managed clusters.
	Value []*ManagedCluster

	// READ-ONLY; The URL to get the next set of managed cluster results.
	NextLink *string
}

ManagedClusterListResult - The response from the List Managed Clusters operation.

func (ManagedClusterListResult) MarshalJSON 

func (m ManagedClusterListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterListResult.

func (*ManagedClusterListResult) UnmarshalJSON 

func (m *ManagedClusterListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterListResult.

type ManagedClusterLoadBalancerProfile 

type ManagedClusterLoadBalancerProfile struct {
	// The desired number of allocated SNAT ports per VM. Allowed values are in the range of 0 to 64000 (inclusive). The default
	// value is 0 which results in Azure dynamically allocating ports.
	AllocatedOutboundPorts *int32

	// The type of the managed inbound Load Balancer BackendPool.
	BackendPoolType *BackendPoolType

	// The effective outbound IP resources of the cluster load balancer.
	EffectiveOutboundIPs []*ResourceReference

	// Enable multiple standard load balancers per AKS cluster or not.
	EnableMultipleStandardLoadBalancers *bool

	// Desired outbound flow idle timeout in minutes. Allowed values are in the range of 4 to 120 (inclusive). The default value
	// is 30 minutes.
	IdleTimeoutInMinutes *int32

	// Desired managed outbound IPs for the cluster load balancer.
	ManagedOutboundIPs *ManagedClusterLoadBalancerProfileManagedOutboundIPs

	// Desired outbound IP Prefix resources for the cluster load balancer.
	OutboundIPPrefixes *ManagedClusterLoadBalancerProfileOutboundIPPrefixes

	// Desired outbound IP resources for the cluster load balancer.
	OutboundIPs *ManagedClusterLoadBalancerProfileOutboundIPs
}

ManagedClusterLoadBalancerProfile - Profile of the managed cluster load balancer.

func (ManagedClusterLoadBalancerProfile) MarshalJSON 

func (m ManagedClusterLoadBalancerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterLoadBalancerProfile.

func (*ManagedClusterLoadBalancerProfile) UnmarshalJSON 

func (m *ManagedClusterLoadBalancerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterLoadBalancerProfile.

type ManagedClusterLoadBalancerProfileManagedOutboundIPs 

type ManagedClusterLoadBalancerProfileManagedOutboundIPs struct {
	// The desired number of IPv4 outbound IPs created/managed by Azure for the cluster load balancer. Allowed values must be
	// in the range of 1 to 100 (inclusive). The default value is 1.
	Count *int32

	// The desired number of IPv6 outbound IPs created/managed by Azure for the cluster load balancer. Allowed values must be
	// in the range of 1 to 100 (inclusive). The default value is 0 for single-stack and
	// 1 for dual-stack.
	CountIPv6 *int32
}

ManagedClusterLoadBalancerProfileManagedOutboundIPs - Desired managed outbound IPs for the cluster load balancer.

func (ManagedClusterLoadBalancerProfileManagedOutboundIPs) MarshalJSON 

func (m ManagedClusterLoadBalancerProfileManagedOutboundIPs) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterLoadBalancerProfileManagedOutboundIPs.

func (*ManagedClusterLoadBalancerProfileManagedOutboundIPs) UnmarshalJSON 

func (m *ManagedClusterLoadBalancerProfileManagedOutboundIPs) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterLoadBalancerProfileManagedOutboundIPs.

type ManagedClusterLoadBalancerProfileOutboundIPPrefixes 

type ManagedClusterLoadBalancerProfileOutboundIPPrefixes struct {
	// A list of public IP prefix resources.
	PublicIPPrefixes []*ResourceReference
}

ManagedClusterLoadBalancerProfileOutboundIPPrefixes - Desired outbound IP Prefix resources for the cluster load balancer.

func (ManagedClusterLoadBalancerProfileOutboundIPPrefixes) MarshalJSON 

func (m ManagedClusterLoadBalancerProfileOutboundIPPrefixes) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterLoadBalancerProfileOutboundIPPrefixes.

func (*ManagedClusterLoadBalancerProfileOutboundIPPrefixes) UnmarshalJSON 

func (m *ManagedClusterLoadBalancerProfileOutboundIPPrefixes) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterLoadBalancerProfileOutboundIPPrefixes.

type ManagedClusterLoadBalancerProfileOutboundIPs 

type ManagedClusterLoadBalancerProfileOutboundIPs struct {
	// A list of public IP resources.
	PublicIPs []*ResourceReference
}

ManagedClusterLoadBalancerProfileOutboundIPs - Desired outbound IP resources for the cluster load balancer.

func (ManagedClusterLoadBalancerProfileOutboundIPs) MarshalJSON 

func (m ManagedClusterLoadBalancerProfileOutboundIPs) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterLoadBalancerProfileOutboundIPs.

func (*ManagedClusterLoadBalancerProfileOutboundIPs) UnmarshalJSON 

func (m *ManagedClusterLoadBalancerProfileOutboundIPs) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterLoadBalancerProfileOutboundIPs.

type ManagedClusterManagedOutboundIPProfile 

type ManagedClusterManagedOutboundIPProfile struct {
	// The desired number of outbound IPs created/managed by Azure. Allowed values must be in the range of 1 to 16 (inclusive).
	// The default value is 1.
	Count *int32
}

ManagedClusterManagedOutboundIPProfile - Profile of the managed outbound IP resources of the managed cluster.

func (ManagedClusterManagedOutboundIPProfile) MarshalJSON 

func (m ManagedClusterManagedOutboundIPProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterManagedOutboundIPProfile.

func (*ManagedClusterManagedOutboundIPProfile) UnmarshalJSON 

func (m *ManagedClusterManagedOutboundIPProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterManagedOutboundIPProfile.

type ManagedClusterMetricsProfile 

type ManagedClusterMetricsProfile struct {
	// The cost analysis configuration for the cluster
	CostAnalysis *ManagedClusterCostAnalysis
}

ManagedClusterMetricsProfile - The metrics profile for the ManagedCluster.

func (ManagedClusterMetricsProfile) MarshalJSON 

func (m ManagedClusterMetricsProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterMetricsProfile.

func (*ManagedClusterMetricsProfile) UnmarshalJSON 

func (m *ManagedClusterMetricsProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterMetricsProfile.

type ManagedClusterNATGatewayProfile 

type ManagedClusterNATGatewayProfile struct {
	// The effective outbound IP resources of the cluster NAT gateway.
	EffectiveOutboundIPs []*ResourceReference

	// Desired outbound flow idle timeout in minutes. Allowed values are in the range of 4 to 120 (inclusive). The default value
	// is 4 minutes.
	IdleTimeoutInMinutes *int32

	// Profile of the managed outbound IP resources of the cluster NAT gateway.
	ManagedOutboundIPProfile *ManagedClusterManagedOutboundIPProfile
}

ManagedClusterNATGatewayProfile - Profile of the managed cluster NAT gateway.

func (ManagedClusterNATGatewayProfile) MarshalJSON 

func (m ManagedClusterNATGatewayProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterNATGatewayProfile.

func (*ManagedClusterNATGatewayProfile) UnmarshalJSON 

func (m *ManagedClusterNATGatewayProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterNATGatewayProfile.

type ManagedClusterNodeResourceGroupProfile added in v6.3.0 

type ManagedClusterNodeResourceGroupProfile struct {
	// The restriction level applied to the cluster's node resource group. If not specified, the default is 'Unrestricted'
	RestrictionLevel *RestrictionLevel
}

ManagedClusterNodeResourceGroupProfile - Node resource group lockdown profile for a managed cluster.

func (ManagedClusterNodeResourceGroupProfile) MarshalJSON added in v6.3.0 

func (m ManagedClusterNodeResourceGroupProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterNodeResourceGroupProfile.

func (*ManagedClusterNodeResourceGroupProfile) UnmarshalJSON added in v6.3.0 

func (m *ManagedClusterNodeResourceGroupProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterNodeResourceGroupProfile.

type ManagedClusterOIDCIssuerProfile 

type ManagedClusterOIDCIssuerProfile struct {
	// Whether the OIDC issuer is enabled.
	Enabled *bool

	// READ-ONLY; The OIDC issuer url of the Managed Cluster.
	IssuerURL *string
}

ManagedClusterOIDCIssuerProfile - The OIDC issuer profile of the Managed Cluster.

func (ManagedClusterOIDCIssuerProfile) MarshalJSON 

func (m ManagedClusterOIDCIssuerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterOIDCIssuerProfile.

func (*ManagedClusterOIDCIssuerProfile) UnmarshalJSON 

func (m *ManagedClusterOIDCIssuerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterOIDCIssuerProfile.

type ManagedClusterPodIdentity 

type ManagedClusterPodIdentity struct {
	// REQUIRED; The user assigned identity details.
	Identity *UserAssignedIdentity

	// REQUIRED; The name of the pod identity.
	Name *string

	// REQUIRED; The namespace of the pod identity.
	Namespace *string

	// The binding selector to use for the AzureIdentityBinding resource.
	BindingSelector *string

	// READ-ONLY
	ProvisioningInfo *ManagedClusterPodIdentityProvisioningInfo

	// READ-ONLY; The current provisioning state of the pod identity.
	ProvisioningState *ManagedClusterPodIdentityProvisioningState
}

ManagedClusterPodIdentity - Details about the pod identity assigned to the Managed Cluster.

func (ManagedClusterPodIdentity) MarshalJSON 

func (m ManagedClusterPodIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentity.

func (*ManagedClusterPodIdentity) UnmarshalJSON 

func (m *ManagedClusterPodIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentity.

type ManagedClusterPodIdentityException 

type ManagedClusterPodIdentityException struct {
	// REQUIRED; The name of the pod identity exception.
	Name *string

	// REQUIRED; The namespace of the pod identity exception.
	Namespace *string

	// REQUIRED; The pod labels to match.
	PodLabels map[string]*string
}

ManagedClusterPodIdentityException - See disable AAD Pod Identity for a specific Pod/Application [https://azure.github.io/aad-pod-identity/docs/configure/application_exception/] for more details.

func (ManagedClusterPodIdentityException) MarshalJSON 

func (m ManagedClusterPodIdentityException) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentityException.

func (*ManagedClusterPodIdentityException) UnmarshalJSON 

func (m *ManagedClusterPodIdentityException) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentityException.

type ManagedClusterPodIdentityProfile 

type ManagedClusterPodIdentityProfile struct {
	// Running in Kubenet is disabled by default due to the security related nature of AAD Pod Identity and the risks of IP spoofing.
	// See using Kubenet network plugin with AAD Pod Identity
	// [https://docs.microsoft.com/azure/aks/use-azure-ad-pod-identity#using-kubenet-network-plugin-with-azure-active-directory-pod-managed-identities]
	// for more information.
	AllowNetworkPluginKubenet *bool

	// Whether the pod identity addon is enabled.
	Enabled *bool

	// The pod identities to use in the cluster.
	UserAssignedIdentities []*ManagedClusterPodIdentity

	// The pod identity exceptions to allow.
	UserAssignedIdentityExceptions []*ManagedClusterPodIdentityException
}

ManagedClusterPodIdentityProfile - See use AAD pod identity [https://docs.microsoft.com/azure/aks/use-azure-ad-pod-identity] for more details on pod identity integration.

func (ManagedClusterPodIdentityProfile) MarshalJSON 

func (m ManagedClusterPodIdentityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentityProfile.

func (*ManagedClusterPodIdentityProfile) UnmarshalJSON 

func (m *ManagedClusterPodIdentityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentityProfile.

type ManagedClusterPodIdentityProvisioningError 

type ManagedClusterPodIdentityProvisioningError struct {
	// Details about the error.
	Error *ManagedClusterPodIdentityProvisioningErrorBody
}

ManagedClusterPodIdentityProvisioningError - An error response from the pod identity provisioning.

func (ManagedClusterPodIdentityProvisioningError) MarshalJSON 

func (m ManagedClusterPodIdentityProvisioningError) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentityProvisioningError.

func (*ManagedClusterPodIdentityProvisioningError) UnmarshalJSON 

func (m *ManagedClusterPodIdentityProvisioningError) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentityProvisioningError.

type ManagedClusterPodIdentityProvisioningErrorBody 

type ManagedClusterPodIdentityProvisioningErrorBody struct {
	// An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
	Code *string

	// A list of additional details about the error.
	Details []*ManagedClusterPodIdentityProvisioningErrorBody

	// A message describing the error, intended to be suitable for display in a user interface.
	Message *string

	// The target of the particular error. For example, the name of the property in error.
	Target *string
}

ManagedClusterPodIdentityProvisioningErrorBody - An error response from the pod identity provisioning.

func (ManagedClusterPodIdentityProvisioningErrorBody) MarshalJSON 

func (m ManagedClusterPodIdentityProvisioningErrorBody) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentityProvisioningErrorBody.

func (*ManagedClusterPodIdentityProvisioningErrorBody) UnmarshalJSON 

func (m *ManagedClusterPodIdentityProvisioningErrorBody) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentityProvisioningErrorBody.

type ManagedClusterPodIdentityProvisioningInfo 

type ManagedClusterPodIdentityProvisioningInfo struct {
	// Pod identity assignment error (if any).
	Error *ManagedClusterPodIdentityProvisioningError
}

func (ManagedClusterPodIdentityProvisioningInfo) MarshalJSON 

func (m ManagedClusterPodIdentityProvisioningInfo) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPodIdentityProvisioningInfo.

func (*ManagedClusterPodIdentityProvisioningInfo) UnmarshalJSON 

func (m *ManagedClusterPodIdentityProvisioningInfo) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPodIdentityProvisioningInfo.

type ManagedClusterPodIdentityProvisioningState 

type ManagedClusterPodIdentityProvisioningState string

ManagedClusterPodIdentityProvisioningState - The current provisioning state of the pod identity. 

const (
	ManagedClusterPodIdentityProvisioningStateAssigned  ManagedClusterPodIdentityProvisioningState = "Assigned"
	ManagedClusterPodIdentityProvisioningStateCanceled  ManagedClusterPodIdentityProvisioningState = "Canceled"
	ManagedClusterPodIdentityProvisioningStateDeleting  ManagedClusterPodIdentityProvisioningState = "Deleting"
	ManagedClusterPodIdentityProvisioningStateFailed    ManagedClusterPodIdentityProvisioningState = "Failed"
	ManagedClusterPodIdentityProvisioningStateSucceeded ManagedClusterPodIdentityProvisioningState = "Succeeded"
	ManagedClusterPodIdentityProvisioningStateUpdating  ManagedClusterPodIdentityProvisioningState = "Updating"
)

func PossibleManagedClusterPodIdentityProvisioningStateValues 

func PossibleManagedClusterPodIdentityProvisioningStateValues() []ManagedClusterPodIdentityProvisioningState

PossibleManagedClusterPodIdentityProvisioningStateValues returns the possible values for the ManagedClusterPodIdentityProvisioningState const type.

type ManagedClusterPoolUpgradeProfile 

type ManagedClusterPoolUpgradeProfile struct {
	// REQUIRED; The Kubernetes version (major.minor.patch).
	KubernetesVersion *string

	// REQUIRED; The operating system type. The default is Linux.
	OSType *OSType

	// The Agent Pool name.
	Name *string

	// List of orchestrator types and versions available for upgrade.
	Upgrades []*ManagedClusterPoolUpgradeProfileUpgradesItem
}

ManagedClusterPoolUpgradeProfile - The list of available upgrade versions.

func (ManagedClusterPoolUpgradeProfile) MarshalJSON 

func (m ManagedClusterPoolUpgradeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPoolUpgradeProfile.

func (*ManagedClusterPoolUpgradeProfile) UnmarshalJSON 

func (m *ManagedClusterPoolUpgradeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPoolUpgradeProfile.

type ManagedClusterPoolUpgradeProfileUpgradesItem 

type ManagedClusterPoolUpgradeProfileUpgradesItem struct {
	// Whether the Kubernetes version is currently in preview.
	IsPreview *bool

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string
}

func (ManagedClusterPoolUpgradeProfileUpgradesItem) MarshalJSON 

func (m ManagedClusterPoolUpgradeProfileUpgradesItem) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPoolUpgradeProfileUpgradesItem.

func (*ManagedClusterPoolUpgradeProfileUpgradesItem) UnmarshalJSON 

func (m *ManagedClusterPoolUpgradeProfileUpgradesItem) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPoolUpgradeProfileUpgradesItem.

type ManagedClusterProperties 

type ManagedClusterProperties struct {
	// The Azure Active Directory configuration.
	AADProfile *ManagedClusterAADProfile

	// The access profile for managed cluster API server.
	APIServerAccessProfile *ManagedClusterAPIServerAccessProfile

	// The profile of managed cluster add-on.
	AddonProfiles map[string]*ManagedClusterAddonProfile

	// The agent pool properties.
	AgentPoolProfiles []*ManagedClusterAgentPoolProfile

	// Parameters to be applied to the cluster-autoscaler when enabled
	AutoScalerProfile *ManagedClusterPropertiesAutoScalerProfile

	// The auto upgrade configuration.
	AutoUpgradeProfile *ManagedClusterAutoUpgradeProfile

	// Azure Monitor addon profiles for monitoring the managed cluster.
	AzureMonitorProfile *ManagedClusterAzureMonitorProfile

	// This cannot be updated once the Managed Cluster has been created.
	DNSPrefix *string

	// If set to true, getting static credentials will be disabled for this cluster. This must only be used on Managed Clusters
	// that are AAD enabled. For more details see disable local accounts
	// [https://docs.microsoft.com/azure/aks/managed-aad#disable-local-accounts-preview].
	DisableLocalAccounts *bool

	// This is of the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{encryptionSetName}'
	DiskEncryptionSetID *string

	// (DEPRECATED) Whether to enable Kubernetes pod security policy (preview). PodSecurityPolicy was deprecated in Kubernetes
	// v1.21, and removed from Kubernetes in v1.25. Learn more at
	// https://aka.ms/k8s/psp and https://aka.ms/aks/psp.
	EnablePodSecurityPolicy *bool

	// Whether to enable Kubernetes Role-Based Access Control.
	EnableRBAC *bool

	// This cannot be updated once the Managed Cluster has been created.
	FqdnSubdomain *string

	// Configurations for provisioning the cluster with HTTP proxy servers.
	HTTPProxyConfig *ManagedClusterHTTPProxyConfig

	// The user identity associated with the managed cluster. This identity will be used by the kubelet. Only one user assigned
	// identity is allowed. The only accepted key is "kubeletidentity", with value of
	// "resourceId": "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}".
	IdentityProfile map[string]*UserAssignedIdentity

	// Ingress profile for the managed cluster.
	IngressProfile *ManagedClusterIngressProfile

	// Both patch version (e.g. 1.20.13) and (e.g. 1.20) are supported. When is specified, the latest supported GA patch version
	// is chosen automatically. Updating the cluster with the same once it has been
	// created (e.g. 1.14.x -> 1.14) will not trigger an upgrade, even if a newer patch version is available. When you upgrade
	// a supported AKS cluster, Kubernetes minor versions cannot be skipped. All
	// upgrades must be performed sequentially by major version number. For example, upgrades between 1.14.x -> 1.15.x or 1.15.x
	// -> 1.16.x are allowed, however 1.14.x -> 1.16.x is not allowed. See upgrading
	// an AKS cluster [https://docs.microsoft.com/azure/aks/upgrade-cluster] for more details.
	KubernetesVersion *string

	// The profile for Linux VMs in the Managed Cluster.
	LinuxProfile *LinuxProfile

	// Optional cluster metrics configuration.
	MetricsProfile *ManagedClusterMetricsProfile

	// The network configuration profile.
	NetworkProfile *NetworkProfile

	// The name of the resource group containing agent pool nodes.
	NodeResourceGroup *string

	// Profile of the node resource group configuration.
	NodeResourceGroupProfile *ManagedClusterNodeResourceGroupProfile

	// The OIDC issuer profile of the Managed Cluster.
	OidcIssuerProfile *ManagedClusterOIDCIssuerProfile

	// See use AAD pod identity [https://docs.microsoft.com/azure/aks/use-azure-ad-pod-identity] for more details on AAD pod identity
	// integration.
	PodIdentityProfile *ManagedClusterPodIdentityProfile

	// Private link resources associated with the cluster.
	PrivateLinkResources []*PrivateLinkResource

	// Allow or deny public network access for AKS
	PublicNetworkAccess *PublicNetworkAccess

	// Security profile for the managed cluster.
	SecurityProfile *ManagedClusterSecurityProfile

	// Service mesh profile for a managed cluster.
	ServiceMeshProfile *ServiceMeshProfile

	// Information about a service principal identity for the cluster to use for manipulating Azure APIs.
	ServicePrincipalProfile *ManagedClusterServicePrincipalProfile

	// Storage profile for the managed cluster.
	StorageProfile *ManagedClusterStorageProfile

	// The support plan for the Managed Cluster. If unspecified, the default is 'KubernetesOfficial'.
	SupportPlan *KubernetesSupportPlan

	// Settings for upgrading a cluster.
	UpgradeSettings *ClusterUpgradeSettings

	// The profile for Windows VMs in the Managed Cluster.
	WindowsProfile *ManagedClusterWindowsProfile

	// Workload Auto-scaler profile for the managed cluster.
	WorkloadAutoScalerProfile *ManagedClusterWorkloadAutoScalerProfile

	// READ-ONLY; The Azure Portal requires certain Cross-Origin Resource Sharing (CORS) headers to be sent in some responses,
	// which Kubernetes APIServer doesn't handle by default. This special FQDN supports CORS,
	// allowing the Azure Portal to function properly.
	AzurePortalFQDN *string

	// READ-ONLY; If kubernetesVersion was a fully specified version , this field will be exactly equal to it. If kubernetesVersion
	// was , this field will contain the full version being used.
	CurrentKubernetesVersion *string

	// READ-ONLY; The FQDN of the master pool.
	Fqdn *string

	// READ-ONLY; The max number of agent pools for the managed cluster.
	MaxAgentPools *int32

	// READ-ONLY; The Power State of the cluster.
	PowerState *PowerState

	// READ-ONLY; The FQDN of private cluster.
	PrivateFQDN *string

	// READ-ONLY; The current provisioning state.
	ProvisioningState *string

	// READ-ONLY; The resourceUID uniquely identifies ManagedClusters that reuse ARM ResourceIds (i.e: create, delete, create
	// sequence)
	ResourceUID *string
}

ManagedClusterProperties - Properties of the managed cluster.

func (ManagedClusterProperties) MarshalJSON 

func (m ManagedClusterProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterProperties.

func (*ManagedClusterProperties) UnmarshalJSON 

func (m *ManagedClusterProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterProperties.

type ManagedClusterPropertiesAutoScalerProfile 

type ManagedClusterPropertiesAutoScalerProfile struct {
	// Valid values are 'true' and 'false'
	BalanceSimilarNodeGroups *string

	// If set to true, all daemonset pods on empty nodes will be evicted before deletion of the node. If the daemonset pod cannot
	// be evicted another node will be chosen for scaling. If set to false, the node
	// will be deleted without ensuring that daemonset pods are deleted or evicted.
	DaemonsetEvictionForEmptyNodes *bool

	// If set to true, all daemonset pods on occupied nodes will be evicted before deletion of the node. If the daemonset pod
	// cannot be evicted another node will be chosen for scaling. If set to false, the
	// node will be deleted without ensuring that daemonset pods are deleted or evicted.
	DaemonsetEvictionForOccupiedNodes *bool

	// If not specified, the default is 'random'. See expanders [https://github.com/kubernetes/autoscaler/blob/master/cluster-autoscaler/FAQ.md#what-are-expanders]
	// for more information.
	Expander *Expander

	// If set to true, the resources used by daemonset will be taken into account when making scaling down decisions.
	IgnoreDaemonsetsUtilization *bool

	// The default is 10.
	MaxEmptyBulkDelete *string

	// The default is 600.
	MaxGracefulTerminationSec *string

	// The default is '15m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
	MaxNodeProvisionTime *string

	// The default is 45. The maximum is 100 and the minimum is 0.
	MaxTotalUnreadyPercentage *string

	// For scenarios like burst/batch scale where you don't want CA to act before the kubernetes scheduler could schedule all
	// the pods, you can tell CA to ignore unscheduled pods before they're a certain
	// age. The default is '0s'. Values must be an integer followed by a unit ('s' for seconds, 'm' for minutes, 'h' for hours,
	// etc).
	NewPodScaleUpDelay *string

	// This must be an integer. The default is 3.
	OkTotalUnreadyCount *string

	// The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
	ScaleDownDelayAfterAdd *string

	// The default is the scan-interval. Values must be an integer followed by an 'm'. No unit of time other than minutes (m)
	// is supported.
	ScaleDownDelayAfterDelete *string

	// The default is '3m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
	ScaleDownDelayAfterFailure *string

	// The default is '10m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
	ScaleDownUnneededTime *string

	// The default is '20m'. Values must be an integer followed by an 'm'. No unit of time other than minutes (m) is supported.
	ScaleDownUnreadyTime *string

	// The default is '0.5'.
	ScaleDownUtilizationThreshold *string

	// The default is '10'. Values must be an integer number of seconds.
	ScanInterval *string

	// The default is true.
	SkipNodesWithLocalStorage *string

	// The default is true.
	SkipNodesWithSystemPods *string
}

ManagedClusterPropertiesAutoScalerProfile - Parameters to be applied to the cluster-autoscaler when enabled

func (ManagedClusterPropertiesAutoScalerProfile) MarshalJSON 

func (m ManagedClusterPropertiesAutoScalerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterPropertiesAutoScalerProfile.

func (*ManagedClusterPropertiesAutoScalerProfile) UnmarshalJSON 

func (m *ManagedClusterPropertiesAutoScalerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterPropertiesAutoScalerProfile.

type ManagedClusterSKU 

type ManagedClusterSKU struct {
	// The name of a managed cluster SKU.
	Name *ManagedClusterSKUName

	// If not specified, the default is 'Free'. See AKS Pricing Tier [https://learn.microsoft.com/azure/aks/free-standard-pricing-tiers]
	// for more details.
	Tier *ManagedClusterSKUTier
}

ManagedClusterSKU - The SKU of a Managed Cluster.

func (ManagedClusterSKU) MarshalJSON 

func (m ManagedClusterSKU) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSKU.

func (*ManagedClusterSKU) UnmarshalJSON 

func (m *ManagedClusterSKU) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSKU.

type ManagedClusterSKUName 

type ManagedClusterSKUName string

ManagedClusterSKUName - The name of a managed cluster SKU. 

const (
	// ManagedClusterSKUNameBase - Base option for the AKS control plane.
	ManagedClusterSKUNameBase ManagedClusterSKUName = "Base"
)

func PossibleManagedClusterSKUNameValues 

func PossibleManagedClusterSKUNameValues() []ManagedClusterSKUName

PossibleManagedClusterSKUNameValues returns the possible values for the ManagedClusterSKUName const type.

type ManagedClusterSKUTier 

type ManagedClusterSKUTier string

ManagedClusterSKUTier - If not specified, the default is 'Free'. See AKS Pricing Tier [https://learn.microsoft.com/azure/aks/free-standard-pricing-tiers] for more details. 

const (
	// ManagedClusterSKUTierFree - The cluster management is free, but charged for VM, storage, and networking usage. Best for
	// experimenting, learning, simple testing, or workloads with fewer than 10 nodes. Not recommended for production use cases.
	ManagedClusterSKUTierFree ManagedClusterSKUTier = "Free"
	// ManagedClusterSKUTierPremium - Cluster has premium capabilities in addition to all of the capabilities included in 'Standard'.
	// Premium enables selection of LongTermSupport (aka.ms/aks/lts) for certain Kubernetes versions.
	ManagedClusterSKUTierPremium ManagedClusterSKUTier = "Premium"
	// ManagedClusterSKUTierStandard - Recommended for mission-critical and production workloads. Includes Kubernetes control
	// plane autoscaling, workload-intensive testing, and up to 5,000 nodes per cluster. Guarantees 99.95% availability of the
	// Kubernetes API server endpoint for clusters that use Availability Zones and 99.9% of availability for clusters that don't
	// use Availability Zones.
	ManagedClusterSKUTierStandard ManagedClusterSKUTier = "Standard"
)

func PossibleManagedClusterSKUTierValues 

func PossibleManagedClusterSKUTierValues() []ManagedClusterSKUTier

PossibleManagedClusterSKUTierValues returns the possible values for the ManagedClusterSKUTier const type.

type ManagedClusterSecurityProfile 

type ManagedClusterSecurityProfile struct {
	// Azure Key Vault key management service [https://kubernetes.io/docs/tasks/administer-cluster/kms-provider/] settings for
	// the security profile.
	AzureKeyVaultKms *AzureKeyVaultKms

	// Microsoft Defender settings for the security profile.
	Defender *ManagedClusterSecurityProfileDefender

	// Image Cleaner settings for the security profile.
	ImageCleaner *ManagedClusterSecurityProfileImageCleaner

	// Workload identity settings for the security profile. Workload identity enables Kubernetes applications to access Azure
	// cloud resources securely with Azure AD. See https://aka.ms/aks/wi for more
	// details.
	WorkloadIdentity *ManagedClusterSecurityProfileWorkloadIdentity
}

ManagedClusterSecurityProfile - Security profile for the container service cluster.

func (ManagedClusterSecurityProfile) MarshalJSON 

func (m ManagedClusterSecurityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSecurityProfile.

func (*ManagedClusterSecurityProfile) UnmarshalJSON 

func (m *ManagedClusterSecurityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSecurityProfile.

type ManagedClusterSecurityProfileDefender 

type ManagedClusterSecurityProfileDefender struct {
	// Resource ID of the Log Analytics workspace to be associated with Microsoft Defender. When Microsoft Defender is enabled,
	// this field is required and must be a valid workspace resource ID. When
	// Microsoft Defender is disabled, leave the field empty.
	LogAnalyticsWorkspaceResourceID *string

	// Microsoft Defender threat detection for Cloud settings for the security profile.
	SecurityMonitoring *ManagedClusterSecurityProfileDefenderSecurityMonitoring
}

ManagedClusterSecurityProfileDefender - Microsoft Defender settings for the security profile.

func (ManagedClusterSecurityProfileDefender) MarshalJSON 

func (m ManagedClusterSecurityProfileDefender) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSecurityProfileDefender.

func (*ManagedClusterSecurityProfileDefender) UnmarshalJSON 

func (m *ManagedClusterSecurityProfileDefender) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSecurityProfileDefender.

type ManagedClusterSecurityProfileDefenderSecurityMonitoring 

type ManagedClusterSecurityProfileDefenderSecurityMonitoring struct {
	// Whether to enable Defender threat detection
	Enabled *bool
}

ManagedClusterSecurityProfileDefenderSecurityMonitoring - Microsoft Defender settings for the security profile threat detection.

func (ManagedClusterSecurityProfileDefenderSecurityMonitoring) MarshalJSON 

func (m ManagedClusterSecurityProfileDefenderSecurityMonitoring) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSecurityProfileDefenderSecurityMonitoring.

func (*ManagedClusterSecurityProfileDefenderSecurityMonitoring) UnmarshalJSON 

func (m *ManagedClusterSecurityProfileDefenderSecurityMonitoring) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSecurityProfileDefenderSecurityMonitoring.

type ManagedClusterSecurityProfileImageCleaner 

type ManagedClusterSecurityProfileImageCleaner struct {
	// Whether to enable Image Cleaner on AKS cluster.
	Enabled *bool

	// Image Cleaner scanning interval in hours.
	IntervalHours *int32
}

ManagedClusterSecurityProfileImageCleaner - Image Cleaner removes unused images from nodes, freeing up disk space and helping to reduce attack surface area. Here are settings for the security profile.

func (ManagedClusterSecurityProfileImageCleaner) MarshalJSON 

func (m ManagedClusterSecurityProfileImageCleaner) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSecurityProfileImageCleaner.

func (*ManagedClusterSecurityProfileImageCleaner) UnmarshalJSON 

func (m *ManagedClusterSecurityProfileImageCleaner) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSecurityProfileImageCleaner.

type ManagedClusterSecurityProfileWorkloadIdentity 

type ManagedClusterSecurityProfileWorkloadIdentity struct {
	// Whether to enable workload identity.
	Enabled *bool
}

ManagedClusterSecurityProfileWorkloadIdentity - Workload identity settings for the security profile.

func (ManagedClusterSecurityProfileWorkloadIdentity) MarshalJSON 

func (m ManagedClusterSecurityProfileWorkloadIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterSecurityProfileWorkloadIdentity.

func (*ManagedClusterSecurityProfileWorkloadIdentity) UnmarshalJSON 

func (m *ManagedClusterSecurityProfileWorkloadIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterSecurityProfileWorkloadIdentity.

type ManagedClusterServicePrincipalProfile 

type ManagedClusterServicePrincipalProfile struct {
	// REQUIRED; The ID for the service principal.
	ClientID *string

	// The secret password associated with the service principal in plain text.
	Secret *string
}

ManagedClusterServicePrincipalProfile - Information about a service principal identity for the cluster to use for manipulating Azure APIs.

func (ManagedClusterServicePrincipalProfile) MarshalJSON 

func (m ManagedClusterServicePrincipalProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterServicePrincipalProfile.

func (*ManagedClusterServicePrincipalProfile) UnmarshalJSON 

func (m *ManagedClusterServicePrincipalProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterServicePrincipalProfile.

type ManagedClusterStorageProfile 

type ManagedClusterStorageProfile struct {
	// AzureBlob CSI Driver settings for the storage profile.
	BlobCSIDriver *ManagedClusterStorageProfileBlobCSIDriver

	// AzureDisk CSI Driver settings for the storage profile.
	DiskCSIDriver *ManagedClusterStorageProfileDiskCSIDriver

	// AzureFile CSI Driver settings for the storage profile.
	FileCSIDriver *ManagedClusterStorageProfileFileCSIDriver

	// Snapshot Controller settings for the storage profile.
	SnapshotController *ManagedClusterStorageProfileSnapshotController
}

ManagedClusterStorageProfile - Storage profile for the container service cluster.

func (ManagedClusterStorageProfile) MarshalJSON 

func (m ManagedClusterStorageProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterStorageProfile.

func (*ManagedClusterStorageProfile) UnmarshalJSON 

func (m *ManagedClusterStorageProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterStorageProfile.

type ManagedClusterStorageProfileBlobCSIDriver 

type ManagedClusterStorageProfileBlobCSIDriver struct {
	// Whether to enable AzureBlob CSI Driver. The default value is false.
	Enabled *bool
}

ManagedClusterStorageProfileBlobCSIDriver - AzureBlob CSI Driver settings for the storage profile.

func (ManagedClusterStorageProfileBlobCSIDriver) MarshalJSON 

func (m ManagedClusterStorageProfileBlobCSIDriver) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterStorageProfileBlobCSIDriver.

func (*ManagedClusterStorageProfileBlobCSIDriver) UnmarshalJSON 

func (m *ManagedClusterStorageProfileBlobCSIDriver) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterStorageProfileBlobCSIDriver.

type ManagedClusterStorageProfileDiskCSIDriver 

type ManagedClusterStorageProfileDiskCSIDriver struct {
	// Whether to enable AzureDisk CSI Driver. The default value is true.
	Enabled *bool
}

ManagedClusterStorageProfileDiskCSIDriver - AzureDisk CSI Driver settings for the storage profile.

func (ManagedClusterStorageProfileDiskCSIDriver) MarshalJSON 

func (m ManagedClusterStorageProfileDiskCSIDriver) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterStorageProfileDiskCSIDriver.

func (*ManagedClusterStorageProfileDiskCSIDriver) UnmarshalJSON 

func (m *ManagedClusterStorageProfileDiskCSIDriver) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterStorageProfileDiskCSIDriver.

type ManagedClusterStorageProfileFileCSIDriver 

type ManagedClusterStorageProfileFileCSIDriver struct {
	// Whether to enable AzureFile CSI Driver. The default value is true.
	Enabled *bool
}

ManagedClusterStorageProfileFileCSIDriver - AzureFile CSI Driver settings for the storage profile.

func (ManagedClusterStorageProfileFileCSIDriver) MarshalJSON 

func (m ManagedClusterStorageProfileFileCSIDriver) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterStorageProfileFileCSIDriver.

func (*ManagedClusterStorageProfileFileCSIDriver) UnmarshalJSON 

func (m *ManagedClusterStorageProfileFileCSIDriver) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterStorageProfileFileCSIDriver.

type ManagedClusterStorageProfileSnapshotController 

type ManagedClusterStorageProfileSnapshotController struct {
	// Whether to enable Snapshot Controller. The default value is true.
	Enabled *bool
}

ManagedClusterStorageProfileSnapshotController - Snapshot Controller settings for the storage profile.

func (ManagedClusterStorageProfileSnapshotController) MarshalJSON 

func (m ManagedClusterStorageProfileSnapshotController) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterStorageProfileSnapshotController.

func (*ManagedClusterStorageProfileSnapshotController) UnmarshalJSON 

func (m *ManagedClusterStorageProfileSnapshotController) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterStorageProfileSnapshotController.

type ManagedClusterUpgradeProfile 

type ManagedClusterUpgradeProfile struct {
	// REQUIRED; The properties of the upgrade profile.
	Properties *ManagedClusterUpgradeProfileProperties

	// READ-ONLY; The ID of the upgrade profile.
	ID *string

	// READ-ONLY; The name of the upgrade profile.
	Name *string

	// READ-ONLY; The type of the upgrade profile.
	Type *string
}

ManagedClusterUpgradeProfile - The list of available upgrades for compute pools.

func (ManagedClusterUpgradeProfile) MarshalJSON 

func (m ManagedClusterUpgradeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterUpgradeProfile.

func (*ManagedClusterUpgradeProfile) UnmarshalJSON 

func (m *ManagedClusterUpgradeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterUpgradeProfile.

type ManagedClusterUpgradeProfileProperties 

type ManagedClusterUpgradeProfileProperties struct {
	// REQUIRED; The list of available upgrade versions for agent pools.
	AgentPoolProfiles []*ManagedClusterPoolUpgradeProfile

	// REQUIRED; The list of available upgrade versions for the control plane.
	ControlPlaneProfile *ManagedClusterPoolUpgradeProfile
}

ManagedClusterUpgradeProfileProperties - Control plane and agent pool upgrade profiles.

func (ManagedClusterUpgradeProfileProperties) MarshalJSON 

func (m ManagedClusterUpgradeProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterUpgradeProfileProperties.

func (*ManagedClusterUpgradeProfileProperties) UnmarshalJSON 

func (m *ManagedClusterUpgradeProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterUpgradeProfileProperties.

type ManagedClusterWindowsProfile 

type ManagedClusterWindowsProfile struct {
	// REQUIRED; Specifies the name of the administrator account.
	// Restriction: Cannot end in "."
	// Disallowed values: "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3", "admin1", "1", "123",
	// "a", "actuser", "adm", "admin2", "aspnet", "backup", "console", "david", "guest",
	// "john", "owner", "root", "server", "sql", "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5".
	// Minimum-length: 1 character
	// Max-length: 20 characters
	AdminUsername *string

	// Specifies the password of the administrator account.
	// Minimum-length: 8 characters
	// Max-length: 123 characters
	// Complexity requirements: 3 out of 4 conditions below need to be fulfilled
	// Has lower characters
	// Has upper characters
	// Has a digit
	// Has a special character (Regex match [\W_])
	// Disallowed values: "abc@123", "P@$$w0rd", "P@ssw0rd", "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1",
	// "Password22", "iloveyou!"
	AdminPassword *string

	// For more details on CSI proxy, see the CSI proxy GitHub repo [https://github.com/kubernetes-csi/csi-proxy].
	EnableCSIProxy *bool

	// The Windows gMSA Profile in the Managed Cluster.
	GmsaProfile *WindowsGmsaProfile

	// The license type to use for Windows VMs. See Azure Hybrid User Benefits [https://azure.microsoft.com/pricing/hybrid-benefit/faq/]
	// for more details.
	LicenseType *LicenseType
}

ManagedClusterWindowsProfile - Profile for Windows VMs in the managed cluster.

func (ManagedClusterWindowsProfile) MarshalJSON 

func (m ManagedClusterWindowsProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterWindowsProfile.

func (*ManagedClusterWindowsProfile) UnmarshalJSON 

func (m *ManagedClusterWindowsProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterWindowsProfile.

type ManagedClusterWorkloadAutoScalerProfile 

type ManagedClusterWorkloadAutoScalerProfile struct {
	// KEDA (Kubernetes Event-driven Autoscaling) settings for the workload auto-scaler profile.
	Keda *ManagedClusterWorkloadAutoScalerProfileKeda

	// VPA (Vertical Pod Autoscaler) settings for the workload auto-scaler profile.
	VerticalPodAutoscaler *ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler
}

ManagedClusterWorkloadAutoScalerProfile - Workload Auto-scaler profile for the managed cluster.

func (ManagedClusterWorkloadAutoScalerProfile) MarshalJSON 

func (m ManagedClusterWorkloadAutoScalerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterWorkloadAutoScalerProfile.

func (*ManagedClusterWorkloadAutoScalerProfile) UnmarshalJSON 

func (m *ManagedClusterWorkloadAutoScalerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterWorkloadAutoScalerProfile.

type ManagedClusterWorkloadAutoScalerProfileKeda 

type ManagedClusterWorkloadAutoScalerProfileKeda struct {
	// REQUIRED; Whether to enable KEDA.
	Enabled *bool
}

ManagedClusterWorkloadAutoScalerProfileKeda - KEDA (Kubernetes Event-driven Autoscaling) settings for the workload auto-scaler profile.

func (ManagedClusterWorkloadAutoScalerProfileKeda) MarshalJSON 

func (m ManagedClusterWorkloadAutoScalerProfileKeda) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterWorkloadAutoScalerProfileKeda.

func (*ManagedClusterWorkloadAutoScalerProfileKeda) UnmarshalJSON 

func (m *ManagedClusterWorkloadAutoScalerProfileKeda) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterWorkloadAutoScalerProfileKeda.

type ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler 

type ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler struct {
	// REQUIRED; Whether to enable VPA. Default value is false.
	Enabled *bool
}

ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler - VPA (Vertical Pod Autoscaler) settings for the workload auto-scaler profile.

func (ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler) MarshalJSON 

func (m ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler.

func (*ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler) UnmarshalJSON 

func (m *ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedClusterWorkloadAutoScalerProfileVerticalPodAutoscaler.

type ManagedClustersClient 

type ManagedClustersClient struct {
	// contains filtered or unexported fields
}

ManagedClustersClient contains the methods for the ManagedClusters group. Don't use this type directly, use NewManagedClustersClient() instead.

func NewManagedClustersClient 

func NewManagedClustersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ManagedClustersClient, error)

NewManagedClustersClient creates a new instance of ManagedClustersClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ManagedClustersClient) BeginAbortLatestOperation 

func (client *ManagedClustersClient) BeginAbortLatestOperation(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginAbortLatestOperationOptions) (*runtime.Poller[ManagedClustersClientAbortLatestOperationResponse], error)

BeginAbortLatestOperation - Aborts the currently running operation on the managed cluster. The Managed Cluster will be moved to a Canceling state and eventually to a Canceled state when cancellation finishes. If the operation completes before cancellation can take place, a 409 error code is returned. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginAbortLatestOperationOptions contains the optional parameters for the ManagedClustersClient.BeginAbortLatestOperation method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersAbortOperation.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginAbortLatestOperation(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginCreateOrUpdate 

func (client *ManagedClustersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedCluster, options *ManagedClustersClientBeginCreateOrUpdateOptions) (*runtime.Poller[ManagedClustersClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - The managed cluster to create or update.
  • options - ManagedClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the ManagedClustersClient.BeginCreateOrUpdate method.
Example (CreateManagedClusterUsingAnAgentPoolSnapshot)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_Snapshot.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:  to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count: to.Ptr[int32](3),
				CreationData: &armcontainerservice.CreationData{
					SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
				},
				EnableFIPS:         to.Ptr(true),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(false),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CreationData: &armcontainerservice.CreationData{
// 					SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
// 				},
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableFIPS: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(false),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithAksManagedNatGatewayAsOutboundType)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_ManagedNATGateway.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(false),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			NatGatewayProfile: &armcontainerservice.ManagedClusterNATGatewayProfile{
				ManagedOutboundIPProfile: &armcontainerservice.ManagedClusterManagedOutboundIPProfile{
					Count: to.Ptr[int32](2),
				},
			},
			OutboundType: to.Ptr(armcontainerservice.OutboundTypeManagedNATGateway),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(false),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 			NatGatewayProfile: &armcontainerservice.ManagedClusterNATGatewayProfile{
// 				EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 					},
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 				}},
// 				IdleTimeoutInMinutes: to.Ptr[int32](4),
// 				ManagedOutboundIPProfile: &armcontainerservice.ManagedClusterManagedOutboundIPProfile{
// 					Count: to.Ptr[int32](2),
// 				},
// 			},
// 			NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 			OutboundType: to.Ptr(armcontainerservice.OutboundTypeManagedNATGateway),
// 			PodCidr: to.Ptr("10.244.0.0/16"),
// 			ServiceCidr: to.Ptr("10.0.0.0/16"),
// 		},
// 		NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 			ClientID: to.Ptr("clientid"),
// 		},
// 		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 		},
// 	},
// }

Output:
Example (CreateManagedClusterWithAzureKeyVaultSecretsProviderAddon)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_AzureKeyvaultSecretsProvider.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{
			"azureKeyvaultSecretsProvider": {
				Config: map[string]*string{
					"enableSecretRotation": to.Ptr("true"),
					"rotationPollInterval": to.Ptr("2m"),
				},
				Enabled: to.Ptr(true),
			},
		},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{
// 			"azureKeyvaultSecretsProvider": &armcontainerservice.ManagedClusterAddonProfile{
// 				Config: map[string]*string{
// 					"enableSecretRotation": to.Ptr("true"),
// 					"rotationPollInterval": to.Ptr("2m"),
// 				},
// 				Enabled: to.Ptr(true),
// 			},
// 		},
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 				AllocatedOutboundPorts: to.Ptr[int32](2000),
// 				EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 					},
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 				}},
// 				IdleTimeoutInMinutes: to.Ptr[int32](10),
// 				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 					Count: to.Ptr[int32](2),
// 				},
// 			},
// 			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 			NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 			OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 			PodCidr: to.Ptr("10.244.0.0/16"),
// 			ServiceCidr: to.Ptr("10.0.0.0/16"),
// 		},
// 		NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 			ClientID: to.Ptr("clientid"),
// 		},
// 		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 		},
// 	},
// }

Output:
Example (CreateManagedClusterWithCapacityReservationGroup)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_CRG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                       to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				CapacityReservationGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/capacityReservationGroups/crg1"),
				Count:                      to.Ptr[int32](3),
				EnableNodePublicIP:         to.Ptr(true),
				Mode:                       to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                     to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                     to.Ptr("Standard_DS2_v2"),
				Name:                       to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				CapacityReservationGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/capacityReservationGroups/crg1"),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithDedicatedHostGroup)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_DedicatedHostGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				HostGroupID:        to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(false),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				EnableNodePublicIP: to.Ptr(true),
// 				HostGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg/providers/Microsoft.Compute/hostGroups/hostgroup1"),
// 				MaxPods: to.Ptr[int32](110),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(false),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithEncryptionAtHostEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_EnableEncryptionAtHost.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                   to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                  to.Ptr[int32](3),
				EnableEncryptionAtHost: to.Ptr(true),
				EnableNodePublicIP:     to.Ptr(true),
				Mode:                   to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                 to.Ptr("Standard_DS2_v2"),
				Name:                   to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithFipsEnabledOs)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_EnabledFIPS.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableFIPS:         to.Ptr(true),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(false),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableFIPS: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(false),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithGpumig)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_GPUMIG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				GpuInstanceProfile: to.Ptr(armcontainerservice.GPUInstanceProfileMIG3G),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_ND96asr_v4"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
			HTTPProxy:  to.Ptr("http://myproxy.server.com:8080"),
			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
			NoProxy: []*string{
				to.Ptr("localhost"),
				to.Ptr("127.0.0.1")},
			TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
		},
		KubernetesVersion: to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				GpuInstanceProfile: to.Ptr(armcontainerservice.GPUInstanceProfileMIG3G),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_ND96asr_v4"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
// 			HTTPProxy: to.Ptr("http://myproxy.server.com:8080"),
// 			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
// 			NoProxy: []*string{
// 				to.Ptr("localhost"),
// 				to.Ptr("127.0.0.1")},
// 				TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
// 			},
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateManagedClusterWithHttpProxyConfigured)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_HTTPProxy.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
			HTTPProxy:  to.Ptr("http://myproxy.server.com:8080"),
			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
			NoProxy: []*string{
				to.Ptr("localhost"),
				to.Ptr("127.0.0.1")},
			TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
		},
		KubernetesVersion: to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
// 			HTTPProxy: to.Ptr("http://myproxy.server.com:8080"),
// 			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
// 			NoProxy: []*string{
// 				to.Ptr("localhost"),
// 				to.Ptr("127.0.0.1")},
// 				TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
// 			},
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateManagedClusterWithLongTermSupport)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_Premium.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                   to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                  to.Ptr[int32](3),
				EnableEncryptionAtHost: to.Ptr(true),
				EnableNodePublicIP:     to.Ptr(true),
				Mode:                   to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                 to.Ptr("Standard_DS2_v2"),
				Name:                   to.Ptr("nodepool1"),
			}},
		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
			DisableRunCommand: to.Ptr(true),
		},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		SupportPlan: to.Ptr(armcontainerservice.KubernetesSupportPlanAKSLongTermSupport),
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUNameBase),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierPremium),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
// 			DisableRunCommand: to.Ptr(true),
// 		},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-ee788a1f.hcp.location1.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					PrivateFQDN: to.Ptr("dnsprefix1-aae7e0f0.5cef6058-b6b5-414d-8cb1-4bd14eb0b15c.privatelink.location1.azmk8s.io"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					SupportPlan: to.Ptr(armcontainerservice.KubernetesSupportPlanAKSLongTermSupport),
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 				SKU: &armcontainerservice.ManagedClusterSKU{
// 					Name: to.Ptr(armcontainerservice.ManagedClusterSKUNameBase),
// 					Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierPremium),
// 				},
// 			}

Output:
Example (CreateManagedClusterWithNodePublicIpPrefix)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_NodePublicIPPrefix.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                 to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                to.Ptr[int32](3),
				EnableNodePublicIP:   to.Ptr(true),
				Mode:                 to.Ptr(armcontainerservice.AgentPoolModeSystem),
				NodePublicIPPrefixID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
				OSType:               to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:               to.Ptr("Standard_DS2_v2"),
				Name:                 to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				NodePublicIPPrefixID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/publicIPPrefixes/public-ip-prefix"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithOssku)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_OSSKU.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSSKU:              to.Ptr(armcontainerservice.OSSKUAzureLinux),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
			HTTPProxy:  to.Ptr("http://myproxy.server.com:8080"),
			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
			NoProxy: []*string{
				to.Ptr("localhost"),
				to.Ptr("127.0.0.1")},
			TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
		},
		KubernetesVersion: to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSSKU: to.Ptr(armcontainerservice.OSSKUAzureLinux),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		HTTPProxyConfig: &armcontainerservice.ManagedClusterHTTPProxyConfig{
// 			HTTPProxy: to.Ptr("http://myproxy.server.com:8080"),
// 			HTTPSProxy: to.Ptr("https://myproxy.server.com:8080"),
// 			NoProxy: []*string{
// 				to.Ptr("localhost"),
// 				to.Ptr("127.0.0.1")},
// 				TrustedCa: to.Ptr("Q29uZ3JhdHMhIFlvdSBoYXZlIGZvdW5kIGEgaGlkZGVuIG1lc3NhZ2U="),
// 			},
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateManagedClusterWithPodIdentityEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_PodIdentity.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		PodIdentityProfile: &armcontainerservice.ManagedClusterPodIdentityProfile{
			AllowNetworkPluginKubenet: to.Ptr(true),
			Enabled:                   to.Ptr(true),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					PodIdentityProfile: &armcontainerservice.ManagedClusterPodIdentityProfile{
// 						AllowNetworkPluginKubenet: to.Ptr(true),
// 						Enabled: to.Ptr(true),
// 					},
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithPpg)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_PPG.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                      to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                     to.Ptr[int32](3),
				EnableNodePublicIP:        to.Ptr(true),
				Mode:                      to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                    to.Ptr(armcontainerservice.OSTypeLinux),
				ProximityPlacementGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
				VMSize:                    to.Ptr("Standard_DS2_v2"),
				Name:                      to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				ProximityPlacementGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/proximityPlacementGroups/ppg1"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithRunCommandDisabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_DisableRunCommand.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                   to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                  to.Ptr[int32](3),
				EnableEncryptionAtHost: to.Ptr(true),
				EnableNodePublicIP:     to.Ptr(true),
				Mode:                   to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                 to.Ptr("Standard_DS2_v2"),
				Name:                   to.Ptr("nodepool1"),
			}},
		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
			DisableRunCommand: to.Ptr(true),
		},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
// 			DisableRunCommand: to.Ptr(true),
// 		},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-ee788a1f.hcp.location1.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					PrivateFQDN: to.Ptr("dnsprefix1-aae7e0f0.5cef6058-b6b5-414d-8cb1-4bd14eb0b15c.privatelink.location1.azmk8s.io"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					SupportPlan: to.Ptr(armcontainerservice.KubernetesSupportPlanKubernetesOfficial),
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithSecurityProfileConfigured)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_SecurityProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		DNSPrefix:         to.Ptr("dnsprefix1"),
		KubernetesVersion: to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		SecurityProfile: &armcontainerservice.ManagedClusterSecurityProfile{
			Defender: &armcontainerservice.ManagedClusterSecurityProfileDefender{
				LogAnalyticsWorkspaceResourceID: to.Ptr("/subscriptions/SUB_ID/resourcegroups/RG_NAME/providers/microsoft.operationalinsights/workspaces/WORKSPACE_NAME"),
				SecurityMonitoring: &armcontainerservice.ManagedClusterSecurityProfileDefenderSecurityMonitoring{
					Enabled: to.Ptr(true),
				},
			},
			WorkloadIdentity: &armcontainerservice.ManagedClusterSecurityProfileWorkloadIdentity{
				Enabled: to.Ptr(true),
			},
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					SecurityProfile: &armcontainerservice.ManagedClusterSecurityProfile{
// 						Defender: &armcontainerservice.ManagedClusterSecurityProfileDefender{
// 							LogAnalyticsWorkspaceResourceID: to.Ptr("/subscriptions/SUB_ID/resourcegroups/RG_NAME/providers/microsoft.operationalinsights/workspaces/WORKSPACE_NAME"),
// 							SecurityMonitoring: &armcontainerservice.ManagedClusterSecurityProfileDefenderSecurityMonitoring{
// 								Enabled: to.Ptr(true),
// 							},
// 						},
// 						WorkloadIdentity: &armcontainerservice.ManagedClusterSecurityProfileWorkloadIdentity{
// 							Enabled: to.Ptr(true),
// 						},
// 					},
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithUltraSsdEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_EnableUltraSSD.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				EnableUltraSSD:     to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(true),
// 				EnableUltraSSD: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedClusterWithUserAssignedNatGatewayAsOutboundType)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_UserAssignedNATGateway.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(false),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeUserAssignedNATGateway),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableNodePublicIP: to.Ptr(false),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 			NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 			OutboundType: to.Ptr(armcontainerservice.OutboundTypeUserAssignedNATGateway),
// 			PodCidr: to.Ptr("10.244.0.0/16"),
// 			ServiceCidr: to.Ptr("10.0.0.0/16"),
// 		},
// 		NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 			ClientID: to.Ptr("clientid"),
// 		},
// 		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 		},
// 	},
// }

Output:
Example (CreateManagedClusterWithWebAppRoutingIngressProfileConfigured)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_IngressProfile_WebAppRouting.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		DNSPrefix: to.Ptr("dnsprefix1"),
		IngressProfile: &armcontainerservice.ManagedClusterIngressProfile{
			WebAppRouting: &armcontainerservice.ManagedClusterIngressProfileWebAppRouting{
				DNSZoneResourceIDs: []*string{
					to.Ptr("/subscriptions/SUB_ID/resourceGroups/RG_NAME/providers/Microsoft.Network/dnszones/DNS_ZONE_NAME")},
				Enabled: to.Ptr(true),
			},
		},
		KubernetesVersion: to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		IngressProfile: &armcontainerservice.ManagedClusterIngressProfile{
// 			WebAppRouting: &armcontainerservice.ManagedClusterIngressProfileWebAppRouting{
// 				DNSZoneResourceIDs: []*string{
// 					to.Ptr("/subscriptions/SUB_ID/resourceGroups/RG_NAME/providers/Microsoft.Network/dnszones/DNS_ZONE_NAME")},
// 					Enabled: to.Ptr(true),
// 				},
// 			},
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateManagedPrivateClusterWithFqdnSubdomainSpecified)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_PrivateClusterFQDNSubdomain.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                   to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                  to.Ptr[int32](3),
				EnableEncryptionAtHost: to.Ptr(true),
				EnableNodePublicIP:     to.Ptr(true),
				Mode:                   to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                 to.Ptr("Standard_DS2_v2"),
				Name:                   to.Ptr("nodepool1"),
			}},
		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
			EnablePrivateCluster: to.Ptr(true),
			PrivateDNSZone:       to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io"),
		},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		FqdnSubdomain:           to.Ptr("domain1"),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
// 			EnablePrivateCluster: to.Ptr(true),
// 			PrivateDNSZone: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/privateDnsZones/privatelink.location1.azmk8s.io"),
// 		},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		FqdnSubdomain: to.Ptr("domain1"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					PrivateFQDN: to.Ptr("domain1.privatelink.location1.azmk8s.io"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateManagedPrivateClusterWithPublicFqdnSpecified)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_PrivateClusterPublicFQDN.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:                   to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:                  to.Ptr[int32](3),
				EnableEncryptionAtHost: to.Ptr(true),
				EnableNodePublicIP:     to.Ptr(true),
				Mode:                   to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:                 to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:                 to.Ptr("Standard_DS2_v2"),
				Name:                   to.Ptr("nodepool1"),
			}},
		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
			EnablePrivateCluster:           to.Ptr(true),
			EnablePrivateClusterPublicFQDN: to.Ptr(true),
		},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		APIServerAccessProfile: &armcontainerservice.ManagedClusterAPIServerAccessProfile{
// 			EnablePrivateCluster: to.Ptr(true),
// 			EnablePrivateClusterPublicFQDN: to.Ptr(true),
// 			PrivateDNSZone: to.Ptr("system"),
// 		},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-ee788a1f.hcp.location1.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			IPFamilies: []*armcontainerservice.IPFamily{
// 				to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 				LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 					AllocatedOutboundPorts: to.Ptr[int32](2000),
// 					EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 						},
// 						{
// 							ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 					}},
// 					IdleTimeoutInMinutes: to.Ptr[int32](10),
// 					ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 						Count: to.Ptr[int32](2),
// 					},
// 				},
// 				LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 				NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 				OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 				PodCidr: to.Ptr("10.244.0.0/16"),
// 				PodCidrs: []*string{
// 					to.Ptr("10.244.0.0/16")},
// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
// 					ServiceCidrs: []*string{
// 						to.Ptr("10.0.0.0/16")},
// 					},
// 					NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 					PrivateFQDN: to.Ptr("dnsprefix1-aae7e0f0.5cef6058-b6b5-414d-8cb1-4bd14eb0b15c.privatelink.location1.azmk8s.io"),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 						ClientID: to.Ptr("clientid"),
// 					},
// 					WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 						AdminUsername: to.Ptr("azureuser"),
// 					},
// 				},
// 			}

Output:
Example (CreateUpdateAadManagedClusterWithEnableAzureRbac)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_UpdateWithEnableAzureRBAC.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AADProfile: &armcontainerservice.ManagedClusterAADProfile{
			EnableAzureRBAC: to.Ptr(true),
			Managed:         to.Ptr(true),
		},
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				AvailabilityZones: []*string{
					to.Ptr("1"),
					to.Ptr("2"),
					to.Ptr("3")},
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS1_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AADProfile: &armcontainerservice.ManagedClusterAADProfile{
// 			EnableAzureRBAC: to.Ptr(true),
// 			Managed: to.Ptr(true),
// 			TenantID: to.Ptr("tenantID"),
// 		},
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 					EnableNodePublicIP: to.Ptr(true),
// 					MaxPods: to.Ptr[int32](110),
// 					Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.9.6"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 				ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 				ScanInterval: to.Ptr("20s"),
// 			},
// 			CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnablePodSecurityPolicy: to.Ptr(true),
// 			EnableRBAC: to.Ptr(true),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateUpdateManagedCluster)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_Update.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Identity: &armcontainerservice.ManagedClusterIdentity{
		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
		},
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				AvailabilityZones: []*string{
					to.Ptr("1"),
					to.Ptr("2"),
					to.Ptr("3")},
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				ScaleDownMode:      to.Ptr(armcontainerservice.ScaleDownModeDeallocate),
				VMSize:             to.Ptr("Standard_DS1_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			BalanceSimilarNodeGroups: to.Ptr("true"),
			Expander:                 to.Ptr(armcontainerservice.ExpanderPriority),
			MaxNodeProvisionTime:     to.Ptr("15m"),
			NewPodScaleUpDelay:       to.Ptr("1m"),
			ScaleDownDelayAfterAdd:   to.Ptr("15m"),
			ScanInterval:             to.Ptr("20s"),
			SkipNodesWithSystemPods:  to.Ptr("false"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		UpgradeSettings: &armcontainerservice.ClusterUpgradeSettings{
			OverrideSettings: &armcontainerservice.UpgradeOverrideSettings{
				ForceUpgrade: to.Ptr(false),
				Until:        to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-11-01T13:00:00.000Z"); return t }()),
			},
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Identity: &armcontainerservice.ManagedClusterIdentity{
// 		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": &armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 				ClientID: to.Ptr("clientId1"),
// 				PrincipalID: to.Ptr("principalId1"),
// 			},
// 		},
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 					EnableNodePublicIP: to.Ptr(true),
// 					MaxPods: to.Ptr[int32](110),
// 					Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.9.6"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ScaleDownMode: to.Ptr(armcontainerservice.ScaleDownModeDeallocate),
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 				BalanceSimilarNodeGroups: to.Ptr("true"),
// 				Expander: to.Ptr(armcontainerservice.ExpanderPriority),
// 				MaxNodeProvisionTime: to.Ptr("15m"),
// 				NewPodScaleUpDelay: to.Ptr("1m"),
// 				ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 				ScanInterval: to.Ptr("20s"),
// 				SkipNodesWithSystemPods: to.Ptr("false"),
// 			},
// 			CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnablePodSecurityPolicy: to.Ptr(true),
// 			EnableRBAC: to.Ptr(true),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						UpgradeSettings: &armcontainerservice.ClusterUpgradeSettings{
// 							OverrideSettings: &armcontainerservice.UpgradeOverrideSettings{
// 								ForceUpgrade: to.Ptr(false),
// 								Until: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-11-01T13:00:00.000Z"); return t}()),
// 							},
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateUpdateManagedClusterWithAzureServiceMesh)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_AzureServiceMesh.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{
			"azureKeyvaultSecretsProvider": {
				Config: map[string]*string{
					"enableSecretRotation": to.Ptr("true"),
					"rotationPollInterval": to.Ptr("2m"),
				},
				Enabled: to.Ptr(true),
			},
		},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type:               to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS2_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServiceMeshProfile: &armcontainerservice.ServiceMeshProfile{
			Istio: &armcontainerservice.IstioServiceMesh{
				CertificateAuthority: &armcontainerservice.IstioCertificateAuthority{
					Plugin: &armcontainerservice.IstioPluginCertificateAuthority{
						CertChainObjectName: to.Ptr("cert-chain"),
						CertObjectName:      to.Ptr("ca-cert"),
						KeyObjectName:       to.Ptr("ca-key"),
						KeyVaultID:          to.Ptr("/subscriptions/854c9ddb-fe9e-4aea-8d58-99ed88282881/resourceGroups/ddama-test/providers/Microsoft.KeyVault/vaults/my-akv"),
						RootCertObjectName:  to.Ptr("root-cert"),
					},
				},
				Components: &armcontainerservice.IstioComponents{
					EgressGateways: []*armcontainerservice.IstioEgressGateway{
						{
							Enabled: to.Ptr(true),
						}},
					IngressGateways: []*armcontainerservice.IstioIngressGateway{
						{
							Enabled: to.Ptr(true),
							Mode:    to.Ptr(armcontainerservice.IstioIngressGatewayModeInternal),
						}},
				},
			},
			Mode: to.Ptr(armcontainerservice.ServiceMeshModeIstio),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{
// 			"azureKeyvaultSecretsProvider": &armcontainerservice.ManagedClusterAddonProfile{
// 				Config: map[string]*string{
// 					"enableSecretRotation": to.Ptr("true"),
// 					"rotationPollInterval": to.Ptr("2m"),
// 				},
// 				Enabled: to.Ptr(true),
// 			},
// 		},
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				Count: to.Ptr[int32](3),
// 				EnableEncryptionAtHost: to.Ptr(true),
// 				EnableNodePublicIP: to.Ptr(true),
// 				MaxPods: to.Ptr[int32](110),
// 				Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 				NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS2_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 			ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 			ScanInterval: to.Ptr("20s"),
// 		},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnablePodSecurityPolicy: to.Ptr(true),
// 		EnableRBAC: to.Ptr(true),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		MaxAgentPools: to.Ptr[int32](1),
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 				AllocatedOutboundPorts: to.Ptr[int32](2000),
// 				EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 					},
// 					{
// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 				}},
// 				IdleTimeoutInMinutes: to.Ptr[int32](10),
// 				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 					Count: to.Ptr[int32](2),
// 				},
// 			},
// 			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 			NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 			OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 			PodCidr: to.Ptr("10.244.0.0/16"),
// 			ServiceCidr: to.Ptr("10.0.0.0/16"),
// 		},
// 		NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServiceMeshProfile: &armcontainerservice.ServiceMeshProfile{
// 			Istio: &armcontainerservice.IstioServiceMesh{
// 				CertificateAuthority: &armcontainerservice.IstioCertificateAuthority{
// 					Plugin: &armcontainerservice.IstioPluginCertificateAuthority{
// 						CertChainObjectName: to.Ptr("cert-chain"),
// 						CertObjectName: to.Ptr("ca-cert"),
// 						KeyObjectName: to.Ptr("ca-key"),
// 						KeyVaultID: to.Ptr("/subscriptions/854c9ddb-fe9e-4aea-8d58-99ed88282881/resourceGroups/ddama-test/providers/Microsoft.KeyVault/vaults/my-akv"),
// 						RootCertObjectName: to.Ptr("root-cert"),
// 					},
// 				},
// 				Components: &armcontainerservice.IstioComponents{
// 					EgressGateways: []*armcontainerservice.IstioEgressGateway{
// 						{
// 							Enabled: to.Ptr(true),
// 					}},
// 					IngressGateways: []*armcontainerservice.IstioIngressGateway{
// 						{
// 							Enabled: to.Ptr(true),
// 							Mode: to.Ptr(armcontainerservice.IstioIngressGatewayModeInternal),
// 					}},
// 				},
// 				Revisions: []*string{
// 					to.Ptr("asm-1-17")},
// 				},
// 				Mode: to.Ptr(armcontainerservice.ServiceMeshModeIstio),
// 			},
// 			ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 				ClientID: to.Ptr("clientid"),
// 			},
// 			WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 			},
// 		},
// 	}

Output:
Example (CreateUpdateManagedClusterWithDualStackNetworking)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_DualStackNetworking.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Identity: &armcontainerservice.ManagedClusterIdentity{
		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
		},
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				AvailabilityZones: []*string{
					to.Ptr("1"),
					to.Ptr("2"),
					to.Ptr("3")},
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				ScaleDownMode:      to.Ptr(armcontainerservice.ScaleDownModeDeallocate),
				VMSize:             to.Ptr("Standard_DS1_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			BalanceSimilarNodeGroups: to.Ptr("true"),
			Expander:                 to.Ptr(armcontainerservice.ExpanderPriority),
			MaxNodeProvisionTime:     to.Ptr("15m"),
			NewPodScaleUpDelay:       to.Ptr("1m"),
			ScaleDownDelayAfterAdd:   to.Ptr("15m"),
			ScanInterval:             to.Ptr("20s"),
			SkipNodesWithSystemPods:  to.Ptr("false"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			IPFamilies: []*armcontainerservice.IPFamily{
				to.Ptr(armcontainerservice.IPFamilyIPv4),
				to.Ptr(armcontainerservice.IPFamilyIPv6)},
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Identity: &armcontainerservice.ManagedClusterIdentity{
// 		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": &armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 				ClientID: to.Ptr("clientId1"),
// 				PrincipalID: to.Ptr("principalId1"),
// 			},
// 		},
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.22.1"),
// 					EnableNodePublicIP: to.Ptr(true),
// 					MaxPods: to.Ptr[int32](110),
// 					Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.22.1"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					ScaleDownMode: to.Ptr(armcontainerservice.ScaleDownModeDeallocate),
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 				BalanceSimilarNodeGroups: to.Ptr("true"),
// 				Expander: to.Ptr(armcontainerservice.ExpanderPriority),
// 				MaxNodeProvisionTime: to.Ptr("15m"),
// 				NewPodScaleUpDelay: to.Ptr("1m"),
// 				ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 				ScanInterval: to.Ptr("20s"),
// 				SkipNodesWithSystemPods: to.Ptr("false"),
// 			},
// 			CurrentKubernetesVersion: to.Ptr("1.22.1"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnablePodSecurityPolicy: to.Ptr(true),
// 			EnableRBAC: to.Ptr(true),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.22.1"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4),
// 					to.Ptr(armcontainerservice.IPFamilyIPv6)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip3-ipv6"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 							CountIPv6: to.Ptr[int32](1),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16"),
// 						to.Ptr("fd11:1234::/64")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16"),
// 							to.Ptr("fd00:1234::/108")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 						},
// 					},
// 				}

Output:
Example (CreateUpdateManagedClusterWithEnableAhub)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_UpdateWithAHUB.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Identity: &armcontainerservice.ManagedClusterIdentity{
		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
		},
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				AvailabilityZones: []*string{
					to.Ptr("1"),
					to.Ptr("2"),
					to.Ptr("3")},
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS1_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
			LicenseType:   to.Ptr(armcontainerservice.LicenseTypeWindowsServer),
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Identity: &armcontainerservice.ManagedClusterIdentity{
// 		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": &armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 				ClientID: to.Ptr("clientId1"),
// 				PrincipalID: to.Ptr("principalId1"),
// 			},
// 		},
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 					EnableNodePublicIP: to.Ptr(true),
// 					MaxPods: to.Ptr[int32](110),
// 					Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.9.6"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 				ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 				ScanInterval: to.Ptr("20s"),
// 			},
// 			CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnablePodSecurityPolicy: to.Ptr(true),
// 			EnableRBAC: to.Ptr(true),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 							LicenseType: to.Ptr(armcontainerservice.LicenseTypeWindowsServer),
// 						},
// 					},
// 				}

Output:
Example (CreateUpdateManagedClusterWithWindowsGMsaEnabled)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersCreate_UpdateWindowsGmsa.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", armcontainerservice.ManagedCluster{
	Location: to.Ptr("location1"),
	Tags: map[string]*string{
		"archv2": to.Ptr(""),
		"tier":   to.Ptr("production"),
	},
	Identity: &armcontainerservice.ManagedClusterIdentity{
		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": {},
		},
	},
	Properties: &armcontainerservice.ManagedClusterProperties{
		AddonProfiles: map[string]*armcontainerservice.ManagedClusterAddonProfile{},
		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
			{
				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
				AvailabilityZones: []*string{
					to.Ptr("1"),
					to.Ptr("2"),
					to.Ptr("3")},
				Count:              to.Ptr[int32](3),
				EnableNodePublicIP: to.Ptr(true),
				Mode:               to.Ptr(armcontainerservice.AgentPoolModeSystem),
				OSType:             to.Ptr(armcontainerservice.OSTypeLinux),
				VMSize:             to.Ptr("Standard_DS1_v2"),
				Name:               to.Ptr("nodepool1"),
			}},
		AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
			ScaleDownDelayAfterAdd: to.Ptr("15m"),
			ScanInterval:           to.Ptr("20s"),
		},
		DiskEncryptionSetID:     to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
		DNSPrefix:               to.Ptr("dnsprefix1"),
		EnablePodSecurityPolicy: to.Ptr(true),
		EnableRBAC:              to.Ptr(true),
		KubernetesVersion:       to.Ptr(""),
		LinuxProfile: &armcontainerservice.LinuxProfile{
			AdminUsername: to.Ptr("azureuser"),
			SSH: &armcontainerservice.SSHConfiguration{
				PublicKeys: []*armcontainerservice.SSHPublicKey{
					{
						KeyData: to.Ptr("keydata"),
					}},
			},
		},
		NetworkProfile: &armcontainerservice.NetworkProfile{
			LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
				ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
					Count: to.Ptr[int32](2),
				},
			},
			LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
			OutboundType:    to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
		},
		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
			ClientID: to.Ptr("clientid"),
			Secret:   to.Ptr("secret"),
		},
		WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
			AdminPassword: to.Ptr("replacePassword1234$"),
			AdminUsername: to.Ptr("azureuser"),
			GmsaProfile: &armcontainerservice.WindowsGmsaProfile{
				Enabled: to.Ptr(true),
			},
		},
	},
	SKU: &armcontainerservice.ManagedClusterSKU{
		Name: to.Ptr(armcontainerservice.ManagedClusterSKUName("Basic")),
		Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
	},
}, &armcontainerservice.ManagedClustersClientBeginCreateOrUpdateOptions{IfMatch: nil,
	IfNoneMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	Identity: &armcontainerservice.ManagedClusterIdentity{
// 		Type: to.Ptr(armcontainerservice.ResourceIdentityTypeUserAssigned),
// 		UserAssignedIdentities: map[string]*armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 			"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rgName1/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identity1": &armcontainerservice.ManagedServiceIdentityUserAssignedIdentitiesValue{
// 				ClientID: to.Ptr("clientId1"),
// 				PrincipalID: to.Ptr("principalId1"),
// 			},
// 		},
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Type: to.Ptr(armcontainerservice.AgentPoolTypeVirtualMachineScaleSets),
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 					EnableNodePublicIP: to.Ptr(true),
// 					MaxPods: to.Ptr[int32](110),
// 					Mode: to.Ptr(armcontainerservice.AgentPoolModeSystem),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.9.6"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AutoScalerProfile: &armcontainerservice.ManagedClusterPropertiesAutoScalerProfile{
// 				ScaleDownDelayAfterAdd: to.Ptr("15m"),
// 				ScanInterval: to.Ptr("20s"),
// 			},
// 			CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnablePodSecurityPolicy: to.Ptr(true),
// 			EnableRBAC: to.Ptr(true),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						ManagedOutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileManagedOutboundIPs{
// 							Count: to.Ptr[int32](2),
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUBasic),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						WindowsProfile: &armcontainerservice.ManagedClusterWindowsProfile{
// 							AdminUsername: to.Ptr("azureuser"),
// 							GmsaProfile: &armcontainerservice.WindowsGmsaProfile{
// 								Enabled: to.Ptr(true),
// 							},
// 						},
// 					},
// 				}

Output:

func (*ManagedClustersClient) BeginDelete 

func (client *ManagedClustersClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginDeleteOptions) (*runtime.Poller[ManagedClustersClientDeleteResponse], error)

BeginDelete - Deletes a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginDeleteOptions contains the optional parameters for the ManagedClustersClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginDelete(ctx, "rg1", "clustername1", &armcontainerservice.ManagedClustersClientBeginDeleteOptions{IfMatch: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginResetAADProfile 

func (client *ManagedClustersClient) BeginResetAADProfile(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterAADProfile, options *ManagedClustersClientBeginResetAADProfileOptions) (*runtime.Poller[ManagedClustersClientResetAADProfileResponse], error)

BeginResetAADProfile - WARNING: This API will be deprecated. Please see AKS-managed Azure Active Directory integration [https://aka.ms/aks-managed-aad] to update your cluster with AKS-managed Azure AD. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - The AAD profile to set on the Managed Cluster
  • options - ManagedClustersClientBeginResetAADProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetAADProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersResetAADProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginResetAADProfile(ctx, "rg1", "clustername1", armcontainerservice.ManagedClusterAADProfile{
	ClientAppID:     to.Ptr("clientappid"),
	ServerAppID:     to.Ptr("serverappid"),
	ServerAppSecret: to.Ptr("serverappsecret"),
	TenantID:        to.Ptr("tenantid"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginResetServicePrincipalProfile 

func (client *ManagedClustersClient) BeginResetServicePrincipalProfile(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterServicePrincipalProfile, options *ManagedClustersClientBeginResetServicePrincipalProfileOptions) (*runtime.Poller[ManagedClustersClientResetServicePrincipalProfileResponse], error)

BeginResetServicePrincipalProfile - This action cannot be performed on a cluster that is not using a service principal If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - The service principal profile to set on the managed cluster.
  • options - ManagedClustersClientBeginResetServicePrincipalProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetServicePrincipalProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersResetServicePrincipalProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginResetServicePrincipalProfile(ctx, "rg1", "clustername1", armcontainerservice.ManagedClusterServicePrincipalProfile{
	ClientID: to.Ptr("clientid"),
	Secret:   to.Ptr("secret"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginRotateClusterCertificates 

func (client *ManagedClustersClient) BeginRotateClusterCertificates(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginRotateClusterCertificatesOptions) (*runtime.Poller[ManagedClustersClientRotateClusterCertificatesResponse], error)

BeginRotateClusterCertificates - See Certificate rotation [https://docs.microsoft.com/azure/aks/certificate-rotation] for more details about rotating managed cluster certificates. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginRotateClusterCertificatesOptions contains the optional parameters for the ManagedClustersClient.BeginRotateClusterCertificates method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersRotateClusterCertificates.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginRotateClusterCertificates(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginRotateServiceAccountSigningKeys 

func (client *ManagedClustersClient) BeginRotateServiceAccountSigningKeys(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginRotateServiceAccountSigningKeysOptions) (*runtime.Poller[ManagedClustersClientRotateServiceAccountSigningKeysResponse], error)

BeginRotateServiceAccountSigningKeys - Rotates the service account signing keys of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginRotateServiceAccountSigningKeysOptions contains the optional parameters for the ManagedClustersClient.BeginRotateServiceAccountSigningKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersRotateServiceAccountSigningKeys.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginRotateServiceAccountSigningKeys(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginRunCommand 

func (client *ManagedClustersClient) BeginRunCommand(ctx context.Context, resourceGroupName string, resourceName string, requestPayload RunCommandRequest, options *ManagedClustersClientBeginRunCommandOptions) (*runtime.Poller[ManagedClustersClientRunCommandResponse], error)

BeginRunCommand - AKS will create a pod to run the command. This is primarily useful for private clusters. For more information see AKS Run Command [https://docs.microsoft.com/azure/aks/private-clusters#aks-run-command-preview]. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • requestPayload - The run command request
  • options - ManagedClustersClientBeginRunCommandOptions contains the optional parameters for the ManagedClustersClient.BeginRunCommand method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/RunCommandRequest.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginRunCommand(ctx, "rg1", "clustername1", armcontainerservice.RunCommandRequest{
	ClusterToken: to.Ptr(""),
	Command:      to.Ptr("kubectl apply -f ns.yaml"),
	Context:      to.Ptr(""),
}, 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.RunCommandResult = armcontainerservice.RunCommandResult{
// 	ID: to.Ptr("def7b3ea71bd4f7e9d226ddbc0f00ad9"),
// 	Properties: &armcontainerservice.CommandResultProperties{
// 		ExitCode: to.Ptr[int32](0),
// 		FinishedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-02-17T00:28:33.000Z"); return t}()),
// 		Logs: to.Ptr("namespace dummy created"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		StartedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-02-17T00:28:20.000Z"); return t}()),
// 	},
// }

Output:

func (*ManagedClustersClient) BeginStart 

func (client *ManagedClustersClient) BeginStart(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginStartOptions) (*runtime.Poller[ManagedClustersClientStartResponse], error)

BeginStart - See starting a cluster [https://docs.microsoft.com/azure/aks/start-stop-cluster] for more details about starting a cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginStartOptions contains the optional parameters for the ManagedClustersClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersStart.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginStart(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginStop 

func (client *ManagedClustersClient) BeginStop(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientBeginStopOptions) (*runtime.Poller[ManagedClustersClientStopResponse], error)

BeginStop - This can only be performed on Azure Virtual Machine Scale set backed clusters. Stopping a cluster stops the control plane and agent nodes entirely, while maintaining all object and cluster state. A cluster does not accrue charges while it is stopped. See stopping a cluster [https://docs.microsoft.com/azure/aks/start-stop-cluster] for more details about stopping a cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientBeginStopOptions contains the optional parameters for the ManagedClustersClient.BeginStop method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersStop.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginStop(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*ManagedClustersClient) BeginUpdateTags 

func (client *ManagedClustersClient) BeginUpdateTags(ctx context.Context, resourceGroupName string, resourceName string, parameters TagsObject, options *ManagedClustersClientBeginUpdateTagsOptions) (*runtime.Poller[ManagedClustersClientUpdateTagsResponse], error)

BeginUpdateTags - Updates tags on a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - Parameters supplied to the Update Managed Cluster Tags operation.
  • options - ManagedClustersClientBeginUpdateTagsOptions contains the optional parameters for the ManagedClustersClient.BeginUpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewManagedClustersClient().BeginUpdateTags(ctx, "rg1", "clustername1", armcontainerservice.TagsObject{
	Tags: map[string]*string{
		"archv3": to.Ptr(""),
		"tier":   to.Ptr("testing"),
	},
}, &armcontainerservice.ManagedClustersClientBeginUpdateTagsOptions{IfMatch: 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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv3": to.Ptr(""),
// 		"tier": to.Ptr("testing"),
// 	},
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				Count: to.Ptr[int32](3),
// 				CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 				MaxPods: to.Ptr[int32](110),
// 				OrchestratorVersion: to.Ptr("1.9.6"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				ProvisioningState: to.Ptr("Succeeded"),
// 				VMSize: to.Ptr("Standard_DS1_v2"),
// 				Name: to.Ptr("nodepool1"),
// 		}},
// 		DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 		DNSPrefix: to.Ptr("dnsprefix1"),
// 		EnableRBAC: to.Ptr(false),
// 		Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 		KubernetesVersion: to.Ptr("1.9.6"),
// 		LinuxProfile: &armcontainerservice.LinuxProfile{
// 			AdminUsername: to.Ptr("azureuser"),
// 			SSH: &armcontainerservice.SSHConfiguration{
// 				PublicKeys: []*armcontainerservice.SSHPublicKey{
// 					{
// 						KeyData: to.Ptr("keydata"),
// 				}},
// 			},
// 		},
// 		NetworkProfile: &armcontainerservice.NetworkProfile{
// 			DNSServiceIP: to.Ptr("10.0.0.10"),
// 			NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 			PodCidr: to.Ptr("10.244.0.0/16"),
// 			ServiceCidr: to.Ptr("10.0.0.0/16"),
// 		},
// 		NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 			ClientID: to.Ptr("clientid"),
// 		},
// 	},
// }

Output:

func (*ManagedClustersClient) Get 

func (client *ManagedClustersClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientGetOptions) (ManagedClustersClientGetResponse, error)

Get - Gets a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientGetOptions contains the optional parameters for the ManagedClustersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().Get(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.ManagedCluster = armcontainerservice.ManagedCluster{
// 	Name: to.Ptr("clustername1"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
// 	Location: to.Ptr("location1"),
// 	Tags: map[string]*string{
// 		"archv2": to.Ptr(""),
// 		"tier": to.Ptr("production"),
// 	},
// 	ETag: to.Ptr("beywbwei"),
// 	Properties: &armcontainerservice.ManagedClusterProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
// 			{
// 				AvailabilityZones: []*string{
// 					to.Ptr("1"),
// 					to.Ptr("2"),
// 					to.Ptr("3")},
// 					Count: to.Ptr[int32](3),
// 					CurrentOrchestratorVersion: to.Ptr("1.9.6"),
// 					ETag: to.Ptr("nvewbvoi"),
// 					MaxPods: to.Ptr[int32](110),
// 					NodeImageVersion: to.Ptr("AKSUbuntu:1604:2020.03.11"),
// 					OrchestratorVersion: to.Ptr("1.9.6"),
// 					OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 					ProvisioningState: to.Ptr("Succeeded"),
// 					UpgradeSettings: &armcontainerservice.AgentPoolUpgradeSettings{
// 						MaxSurge: to.Ptr("33%"),
// 					},
// 					VMSize: to.Ptr("Standard_DS1_v2"),
// 					Name: to.Ptr("nodepool1"),
// 			}},
// 			AzurePortalFQDN: to.Ptr("dnsprefix1-abcd1234.portal.hcp.eastus.azmk8s.io"),
// 			CurrentKubernetesVersion: to.Ptr("1.9.6"),
// 			DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
// 			DNSPrefix: to.Ptr("dnsprefix1"),
// 			EnableRBAC: to.Ptr(false),
// 			Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
// 			KubernetesVersion: to.Ptr("1.9.6"),
// 			LinuxProfile: &armcontainerservice.LinuxProfile{
// 				AdminUsername: to.Ptr("azureuser"),
// 				SSH: &armcontainerservice.SSHConfiguration{
// 					PublicKeys: []*armcontainerservice.SSHPublicKey{
// 						{
// 							KeyData: to.Ptr("keydata"),
// 					}},
// 				},
// 			},
// 			MaxAgentPools: to.Ptr[int32](1),
// 			NetworkProfile: &armcontainerservice.NetworkProfile{
// 				DNSServiceIP: to.Ptr("10.0.0.10"),
// 				IPFamilies: []*armcontainerservice.IPFamily{
// 					to.Ptr(armcontainerservice.IPFamilyIPv4)},
// 					LoadBalancerProfile: &armcontainerservice.ManagedClusterLoadBalancerProfile{
// 						AllocatedOutboundPorts: to.Ptr[int32](2000),
// 						EffectiveOutboundIPs: []*armcontainerservice.ResourceReference{
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip1"),
// 							},
// 							{
// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/MC_rg1/providers/Microsoft.Network/publicIPAddresses/mgdoutboundip2"),
// 						}},
// 						IdleTimeoutInMinutes: to.Ptr[int32](10),
// 						OutboundIPs: &armcontainerservice.ManagedClusterLoadBalancerProfileOutboundIPs{
// 							PublicIPs: []*armcontainerservice.ResourceReference{
// 								{
// 									ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/publicIPAddresses/customeroutboundip1"),
// 								},
// 								{
// 									ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Network/publicIPAddresses/customeroutboundip2"),
// 							}},
// 						},
// 					},
// 					LoadBalancerSKU: to.Ptr(armcontainerservice.LoadBalancerSKUStandard),
// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
// 					OutboundType: to.Ptr(armcontainerservice.OutboundTypeLoadBalancer),
// 					PodCidr: to.Ptr("10.244.0.0/16"),
// 					PodCidrs: []*string{
// 						to.Ptr("10.244.0.0/16")},
// 						ServiceCidr: to.Ptr("10.0.0.0/16"),
// 						ServiceCidrs: []*string{
// 							to.Ptr("10.0.0.0/16")},
// 						},
// 						NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
// 						ProvisioningState: to.Ptr("Succeeded"),
// 						ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
// 							ClientID: to.Ptr("clientid"),
// 						},
// 						UpgradeSettings: &armcontainerservice.ClusterUpgradeSettings{
// 							OverrideSettings: &armcontainerservice.UpgradeOverrideSettings{
// 								ForceUpgrade: to.Ptr(true),
// 								Until: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-11-01T13:00:00.000Z"); return t}()),
// 							},
// 						},
// 					},
// 				}

Output:

func (*ManagedClustersClient) GetAccessProfile 

func (client *ManagedClustersClient) GetAccessProfile(ctx context.Context, resourceGroupName string, resourceName string, roleName string, options *ManagedClustersClientGetAccessProfileOptions) (ManagedClustersClientGetAccessProfileResponse, error)

GetAccessProfile - WARNING: This API will be deprecated. Instead use ListClusterUserCredentials [https://docs.microsoft.com/rest/api/aks/managedclusters/listclusterusercredentials] or ListClusterAdminCredentials [https://docs.microsoft.com/rest/api/aks/managedclusters/listclusteradmincredentials] . If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • roleName - The name of the role for managed cluster accessProfile resource.
  • options - ManagedClustersClientGetAccessProfileOptions contains the optional parameters for the ManagedClustersClient.GetAccessProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersGetAccessProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetAccessProfile(ctx, "rg1", "clustername1", "clusterUser", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.ManagedClusterAccessProfile = armcontainerservice.ManagedClusterAccessProfile{
// 	Name: to.Ptr("clusterUser"),
// 	Type: to.Ptr("Microsoft.ContainerService/ManagedClusters/AccessProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/accessProfiles/clusterUser"),
// 	Location: to.Ptr("location1"),
// 	Properties: &armcontainerservice.AccessProfile{
// 		KubeConfig: []byte("a3ViZUNvbmZpZzE="),
// 	},
// }

Output:

func (*ManagedClustersClient) GetCommandResult 

func (client *ManagedClustersClient) GetCommandResult(ctx context.Context, resourceGroupName string, resourceName string, commandID string, options *ManagedClustersClientGetCommandResultOptions) (ManagedClustersClientGetCommandResultResponse, error)

GetCommandResult - Gets the results of a command which has been run on the Managed Cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • commandID - Id of the command.
  • options - ManagedClustersClientGetCommandResultOptions contains the optional parameters for the ManagedClustersClient.GetCommandResult method.
Example (CommandFailedResult)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/RunCommandResultFailed.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetCommandResult(ctx, "rg1", "clustername1", "def7b3ea71bd4f7e9d226ddbc0f00ad9", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.RunCommandResult = armcontainerservice.RunCommandResult{
// 	ID: to.Ptr("def7b3ea71bd4f7e9d226ddbc0f00ad9"),
// 	Properties: &armcontainerservice.CommandResultProperties{
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		Reason: to.Ptr("ImagePullBackoff"),
// 	},
// }

Output:
Example (CommandSucceedResult)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/RunCommandResultSucceed.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetCommandResult(ctx, "rg1", "clustername1", "def7b3ea71bd4f7e9d226ddbc0f00ad9", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.RunCommandResult = armcontainerservice.RunCommandResult{
// 	ID: to.Ptr("def7b3ea71bd4f7e9d226ddbc0f00ad9"),
// 	Properties: &armcontainerservice.CommandResultProperties{
// 		ExitCode: to.Ptr[int32](0),
// 		FinishedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-02-17T00:28:33.000Z"); return t}()),
// 		Logs: to.Ptr("namespace dummy created"),
// 		ProvisioningState: to.Ptr("Succeeded"),
// 		StartedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-02-17T00:28:20.000Z"); return t}()),
// 	},
// }

Output:

func (*ManagedClustersClient) GetMeshRevisionProfile 

func (client *ManagedClustersClient) GetMeshRevisionProfile(ctx context.Context, location string, mode string, options *ManagedClustersClientGetMeshRevisionProfileOptions) (ManagedClustersClientGetMeshRevisionProfileResponse, error)

GetMeshRevisionProfile - Contains extra metadata on the revision, including supported revisions, cluster compatibility and available upgrades If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • location - The name of the Azure region.
  • mode - The mode of the mesh.
  • options - ManagedClustersClientGetMeshRevisionProfileOptions contains the optional parameters for the ManagedClustersClient.GetMeshRevisionProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersGet_MeshRevisionProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetMeshRevisionProfile(ctx, "location1", "istio", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MeshRevisionProfile = armcontainerservice.MeshRevisionProfile{
// 	Name: to.Ptr("istio"),
// 	Type: to.Ptr("Microsoft.ContainerService/locations/meshRevisionProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.ContainerService/locations/location1/meshRevisionProfiles/istio"),
// 	Properties: &armcontainerservice.MeshRevisionProfileProperties{
// 		MeshRevisions: []*armcontainerservice.MeshRevision{
// 			{
// 				CompatibleWith: []*armcontainerservice.CompatibleVersions{
// 					{
// 						Name: to.Ptr("kubernetes"),
// 						Versions: []*string{
// 							to.Ptr("1.23"),
// 							to.Ptr("1.24"),
// 							to.Ptr("1.25"),
// 							to.Ptr("1.26")},
// 					}},
// 					Revision: to.Ptr("asm-1-17"),
// 					Upgrades: []*string{
// 						to.Ptr("asm-1-18")},
// 					},
// 					{
// 						CompatibleWith: []*armcontainerservice.CompatibleVersions{
// 							{
// 								Name: to.Ptr("kubernetes"),
// 								Versions: []*string{
// 									to.Ptr("1.24"),
// 									to.Ptr("1.25"),
// 									to.Ptr("1.26"),
// 									to.Ptr("1.27")},
// 							}},
// 							Revision: to.Ptr("asm-1-18"),
// 							Upgrades: []*string{
// 							},
// 					}},
// 				},
// 			}

Output:

func (*ManagedClustersClient) GetMeshUpgradeProfile 

func (client *ManagedClustersClient) GetMeshUpgradeProfile(ctx context.Context, resourceGroupName string, resourceName string, mode string, options *ManagedClustersClientGetMeshUpgradeProfileOptions) (ManagedClustersClientGetMeshUpgradeProfileResponse, error)

GetMeshUpgradeProfile - Gets available upgrades for a service mesh in a cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • mode - The mode of the mesh.
  • options - ManagedClustersClientGetMeshUpgradeProfileOptions contains the optional parameters for the ManagedClustersClient.GetMeshUpgradeProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersGet_MeshUpgradeProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetMeshUpgradeProfile(ctx, "rg1", "clustername1", "istio", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.MeshUpgradeProfile = armcontainerservice.MeshUpgradeProfile{
// 	Name: to.Ptr("istio"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/meshUpgradeProfiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/meshUpgradeProfiles/istio"),
// 	Properties: &armcontainerservice.MeshUpgradeProfileProperties{
// 		CompatibleWith: []*armcontainerservice.CompatibleVersions{
// 			{
// 				Name: to.Ptr("kubernetes"),
// 				Versions: []*string{
// 					to.Ptr("1.23"),
// 					to.Ptr("1.24"),
// 					to.Ptr("1.25"),
// 					to.Ptr("1.26")},
// 			}},
// 			Revision: to.Ptr("asm-1-17"),
// 			Upgrades: []*string{
// 				to.Ptr("asm-1-18")},
// 			},
// 		}

Output:

func (*ManagedClustersClient) GetUpgradeProfile 

func (client *ManagedClustersClient) GetUpgradeProfile(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientGetUpgradeProfileOptions) (ManagedClustersClientGetUpgradeProfileResponse, error)

GetUpgradeProfile - Gets the upgrade profile of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientGetUpgradeProfileOptions contains the optional parameters for the ManagedClustersClient.GetUpgradeProfile method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersGetUpgradeProfile.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().GetUpgradeProfile(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.ManagedClusterUpgradeProfile = armcontainerservice.ManagedClusterUpgradeProfile{
// 	Name: to.Ptr("default"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/upgradeprofiles"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/upgradeprofiles/default"),
// 	Properties: &armcontainerservice.ManagedClusterUpgradeProfileProperties{
// 		AgentPoolProfiles: []*armcontainerservice.ManagedClusterPoolUpgradeProfile{
// 			{
// 				Name: to.Ptr("agent"),
// 				KubernetesVersion: to.Ptr("1.7.7"),
// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 				Upgrades: []*armcontainerservice.ManagedClusterPoolUpgradeProfileUpgradesItem{
// 					{
// 						KubernetesVersion: to.Ptr("1.7.9"),
// 					},
// 					{
// 						IsPreview: to.Ptr(true),
// 						KubernetesVersion: to.Ptr("1.7.11"),
// 				}},
// 		}},
// 		ControlPlaneProfile: &armcontainerservice.ManagedClusterPoolUpgradeProfile{
// 			Name: to.Ptr("master"),
// 			KubernetesVersion: to.Ptr("1.7.7"),
// 			OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 			Upgrades: []*armcontainerservice.ManagedClusterPoolUpgradeProfileUpgradesItem{
// 				{
// 					IsPreview: to.Ptr(true),
// 					KubernetesVersion: to.Ptr("1.7.9"),
// 				},
// 				{
// 					KubernetesVersion: to.Ptr("1.7.11"),
// 			}},
// 		},
// 	},
// }

Output:

func (*ManagedClustersClient) ListClusterAdminCredentials 

func (client *ManagedClustersClient) ListClusterAdminCredentials(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientListClusterAdminCredentialsOptions) (ManagedClustersClientListClusterAdminCredentialsResponse, error)

ListClusterAdminCredentials - Lists the admin credentials of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientListClusterAdminCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterAdminCredentials method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersListClusterAdminCredentials.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().ListClusterAdminCredentials(ctx, "rg1", "clustername1", &armcontainerservice.ManagedClustersClientListClusterAdminCredentialsOptions{ServerFqdn: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %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.CredentialResults = armcontainerservice.CredentialResults{
// 	Kubeconfigs: []*armcontainerservice.CredentialResult{
// 		{
// 			Name: to.Ptr("credentialName1"),
// 			Value: []byte("Y3JlZGVudGlhbFZhbHVlMQ=="),
// 	}},
// }

Output:

func (*ManagedClustersClient) ListClusterMonitoringUserCredentials 

func (client *ManagedClustersClient) ListClusterMonitoringUserCredentials(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientListClusterMonitoringUserCredentialsOptions) (ManagedClustersClientListClusterMonitoringUserCredentialsResponse, error)

ListClusterMonitoringUserCredentials - Lists the cluster monitoring user credentials of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientListClusterMonitoringUserCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterMonitoringUserCredentials method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersListClusterMonitoringUserCredentials.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().ListClusterMonitoringUserCredentials(ctx, "rg1", "clustername1", &armcontainerservice.ManagedClustersClientListClusterMonitoringUserCredentialsOptions{ServerFqdn: nil})
if err != nil {
	log.Fatalf("failed to finish the request: %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.CredentialResults = armcontainerservice.CredentialResults{
// 	Kubeconfigs: []*armcontainerservice.CredentialResult{
// 		{
// 			Name: to.Ptr("credentialName1"),
// 			Value: []byte("Y3JlZGVudGlhbFZhbHVlMQ=="),
// 	}},
// }

Output:

func (*ManagedClustersClient) ListClusterUserCredentials 

func (client *ManagedClustersClient) ListClusterUserCredentials(ctx context.Context, resourceGroupName string, resourceName string, options *ManagedClustersClientListClusterUserCredentialsOptions) (ManagedClustersClientListClusterUserCredentialsResponse, error)

ListClusterUserCredentials - Lists the user credentials of a managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientListClusterUserCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterUserCredentials method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersListClusterUserCredentials.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().ListClusterUserCredentials(ctx, "rg1", "clustername1", &armcontainerservice.ManagedClustersClientListClusterUserCredentialsOptions{ServerFqdn: nil,
	Format: nil,
})
if err != nil {
	log.Fatalf("failed to finish the request: %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.CredentialResults = armcontainerservice.CredentialResults{
// 	Kubeconfigs: []*armcontainerservice.CredentialResult{
// 		{
// 			Name: to.Ptr("credentialName1"),
// 			Value: []byte("Y3JlZGVudGlhbFZhbHVlMQ=="),
// 	}},
// }

Output:

func (*ManagedClustersClient) ListKubernetesVersions 

func (client *ManagedClustersClient) ListKubernetesVersions(ctx context.Context, location string, options *ManagedClustersClientListKubernetesVersionsOptions) (ManagedClustersClientListKubernetesVersionsResponse, error)

ListKubernetesVersions - Contains extra metadata on the version, including supported patch versions, capabilities, available upgrades, and details on preview status of the version If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • location - The name of the Azure region.
  • options - ManagedClustersClientListKubernetesVersionsOptions contains the optional parameters for the ManagedClustersClient.ListKubernetesVersions method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/KubernetesVersions_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewManagedClustersClient().ListKubernetesVersions(ctx, "location1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.KubernetesVersionListResult = armcontainerservice.KubernetesVersionListResult{
// 	Values: []*armcontainerservice.KubernetesVersion{
// 		{
// 			Capabilities: &armcontainerservice.KubernetesVersionCapabilities{
// 				SupportPlan: []*armcontainerservice.KubernetesSupportPlan{
// 					to.Ptr(armcontainerservice.KubernetesSupportPlanKubernetesOfficial)},
// 				},
// 				PatchVersions: map[string]*armcontainerservice.KubernetesPatchVersion{
// 					"1.23.12": &armcontainerservice.KubernetesPatchVersion{
// 						Upgrades: []*string{
// 							to.Ptr("1.23.15"),
// 							to.Ptr("1.24.6"),
// 							to.Ptr("1.24.9")},
// 						},
// 						"1.23.15": &armcontainerservice.KubernetesPatchVersion{
// 							Upgrades: []*string{
// 								to.Ptr("1.24.6"),
// 								to.Ptr("1.24.9")},
// 							},
// 						},
// 						Version: to.Ptr("1.23"),
// 					},
// 					{
// 						Capabilities: &armcontainerservice.KubernetesVersionCapabilities{
// 							SupportPlan: []*armcontainerservice.KubernetesSupportPlan{
// 								to.Ptr(armcontainerservice.KubernetesSupportPlanKubernetesOfficial)},
// 							},
// 							IsDefault: to.Ptr(true),
// 							PatchVersions: map[string]*armcontainerservice.KubernetesPatchVersion{
// 								"1.24.6": &armcontainerservice.KubernetesPatchVersion{
// 									Upgrades: []*string{
// 										to.Ptr("1.24.9"),
// 										to.Ptr("1.25.4"),
// 										to.Ptr("1.25.5")},
// 									},
// 									"1.24.9": &armcontainerservice.KubernetesPatchVersion{
// 										Upgrades: []*string{
// 											to.Ptr("1.25.4"),
// 											to.Ptr("1.25.5")},
// 										},
// 									},
// 									Version: to.Ptr("1.24"),
// 								},
// 								{
// 									Capabilities: &armcontainerservice.KubernetesVersionCapabilities{
// 										SupportPlan: []*armcontainerservice.KubernetesSupportPlan{
// 											to.Ptr(armcontainerservice.KubernetesSupportPlanKubernetesOfficial)},
// 										},
// 										PatchVersions: map[string]*armcontainerservice.KubernetesPatchVersion{
// 											"1.25.4": &armcontainerservice.KubernetesPatchVersion{
// 												Upgrades: []*string{
// 													to.Ptr("1.25.5"),
// 													to.Ptr("1.26.0")},
// 												},
// 												"1.25.5": &armcontainerservice.KubernetesPatchVersion{
// 													Upgrades: []*string{
// 														to.Ptr("1.26.0")},
// 													},
// 												},
// 												Version: to.Ptr("1.25"),
// 											},
// 											{
// 												Capabilities: &armcontainerservice.KubernetesVersionCapabilities{
// 													SupportPlan: []*armcontainerservice.KubernetesSupportPlan{
// 														to.Ptr(armcontainerservice.KubernetesSupportPlanKubernetesOfficial)},
// 													},
// 													IsPreview: to.Ptr(true),
// 													PatchVersions: map[string]*armcontainerservice.KubernetesPatchVersion{
// 														"1.26.0": &armcontainerservice.KubernetesPatchVersion{
// 															Upgrades: []*string{
// 															},
// 														},
// 													},
// 													Version: to.Ptr("1.26"),
// 											}},
// 										}

Output:

func (*ManagedClustersClient) NewListByResourceGroupPager 

func (client *ManagedClustersClient) NewListByResourceGroupPager(resourceGroupName string, options *ManagedClustersClientListByResourceGroupOptions) *runtime.Pager[ManagedClustersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists managed clusters in the specified subscription and resource group.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - ManagedClustersClientListByResourceGroupOptions contains the optional parameters for the ManagedClustersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedClustersClient().NewListByResourceGroupPager("rg1", 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.ManagedClusterListResult = armcontainerservice.ManagedClusterListResult{
	// 	Value: []*armcontainerservice.ManagedCluster{
	// 		{
	// 			Name: to.Ptr("clustername1"),
	// 			Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
	// 			Location: to.Ptr("location1"),
	// 			Tags: map[string]*string{
	// 				"archv2": to.Ptr(""),
	// 				"tier": to.Ptr("production"),
	// 			},
	// 			Properties: &armcontainerservice.ManagedClusterProperties{
	// 				AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
	// 					{
	// 						Count: to.Ptr[int32](3),
	// 						CurrentOrchestratorVersion: to.Ptr("1.9.6"),
	// 						MaxPods: to.Ptr[int32](110),
	// 						OrchestratorVersion: to.Ptr("1.9.6"),
	// 						OSType: to.Ptr(armcontainerservice.OSTypeLinux),
	// 						ProvisioningState: to.Ptr("Succeeded"),
	// 						VMSize: to.Ptr("Standard_DS1_v2"),
	// 						Name: to.Ptr("nodepool1"),
	// 				}},
	// 				CurrentKubernetesVersion: to.Ptr("1.9.6"),
	// 				DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
	// 				DNSPrefix: to.Ptr("dnsprefix1"),
	// 				EnableRBAC: to.Ptr(false),
	// 				Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
	// 				KubernetesVersion: to.Ptr("1.9.6"),
	// 				LinuxProfile: &armcontainerservice.LinuxProfile{
	// 					AdminUsername: to.Ptr("azureuser"),
	// 					SSH: &armcontainerservice.SSHConfiguration{
	// 						PublicKeys: []*armcontainerservice.SSHPublicKey{
	// 							{
	// 								KeyData: to.Ptr("keydata"),
	// 						}},
	// 					},
	// 				},
	// 				MaxAgentPools: to.Ptr[int32](1),
	// 				NetworkProfile: &armcontainerservice.NetworkProfile{
	// 					DNSServiceIP: to.Ptr("10.0.0.10"),
	// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
	// 					PodCidr: to.Ptr("10.244.0.0/16"),
	// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
	// 				},
	// 				NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
	// 					ClientID: to.Ptr("clientid"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

func (*ManagedClustersClient) NewListMeshRevisionProfilesPager 

func (client *ManagedClustersClient) NewListMeshRevisionProfilesPager(location string, options *ManagedClustersClientListMeshRevisionProfilesOptions) *runtime.Pager[ManagedClustersClientListMeshRevisionProfilesResponse]

NewListMeshRevisionProfilesPager - Contains extra metadata on each revision, including supported revisions, cluster compatibility and available upgrades

Generated from API version 2024-09-01

  • location - The name of the Azure region.
  • options - ManagedClustersClientListMeshRevisionProfilesOptions contains the optional parameters for the ManagedClustersClient.NewListMeshRevisionProfilesPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersList_MeshRevisionProfiles.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedClustersClient().NewListMeshRevisionProfilesPager("location1", 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.MeshRevisionProfileList = armcontainerservice.MeshRevisionProfileList{
	// 	Value: []*armcontainerservice.MeshRevisionProfile{
	// 		{
	// 			Name: to.Ptr("istio"),
	// 			Type: to.Ptr("Microsoft.ContainerService/locations/meshRevisionProfiles"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/providers/Microsoft.ContainerService/locations/location1/meshRevisionProfiles/istio"),
	// 			Properties: &armcontainerservice.MeshRevisionProfileProperties{
	// 				MeshRevisions: []*armcontainerservice.MeshRevision{
	// 					{
	// 						CompatibleWith: []*armcontainerservice.CompatibleVersions{
	// 							{
	// 								Name: to.Ptr("kubernetes"),
	// 								Versions: []*string{
	// 									to.Ptr("1.23"),
	// 									to.Ptr("1.24"),
	// 									to.Ptr("1.25"),
	// 									to.Ptr("1.26")},
	// 							}},
	// 							Revision: to.Ptr("asm-1-17"),
	// 							Upgrades: []*string{
	// 								to.Ptr("asm-1-18")},
	// 							},
	// 							{
	// 								CompatibleWith: []*armcontainerservice.CompatibleVersions{
	// 									{
	// 										Name: to.Ptr("kubernetes"),
	// 										Versions: []*string{
	// 											to.Ptr("1.24"),
	// 											to.Ptr("1.25"),
	// 											to.Ptr("1.26"),
	// 											to.Ptr("1.27")},
	// 									}},
	// 									Revision: to.Ptr("asm-1-18"),
	// 									Upgrades: []*string{
	// 									},
	// 							}},
	// 						},
	// 				}},
	// 			}
}

Output:

func (*ManagedClustersClient) NewListMeshUpgradeProfilesPager 

func (client *ManagedClustersClient) NewListMeshUpgradeProfilesPager(resourceGroupName string, resourceName string, options *ManagedClustersClientListMeshUpgradeProfilesOptions) *runtime.Pager[ManagedClustersClientListMeshUpgradeProfilesResponse]

NewListMeshUpgradeProfilesPager - Lists available upgrades for all service meshes in a specific cluster.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientListMeshUpgradeProfilesOptions contains the optional parameters for the ManagedClustersClient.NewListMeshUpgradeProfilesPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersList_MeshUpgradeProfiles.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedClustersClient().NewListMeshUpgradeProfilesPager("rg1", "clustername1", 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.MeshUpgradeProfileList = armcontainerservice.MeshUpgradeProfileList{
	// 	Value: []*armcontainerservice.MeshUpgradeProfile{
	// 		{
	// 			Name: to.Ptr("istio"),
	// 			Type: to.Ptr("Microsoft.ContainerService/managedClusters/meshUpgradeProfiles"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/meshUpgradeProfiles/istio"),
	// 			Properties: &armcontainerservice.MeshUpgradeProfileProperties{
	// 				CompatibleWith: []*armcontainerservice.CompatibleVersions{
	// 					{
	// 						Name: to.Ptr("kubernetes"),
	// 						Versions: []*string{
	// 							to.Ptr("1.23"),
	// 							to.Ptr("1.24"),
	// 							to.Ptr("1.25"),
	// 							to.Ptr("1.26")},
	// 					}},
	// 					Revision: to.Ptr("asm-1-17"),
	// 					Upgrades: []*string{
	// 						to.Ptr("asm-1-18")},
	// 					},
	// 			}},
	// 		}
}

Output:

func (*ManagedClustersClient) NewListOutboundNetworkDependenciesEndpointsPager 

func (client *ManagedClustersClient) NewListOutboundNetworkDependenciesEndpointsPager(resourceGroupName string, resourceName string, options *ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions) *runtime.Pager[ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse]

NewListOutboundNetworkDependenciesEndpointsPager - Gets a list of egress endpoints (network endpoints of all outbound dependencies) in the specified managed cluster. The operation returns properties of each egress endpoint.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions contains the optional parameters for the ManagedClustersClient.NewListOutboundNetworkDependenciesEndpointsPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/OutboundNetworkDependenciesEndpointsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedClustersClient().NewListOutboundNetworkDependenciesEndpointsPager("rg1", "clustername1", 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.OutboundEnvironmentEndpointCollection = armcontainerservice.OutboundEnvironmentEndpointCollection{
	// 	Value: []*armcontainerservice.OutboundEnvironmentEndpoint{
	// 		{
	// 			Category: to.Ptr("azure-resource-management"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("management.azure.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("login.microsoftonline.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("images"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("mcr.microsoft.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("*.data.mcr.microsoft.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Description: to.Ptr("mcr cdn"),
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("artifacts"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("packages.microsoft.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("acs-mirror.azureedge.net"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("time-sync"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("ntp.ubuntu.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](123),
	// 							Protocol: to.Ptr("UDP"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("ubuntu-optional"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("security.ubuntu.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("azure.archive.ubuntu.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("changelogs.ubuntu.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("gpu"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("nvidia.github.io"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("us.download.nvidia.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("apt.dockerproject.org"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("windows"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("onegetcdn.azureedge.net"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("go.microsoft.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("*.mp.microsoft.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("www.msftconnecttest.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 				},
	// 				{
	// 					DomainName: to.Ptr("ctldl.windowsupdate.com"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](80),
	// 							Protocol: to.Ptr("Http"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("apiserver"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("*.azmk8s.io"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](443),
	// 							Protocol: to.Ptr("Https"),
	// 					}},
	// 			}},
	// 		},
	// 		{
	// 			Category: to.Ptr("tunnel-classic"),
	// 			Endpoints: []*armcontainerservice.EndpointDependency{
	// 				{
	// 					DomainName: to.Ptr("*.azmk8s.io"),
	// 					EndpointDetails: []*armcontainerservice.EndpointDetail{
	// 						{
	// 							Port: to.Ptr[int32](9000),
	// 							Protocol: to.Ptr("TCP"),
	// 					}},
	// 			}},
	// 	}},
	// }
}

Output:

func (*ManagedClustersClient) NewListPager 

func (client *ManagedClustersClient) NewListPager(options *ManagedClustersClientListOptions) *runtime.Pager[ManagedClustersClientListResponse]

NewListPager - Gets a list of managed clusters in the specified subscription.

Generated from API version 2024-09-01

  • options - ManagedClustersClientListOptions contains the optional parameters for the ManagedClustersClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ManagedClustersList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewManagedClustersClient().NewListPager(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.ManagedClusterListResult = armcontainerservice.ManagedClusterListResult{
	// 	Value: []*armcontainerservice.ManagedCluster{
	// 		{
	// 			Name: to.Ptr("clustername1"),
	// 			Type: to.Ptr("Microsoft.ContainerService/ManagedClusters"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1"),
	// 			Location: to.Ptr("location1"),
	// 			Tags: map[string]*string{
	// 				"archv2": to.Ptr(""),
	// 				"tier": to.Ptr("production"),
	// 			},
	// 			ETag: to.Ptr("nvweuib"),
	// 			Properties: &armcontainerservice.ManagedClusterProperties{
	// 				AgentPoolProfiles: []*armcontainerservice.ManagedClusterAgentPoolProfile{
	// 					{
	// 						Count: to.Ptr[int32](3),
	// 						CurrentOrchestratorVersion: to.Ptr("1.9.6"),
	// 						ETag: to.Ptr("byuefvwi"),
	// 						MaxPods: to.Ptr[int32](110),
	// 						OrchestratorVersion: to.Ptr("1.9.6"),
	// 						OSType: to.Ptr(armcontainerservice.OSTypeLinux),
	// 						ProvisioningState: to.Ptr("Succeeded"),
	// 						VMSize: to.Ptr("Standard_DS1_v2"),
	// 						Name: to.Ptr("nodepool1"),
	// 				}},
	// 				CurrentKubernetesVersion: to.Ptr("1.9.6"),
	// 				DiskEncryptionSetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.Compute/diskEncryptionSets/des"),
	// 				DNSPrefix: to.Ptr("dnsprefix1"),
	// 				EnableRBAC: to.Ptr(false),
	// 				Fqdn: to.Ptr("dnsprefix1-abcd1234.hcp.eastus.azmk8s.io"),
	// 				KubernetesVersion: to.Ptr("1.9.6"),
	// 				LinuxProfile: &armcontainerservice.LinuxProfile{
	// 					AdminUsername: to.Ptr("azureuser"),
	// 					SSH: &armcontainerservice.SSHConfiguration{
	// 						PublicKeys: []*armcontainerservice.SSHPublicKey{
	// 							{
	// 								KeyData: to.Ptr("keydata"),
	// 						}},
	// 					},
	// 				},
	// 				MaxAgentPools: to.Ptr[int32](1),
	// 				NetworkProfile: &armcontainerservice.NetworkProfile{
	// 					DNSServiceIP: to.Ptr("10.0.0.10"),
	// 					NetworkPlugin: to.Ptr(armcontainerservice.NetworkPluginKubenet),
	// 					PodCidr: to.Ptr("10.244.0.0/16"),
	// 					ServiceCidr: to.Ptr("10.0.0.0/16"),
	// 				},
	// 				NodeResourceGroup: to.Ptr("MC_rg1_clustername1_location1"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 				ServicePrincipalProfile: &armcontainerservice.ManagedClusterServicePrincipalProfile{
	// 					ClientID: to.Ptr("clientid"),
	// 				},
	// 			},
	// 	}},
	// }
}

Output:

type ManagedClustersClientAbortLatestOperationResponse 

type ManagedClustersClientAbortLatestOperationResponse struct {
}

ManagedClustersClientAbortLatestOperationResponse contains the response from method ManagedClustersClient.BeginAbortLatestOperation.

type ManagedClustersClientBeginAbortLatestOperationOptions 

type ManagedClustersClientBeginAbortLatestOperationOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginAbortLatestOperationOptions contains the optional parameters for the ManagedClustersClient.BeginAbortLatestOperation method.

type ManagedClustersClientBeginCreateOrUpdateOptions 

type ManagedClustersClientBeginCreateOrUpdateOptions struct {
	// The request should only proceed if an entity matches this string.
	IfMatch *string

	// The request should only proceed if no entity matches this string.
	IfNoneMatch *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the ManagedClustersClient.BeginCreateOrUpdate method.

type ManagedClustersClientBeginDeleteOptions 

type ManagedClustersClientBeginDeleteOptions struct {
	// The request should only proceed if an entity matches this string.
	IfMatch *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginDeleteOptions contains the optional parameters for the ManagedClustersClient.BeginDelete method.

type ManagedClustersClientBeginResetAADProfileOptions 

type ManagedClustersClientBeginResetAADProfileOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginResetAADProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetAADProfile method.

type ManagedClustersClientBeginResetServicePrincipalProfileOptions 

type ManagedClustersClientBeginResetServicePrincipalProfileOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginResetServicePrincipalProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetServicePrincipalProfile method.

type ManagedClustersClientBeginRotateClusterCertificatesOptions 

type ManagedClustersClientBeginRotateClusterCertificatesOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginRotateClusterCertificatesOptions contains the optional parameters for the ManagedClustersClient.BeginRotateClusterCertificates method.

type ManagedClustersClientBeginRotateServiceAccountSigningKeysOptions 

type ManagedClustersClientBeginRotateServiceAccountSigningKeysOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginRotateServiceAccountSigningKeysOptions contains the optional parameters for the ManagedClustersClient.BeginRotateServiceAccountSigningKeys method.

type ManagedClustersClientBeginRunCommandOptions 

type ManagedClustersClientBeginRunCommandOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginRunCommandOptions contains the optional parameters for the ManagedClustersClient.BeginRunCommand method.

type ManagedClustersClientBeginStartOptions 

type ManagedClustersClientBeginStartOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginStartOptions contains the optional parameters for the ManagedClustersClient.BeginStart method.

type ManagedClustersClientBeginStopOptions 

type ManagedClustersClientBeginStopOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginStopOptions contains the optional parameters for the ManagedClustersClient.BeginStop method.

type ManagedClustersClientBeginUpdateTagsOptions 

type ManagedClustersClientBeginUpdateTagsOptions struct {
	// The request should only proceed if an entity matches this string.
	IfMatch *string

	// Resumes the LRO from the provided token.
	ResumeToken string
}

ManagedClustersClientBeginUpdateTagsOptions contains the optional parameters for the ManagedClustersClient.BeginUpdateTags method.

type ManagedClustersClientCreateOrUpdateResponse 

type ManagedClustersClientCreateOrUpdateResponse struct {
	// Managed cluster.
	ManagedCluster
}

ManagedClustersClientCreateOrUpdateResponse contains the response from method ManagedClustersClient.BeginCreateOrUpdate.

type ManagedClustersClientDeleteResponse 

type ManagedClustersClientDeleteResponse struct {
}

ManagedClustersClientDeleteResponse contains the response from method ManagedClustersClient.BeginDelete.

type ManagedClustersClientGetAccessProfileOptions 

type ManagedClustersClientGetAccessProfileOptions struct {
}

ManagedClustersClientGetAccessProfileOptions contains the optional parameters for the ManagedClustersClient.GetAccessProfile method.

type ManagedClustersClientGetAccessProfileResponse 

type ManagedClustersClientGetAccessProfileResponse struct {
	// Managed cluster Access Profile.
	ManagedClusterAccessProfile
}

ManagedClustersClientGetAccessProfileResponse contains the response from method ManagedClustersClient.GetAccessProfile.

type ManagedClustersClientGetCommandResultOptions 

type ManagedClustersClientGetCommandResultOptions struct {
}

ManagedClustersClientGetCommandResultOptions contains the optional parameters for the ManagedClustersClient.GetCommandResult method.

type ManagedClustersClientGetCommandResultResponse 

type ManagedClustersClientGetCommandResultResponse struct {
	// run command result.
	RunCommandResult

	// Location contains the information returned from the Location header response.
	Location *string
}

ManagedClustersClientGetCommandResultResponse contains the response from method ManagedClustersClient.GetCommandResult.

type ManagedClustersClientGetMeshRevisionProfileOptions 

type ManagedClustersClientGetMeshRevisionProfileOptions struct {
}

ManagedClustersClientGetMeshRevisionProfileOptions contains the optional parameters for the ManagedClustersClient.GetMeshRevisionProfile method.

type ManagedClustersClientGetMeshRevisionProfileResponse 

type ManagedClustersClientGetMeshRevisionProfileResponse struct {
	// Mesh revision profile for a mesh.
	MeshRevisionProfile
}

ManagedClustersClientGetMeshRevisionProfileResponse contains the response from method ManagedClustersClient.GetMeshRevisionProfile.

type ManagedClustersClientGetMeshUpgradeProfileOptions 

type ManagedClustersClientGetMeshUpgradeProfileOptions struct {
}

ManagedClustersClientGetMeshUpgradeProfileOptions contains the optional parameters for the ManagedClustersClient.GetMeshUpgradeProfile method.

type ManagedClustersClientGetMeshUpgradeProfileResponse 

type ManagedClustersClientGetMeshUpgradeProfileResponse struct {
	// Upgrade profile for given mesh.
	MeshUpgradeProfile
}

ManagedClustersClientGetMeshUpgradeProfileResponse contains the response from method ManagedClustersClient.GetMeshUpgradeProfile.

type ManagedClustersClientGetOptions 

type ManagedClustersClientGetOptions struct {
}

ManagedClustersClientGetOptions contains the optional parameters for the ManagedClustersClient.Get method.

type ManagedClustersClientGetResponse 

type ManagedClustersClientGetResponse struct {
	// Managed cluster.
	ManagedCluster
}

ManagedClustersClientGetResponse contains the response from method ManagedClustersClient.Get.

type ManagedClustersClientGetUpgradeProfileOptions 

type ManagedClustersClientGetUpgradeProfileOptions struct {
}

ManagedClustersClientGetUpgradeProfileOptions contains the optional parameters for the ManagedClustersClient.GetUpgradeProfile method.

type ManagedClustersClientGetUpgradeProfileResponse 

type ManagedClustersClientGetUpgradeProfileResponse struct {
	// The list of available upgrades for compute pools.
	ManagedClusterUpgradeProfile
}

ManagedClustersClientGetUpgradeProfileResponse contains the response from method ManagedClustersClient.GetUpgradeProfile.

type ManagedClustersClientListByResourceGroupOptions 

type ManagedClustersClientListByResourceGroupOptions struct {
}

ManagedClustersClientListByResourceGroupOptions contains the optional parameters for the ManagedClustersClient.NewListByResourceGroupPager method.

type ManagedClustersClientListByResourceGroupResponse 

type ManagedClustersClientListByResourceGroupResponse struct {
	// The response from the List Managed Clusters operation.
	ManagedClusterListResult
}

ManagedClustersClientListByResourceGroupResponse contains the response from method ManagedClustersClient.NewListByResourceGroupPager.

type ManagedClustersClientListClusterAdminCredentialsOptions 

type ManagedClustersClientListClusterAdminCredentialsOptions struct {
	// server fqdn type for credentials to be returned
	ServerFqdn *string
}

ManagedClustersClientListClusterAdminCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterAdminCredentials method.

type ManagedClustersClientListClusterAdminCredentialsResponse 

type ManagedClustersClientListClusterAdminCredentialsResponse struct {
	// The list credential result response.
	CredentialResults
}

ManagedClustersClientListClusterAdminCredentialsResponse contains the response from method ManagedClustersClient.ListClusterAdminCredentials.

type ManagedClustersClientListClusterMonitoringUserCredentialsOptions 

type ManagedClustersClientListClusterMonitoringUserCredentialsOptions struct {
	// server fqdn type for credentials to be returned
	ServerFqdn *string
}

ManagedClustersClientListClusterMonitoringUserCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterMonitoringUserCredentials method.

type ManagedClustersClientListClusterMonitoringUserCredentialsResponse 

type ManagedClustersClientListClusterMonitoringUserCredentialsResponse struct {
	// The list credential result response.
	CredentialResults
}

ManagedClustersClientListClusterMonitoringUserCredentialsResponse contains the response from method ManagedClustersClient.ListClusterMonitoringUserCredentials.

type ManagedClustersClientListClusterUserCredentialsOptions 

type ManagedClustersClientListClusterUserCredentialsOptions struct {
	// Only apply to AAD clusters, specifies the format of returned kubeconfig. Format 'azure' will return azure auth-provider
	// kubeconfig; format 'exec' will return exec format kubeconfig, which requires
	// kubelogin binary in the path.
	Format *Format

	// server fqdn type for credentials to be returned
	ServerFqdn *string
}

ManagedClustersClientListClusterUserCredentialsOptions contains the optional parameters for the ManagedClustersClient.ListClusterUserCredentials method.

type ManagedClustersClientListClusterUserCredentialsResponse 

type ManagedClustersClientListClusterUserCredentialsResponse struct {
	// The list credential result response.
	CredentialResults
}

ManagedClustersClientListClusterUserCredentialsResponse contains the response from method ManagedClustersClient.ListClusterUserCredentials.

type ManagedClustersClientListKubernetesVersionsOptions 

type ManagedClustersClientListKubernetesVersionsOptions struct {
}

ManagedClustersClientListKubernetesVersionsOptions contains the optional parameters for the ManagedClustersClient.ListKubernetesVersions method.

type ManagedClustersClientListKubernetesVersionsResponse 

type ManagedClustersClientListKubernetesVersionsResponse struct {
	// Hold values properties, which is array of KubernetesVersion
	KubernetesVersionListResult
}

ManagedClustersClientListKubernetesVersionsResponse contains the response from method ManagedClustersClient.ListKubernetesVersions.

type ManagedClustersClientListMeshRevisionProfilesOptions 

type ManagedClustersClientListMeshRevisionProfilesOptions struct {
}

ManagedClustersClientListMeshRevisionProfilesOptions contains the optional parameters for the ManagedClustersClient.NewListMeshRevisionProfilesPager method.

type ManagedClustersClientListMeshRevisionProfilesResponse 

type ManagedClustersClientListMeshRevisionProfilesResponse struct {
	// Holds an array of MeshRevisionsProfiles
	MeshRevisionProfileList
}

ManagedClustersClientListMeshRevisionProfilesResponse contains the response from method ManagedClustersClient.NewListMeshRevisionProfilesPager.

type ManagedClustersClientListMeshUpgradeProfilesOptions 

type ManagedClustersClientListMeshUpgradeProfilesOptions struct {
}

ManagedClustersClientListMeshUpgradeProfilesOptions contains the optional parameters for the ManagedClustersClient.NewListMeshUpgradeProfilesPager method.

type ManagedClustersClientListMeshUpgradeProfilesResponse 

type ManagedClustersClientListMeshUpgradeProfilesResponse struct {
	// Holds an array of MeshUpgradeProfiles
	MeshUpgradeProfileList
}

ManagedClustersClientListMeshUpgradeProfilesResponse contains the response from method ManagedClustersClient.NewListMeshUpgradeProfilesPager.

type ManagedClustersClientListOptions 

type ManagedClustersClientListOptions struct {
}

ManagedClustersClientListOptions contains the optional parameters for the ManagedClustersClient.NewListPager method.

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions 

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions struct {
}

ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions contains the optional parameters for the ManagedClustersClient.NewListOutboundNetworkDependenciesEndpointsPager method.

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse 

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse struct {
	// Collection of OutboundEnvironmentEndpoint
	OutboundEnvironmentEndpointCollection
}

ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse contains the response from method ManagedClustersClient.NewListOutboundNetworkDependenciesEndpointsPager.

type ManagedClustersClientListResponse 

type ManagedClustersClientListResponse struct {
	// The response from the List Managed Clusters operation.
	ManagedClusterListResult
}

ManagedClustersClientListResponse contains the response from method ManagedClustersClient.NewListPager.

type ManagedClustersClientResetAADProfileResponse 

type ManagedClustersClientResetAADProfileResponse struct {
}

ManagedClustersClientResetAADProfileResponse contains the response from method ManagedClustersClient.BeginResetAADProfile.

type ManagedClustersClientResetServicePrincipalProfileResponse 

type ManagedClustersClientResetServicePrincipalProfileResponse struct {
}

ManagedClustersClientResetServicePrincipalProfileResponse contains the response from method ManagedClustersClient.BeginResetServicePrincipalProfile.

type ManagedClustersClientRotateClusterCertificatesResponse 

type ManagedClustersClientRotateClusterCertificatesResponse struct {
}

ManagedClustersClientRotateClusterCertificatesResponse contains the response from method ManagedClustersClient.BeginRotateClusterCertificates.

type ManagedClustersClientRotateServiceAccountSigningKeysResponse 

type ManagedClustersClientRotateServiceAccountSigningKeysResponse struct {
}

ManagedClustersClientRotateServiceAccountSigningKeysResponse contains the response from method ManagedClustersClient.BeginRotateServiceAccountSigningKeys.

type ManagedClustersClientRunCommandResponse 

type ManagedClustersClientRunCommandResponse struct {
	// run command result.
	RunCommandResult
}

ManagedClustersClientRunCommandResponse contains the response from method ManagedClustersClient.BeginRunCommand.

type ManagedClustersClientStartResponse 

type ManagedClustersClientStartResponse struct {
}

ManagedClustersClientStartResponse contains the response from method ManagedClustersClient.BeginStart.

type ManagedClustersClientStopResponse 

type ManagedClustersClientStopResponse struct {
}

ManagedClustersClientStopResponse contains the response from method ManagedClustersClient.BeginStop.

type ManagedClustersClientUpdateTagsResponse 

type ManagedClustersClientUpdateTagsResponse struct {
	// Managed cluster.
	ManagedCluster
}

ManagedClustersClientUpdateTagsResponse contains the response from method ManagedClustersClient.BeginUpdateTags.

type ManagedServiceIdentityUserAssignedIdentitiesValue 

type ManagedServiceIdentityUserAssignedIdentitiesValue struct {
	// READ-ONLY; The client id of user assigned identity.
	ClientID *string

	// READ-ONLY; The principal id of user assigned identity.
	PrincipalID *string
}

func (ManagedServiceIdentityUserAssignedIdentitiesValue) MarshalJSON 

func (m ManagedServiceIdentityUserAssignedIdentitiesValue) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentityUserAssignedIdentitiesValue.

func (*ManagedServiceIdentityUserAssignedIdentitiesValue) UnmarshalJSON 

func (m *ManagedServiceIdentityUserAssignedIdentitiesValue) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentityUserAssignedIdentitiesValue.

type MeshRevision 

type MeshRevision struct {
	// List of items this revision of service mesh is compatible with, and their associated versions.
	CompatibleWith []*CompatibleVersions

	// The revision of the mesh release.
	Revision *string

	// List of revisions available for upgrade of a specific mesh revision
	Upgrades []*string
}

MeshRevision - Holds information on upgrades and compatibility for given major.minor mesh release.

func (MeshRevision) MarshalJSON 

func (m MeshRevision) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshRevision.

func (*MeshRevision) UnmarshalJSON 

func (m *MeshRevision) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshRevision.

type MeshRevisionProfile 

type MeshRevisionProfile struct {
	// Mesh revision profile properties for a mesh
	Properties *MeshRevisionProfileProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

MeshRevisionProfile - Mesh revision profile for a mesh.

func (MeshRevisionProfile) MarshalJSON 

func (m MeshRevisionProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshRevisionProfile.

func (*MeshRevisionProfile) UnmarshalJSON 

func (m *MeshRevisionProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshRevisionProfile.

type MeshRevisionProfileList 

type MeshRevisionProfileList struct {
	// Array of service mesh add-on revision profiles for all supported mesh modes.
	Value []*MeshRevisionProfile

	// READ-ONLY; The URL to get the next set of mesh revision profile.
	NextLink *string
}

MeshRevisionProfileList - Holds an array of MeshRevisionsProfiles

func (MeshRevisionProfileList) MarshalJSON 

func (m MeshRevisionProfileList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshRevisionProfileList.

func (*MeshRevisionProfileList) UnmarshalJSON 

func (m *MeshRevisionProfileList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshRevisionProfileList.

type MeshRevisionProfileProperties 

type MeshRevisionProfileProperties struct {
	MeshRevisions []*MeshRevision
}

MeshRevisionProfileProperties - Mesh revision profile properties for a mesh

func (MeshRevisionProfileProperties) MarshalJSON 

func (m MeshRevisionProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshRevisionProfileProperties.

func (*MeshRevisionProfileProperties) UnmarshalJSON 

func (m *MeshRevisionProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshRevisionProfileProperties.

type MeshUpgradeProfile 

type MeshUpgradeProfile struct {
	// Mesh upgrade profile properties for a major.minor release.
	Properties *MeshUpgradeProfileProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

MeshUpgradeProfile - Upgrade profile for given mesh.

func (MeshUpgradeProfile) MarshalJSON 

func (m MeshUpgradeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshUpgradeProfile.

func (*MeshUpgradeProfile) UnmarshalJSON 

func (m *MeshUpgradeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshUpgradeProfile.

type MeshUpgradeProfileList 

type MeshUpgradeProfileList struct {
	// Array of supported service mesh add-on upgrade profiles.
	Value []*MeshUpgradeProfile

	// READ-ONLY; The URL to get the next set of mesh upgrade profile.
	NextLink *string
}

MeshUpgradeProfileList - Holds an array of MeshUpgradeProfiles

func (MeshUpgradeProfileList) MarshalJSON 

func (m MeshUpgradeProfileList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshUpgradeProfileList.

func (*MeshUpgradeProfileList) UnmarshalJSON 

func (m *MeshUpgradeProfileList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshUpgradeProfileList.

type MeshUpgradeProfileProperties 

type MeshUpgradeProfileProperties struct {
	// List of items this revision of service mesh is compatible with, and their associated versions.
	CompatibleWith []*CompatibleVersions

	// The revision of the mesh release.
	Revision *string

	// List of revisions available for upgrade of a specific mesh revision
	Upgrades []*string
}

MeshUpgradeProfileProperties - Mesh upgrade profile properties for a major.minor release.

func (MeshUpgradeProfileProperties) MarshalJSON 

func (m MeshUpgradeProfileProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MeshUpgradeProfileProperties.

func (*MeshUpgradeProfileProperties) UnmarshalJSON 

func (m *MeshUpgradeProfileProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MeshUpgradeProfileProperties.

type NetworkDataplane 

type NetworkDataplane string

NetworkDataplane - Network dataplane used in the Kubernetes cluster. 

const (
	// NetworkDataplaneAzure - Use Azure network dataplane.
	NetworkDataplaneAzure NetworkDataplane = "azure"
	// NetworkDataplaneCilium - Use Cilium network dataplane. See [Azure CNI Powered by Cilium](https://learn.microsoft.com/azure/aks/azure-cni-powered-by-cilium)
	// for more information.
	NetworkDataplaneCilium NetworkDataplane = "cilium"
)

func PossibleNetworkDataplaneValues 

func PossibleNetworkDataplaneValues() []NetworkDataplane

PossibleNetworkDataplaneValues returns the possible values for the NetworkDataplane const type.

type NetworkMode 

type NetworkMode string

NetworkMode - This cannot be specified if networkPlugin is anything other than 'azure'. 

const (
	// NetworkModeBridge - This is no longer supported
	NetworkModeBridge NetworkMode = "bridge"
	// NetworkModeTransparent - No bridge is created. Intra-VM Pod to Pod communication is through IP routes created by Azure
	// CNI. See [Transparent Mode](https://docs.microsoft.com/azure/aks/faq#transparent-mode) for more information.
	NetworkModeTransparent NetworkMode = "transparent"
)

func PossibleNetworkModeValues 

func PossibleNetworkModeValues() []NetworkMode

PossibleNetworkModeValues returns the possible values for the NetworkMode const type.

type NetworkPlugin 

type NetworkPlugin string

NetworkPlugin - Network plugin used for building the Kubernetes network. 

const (
	// NetworkPluginAzure - Use the Azure CNI network plugin. See [Azure CNI (advanced) networking](https://docs.microsoft.com/azure/aks/concepts-network#azure-cni-advanced-networking)
	// for more information.
	NetworkPluginAzure NetworkPlugin = "azure"
	// NetworkPluginKubenet - Use the Kubenet network plugin. See [Kubenet (basic) networking](https://docs.microsoft.com/azure/aks/concepts-network#kubenet-basic-networking)
	// for more information.
	NetworkPluginKubenet NetworkPlugin = "kubenet"
	// NetworkPluginNone - No CNI plugin is pre-installed. See [BYO CNI](https://docs.microsoft.com/en-us/azure/aks/use-byo-cni)
	// for more information.
	NetworkPluginNone NetworkPlugin = "none"
)

func PossibleNetworkPluginValues 

func PossibleNetworkPluginValues() []NetworkPlugin

PossibleNetworkPluginValues returns the possible values for the NetworkPlugin const type.

type NetworkPluginMode 

type NetworkPluginMode string

NetworkPluginMode - The mode the network plugin should use. 

const (
	// NetworkPluginModeOverlay - Used with networkPlugin=azure, pods are given IPs from the PodCIDR address space but use Azure
	// Routing Domains rather than Kubenet's method of route tables. For more information visit https://aka.ms/aks/azure-cni-overlay.
	NetworkPluginModeOverlay NetworkPluginMode = "overlay"
)

func PossibleNetworkPluginModeValues 

func PossibleNetworkPluginModeValues() []NetworkPluginMode

PossibleNetworkPluginModeValues returns the possible values for the NetworkPluginMode const type.

type NetworkPolicy 

type NetworkPolicy string

NetworkPolicy - Network policy used for building the Kubernetes network. 

const (
	// NetworkPolicyAzure - Use Azure network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities)
	// for more information.
	NetworkPolicyAzure NetworkPolicy = "azure"
	// NetworkPolicyCalico - Use Calico network policies. See [differences between Azure and Calico policies](https://docs.microsoft.com/azure/aks/use-network-policies#differences-between-azure-and-calico-policies-and-their-capabilities)
	// for more information.
	NetworkPolicyCalico NetworkPolicy = "calico"
	// NetworkPolicyCilium - Use Cilium to enforce network policies. This requires networkDataplane to be 'cilium'.
	NetworkPolicyCilium NetworkPolicy = "cilium"
	// NetworkPolicyNone - Network policies will not be enforced. This is the default value when NetworkPolicy is not specified.
	NetworkPolicyNone NetworkPolicy = "none"
)

func PossibleNetworkPolicyValues 

func PossibleNetworkPolicyValues() []NetworkPolicy

PossibleNetworkPolicyValues returns the possible values for the NetworkPolicy const type.

type NetworkProfile 

type NetworkProfile struct {
	// Advanced Networking profile for enabling observability and security feature suite on a cluster. For more information see
	// aka.ms/aksadvancednetworking.
	AdvancedNetworking *AdvancedNetworking

	// An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified
	// in serviceCidr.
	DNSServiceIP *string

	// IP families are used to determine single-stack or dual-stack clusters. For single-stack, the expected value is IPv4. For
	// dual-stack, the expected values are IPv4 and IPv6.
	IPFamilies []*IPFamily

	// Profile of the cluster load balancer.
	LoadBalancerProfile *ManagedClusterLoadBalancerProfile

	// The default is 'standard'. See Azure Load Balancer SKUs [https://docs.microsoft.com/azure/load-balancer/skus] for more
	// information about the differences between load balancer SKUs.
	LoadBalancerSKU *LoadBalancerSKU

	// Profile of the cluster NAT gateway.
	NatGatewayProfile *ManagedClusterNATGatewayProfile

	// Network dataplane used in the Kubernetes cluster.
	NetworkDataplane *NetworkDataplane

	// This cannot be specified if networkPlugin is anything other than 'azure'.
	NetworkMode *NetworkMode

	// Network plugin used for building the Kubernetes network.
	NetworkPlugin *NetworkPlugin

	// The mode the network plugin should use.
	NetworkPluginMode *NetworkPluginMode

	// Network policy used for building the Kubernetes network.
	NetworkPolicy *NetworkPolicy

	// This can only be set at cluster creation time and cannot be changed later. For more information see egress outbound type
	// [https://docs.microsoft.com/azure/aks/egress-outboundtype].
	OutboundType *OutboundType

	// A CIDR notation IP range from which to assign pod IPs when kubenet is used.
	PodCidr *string

	// One IPv4 CIDR is expected for single-stack networking. Two CIDRs, one for each IP family (IPv4/IPv6), is expected for dual-stack
	// networking.
	PodCidrs []*string

	// A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
	ServiceCidr *string

	// One IPv4 CIDR is expected for single-stack networking. Two CIDRs, one for each IP family (IPv4/IPv6), is expected for dual-stack
	// networking. They must not overlap with any Subnet IP ranges.
	ServiceCidrs []*string
}

NetworkProfile - Profile of network configuration.

func (NetworkProfile) MarshalJSON 

func (n NetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkProfile.

func (*NetworkProfile) UnmarshalJSON 

func (n *NetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkProfile.

type NodeOSUpgradeChannel 

type NodeOSUpgradeChannel string

NodeOSUpgradeChannel - Manner in which the OS on your nodes is updated. The default is NodeImage. 

const (
	// NodeOSUpgradeChannelNodeImage - AKS will update the nodes with a newly patched VHD containing security fixes and bugfixes
	// on a weekly cadence. With the VHD update machines will be rolling reimaged to that VHD following maintenance windows and
	// surge settings. No extra VHD cost is incurred when choosing this option as AKS hosts the images.
	NodeOSUpgradeChannelNodeImage NodeOSUpgradeChannel = "NodeImage"
	// NodeOSUpgradeChannelNone - No attempt to update your machines OS will be made either by OS or by rolling VHDs. This means
	// you are responsible for your security updates
	NodeOSUpgradeChannelNone NodeOSUpgradeChannel = "None"
	// NodeOSUpgradeChannelSecurityPatch - AKS downloads and updates the nodes with tested security updates. These updates honor
	// the maintenance window settings and produce a new VHD that is used on new nodes. On some occasions it's not possible to
	// apply the updates in place, in such cases the existing nodes will also be re-imaged to the newly produced VHD in order
	// to apply the changes. This option incurs an extra cost of hosting the new Security Patch VHDs in your resource group for
	// just in time consumption.
	NodeOSUpgradeChannelSecurityPatch NodeOSUpgradeChannel = "SecurityPatch"
	// NodeOSUpgradeChannelUnmanaged - OS updates will be applied automatically through the OS built-in patching infrastructure.
	// Newly scaled in machines will be unpatched initially and will be patched at some point by the OS's infrastructure. Behavior
	// of this option depends on the OS in question. Ubuntu and Mariner apply security patches through unattended upgrade roughly
	// once a day around 06:00 UTC. Windows does not apply security patches automatically and so for them this option is equivalent
	// to None till further notice
	NodeOSUpgradeChannelUnmanaged NodeOSUpgradeChannel = "Unmanaged"
)

func PossibleNodeOSUpgradeChannelValues 

func PossibleNodeOSUpgradeChannelValues() []NodeOSUpgradeChannel

PossibleNodeOSUpgradeChannelValues returns the possible values for the NodeOSUpgradeChannel const type.

type OSDiskType 

type OSDiskType string

OSDiskType - The default is 'Ephemeral' if the VM supports it and has a cache disk larger than the requested OSDiskSizeGB. Otherwise, defaults to 'Managed'. May not be changed after creation. For more information see Ephemeral OS [https://docs.microsoft.com/azure/aks/cluster-configuration#ephemeral-os]. 

const (
	// OSDiskTypeEphemeral - Ephemeral OS disks are stored only on the host machine, just like a temporary disk. This provides
	// lower read/write latency, along with faster node scaling and cluster upgrades.
	OSDiskTypeEphemeral OSDiskType = "Ephemeral"
	// OSDiskTypeManaged - Azure replicates the operating system disk for a virtual machine to Azure storage to avoid data loss
	// should the VM need to be relocated to another host. Since containers aren't designed to have local state persisted, this
	// behavior offers limited value while providing some drawbacks, including slower node provisioning and higher read/write
	// latency.
	OSDiskTypeManaged OSDiskType = "Managed"
)

func PossibleOSDiskTypeValues 

func PossibleOSDiskTypeValues() []OSDiskType

PossibleOSDiskTypeValues returns the possible values for the OSDiskType const type.

type OSSKU 

type OSSKU string

OSSKU - Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019 when Kubernetes = 1.25 if OSType is Windows. 

const (
	// OSSKUAzureLinux - Use AzureLinux as the OS for node images. Azure Linux is a container-optimized Linux distro built by
	// Microsoft, visit https://aka.ms/azurelinux for more information.
	OSSKUAzureLinux OSSKU = "AzureLinux"
	// OSSKUCBLMariner - Deprecated OSSKU. Microsoft recommends that new deployments choose 'AzureLinux' instead.
	OSSKUCBLMariner OSSKU = "CBLMariner"
	// OSSKUUbuntu - Use Ubuntu as the OS for node images.
	OSSKUUbuntu OSSKU = "Ubuntu"
	// OSSKUWindows2019 - Use Windows2019 as the OS for node images. Unsupported for system node pools. Windows2019 only supports
	// Windows2019 containers; it cannot run Windows2022 containers and vice versa.
	OSSKUWindows2019 OSSKU = "Windows2019"
	// OSSKUWindows2022 - Use Windows2022 as the OS for node images. Unsupported for system node pools. Windows2022 only supports
	// Windows2022 containers; it cannot run Windows2019 containers and vice versa.
	OSSKUWindows2022 OSSKU = "Windows2022"
)

func PossibleOSSKUValues 

func PossibleOSSKUValues() []OSSKU

PossibleOSSKUValues returns the possible values for the OSSKU const type.

type OSType 

type OSType string

OSType - The operating system type. The default is Linux. 

const (
	// OSTypeLinux - Use Linux.
	OSTypeLinux OSType = "Linux"
	// OSTypeWindows - Use Windows.
	OSTypeWindows OSType = "Windows"
)

func PossibleOSTypeValues 

func PossibleOSTypeValues() []OSType

PossibleOSTypeValues returns the possible values for the OSType const type.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; The list of operations
	Value []*OperationValue
}

OperationListResult - The List Operation response.

func (OperationListResult) MarshalJSON 

func (o OperationListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

func (o *OperationListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationValue 

type OperationValue struct {
	// Describes the properties of a Operation Value Display.
	Display *OperationValueDisplay

	// READ-ONLY; The name of the operation.
	Name *string

	// READ-ONLY; The origin of the operation.
	Origin *string
}

OperationValue - Describes the properties of a Operation value.

func (OperationValue) MarshalJSON 

func (o OperationValue) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationValue.

func (*OperationValue) UnmarshalJSON 

func (o *OperationValue) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationValue.

type OperationValueDisplay 

type OperationValueDisplay struct {
	// READ-ONLY; The description of the operation.
	Description *string

	// READ-ONLY; The display name of the operation.
	Operation *string

	// READ-ONLY; The resource provider for the operation.
	Provider *string

	// READ-ONLY; The display name of the resource the operation applies to.
	Resource *string
}

OperationValueDisplay - Describes the properties of a Operation Value Display.

func (OperationValueDisplay) MarshalJSON 

func (o OperationValueDisplay) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationValueDisplay.

func (*OperationValueDisplay) UnmarshalJSON 

func (o *OperationValueDisplay) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationValueDisplay.

type OperationsClient 

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Gets a list of operations.

Generated from API version 2024-09-01

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/Operation_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewOperationsClient().NewListPager(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.OperationListResult = armcontainerservice.OperationListResult{
	// 	Value: []*armcontainerservice.OperationValue{
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/locations/operations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the status of an asynchronous operation"),
	// 				Operation: to.Ptr("Get Operation"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Operation"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/locations/orchestrators/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Lists the supported orchestrators"),
	// 				Operation: to.Ptr("List Orchestrators"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Orchestrator"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/operations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Lists operations available on Microsoft.ContainerService resource provider"),
	// 				Operation: to.Ptr("List Available Container Service Operations"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Available Container Service Operations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/register/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Registers Subscription with Microsoft.ContainerService resource provider"),
	// 				Operation: to.Ptr("Register Subscription for Container Service"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Container Service Register Subscription"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/unregister/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Unregisters Subscription with Microsoft.ContainerService resource provider"),
	// 				Operation: to.Ptr("Unregister Subscription for Container Service"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Container Service Unregister Subscription"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/locations/operationresults/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the status of an asynchronous operation result"),
	// 				Operation: to.Ptr("Get Operation Result"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("OperationResult"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/containerServices/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a container service"),
	// 				Operation: to.Ptr("Get Container Service"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Container Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/containerServices/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new container service or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update Container Service"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Container Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/containerServices/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes a container service"),
	// 				Operation: to.Ptr("Delete Container Service"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Container Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a managed cluster"),
	// 				Operation: to.Ptr("Get Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new managed cluster or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes a managed cluster"),
	// 				Operation: to.Ptr("Delete Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/start/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Starts a managed cluster"),
	// 				Operation: to.Ptr("Start Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/stop/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Stops a managed cluster"),
	// 				Operation: to.Ptr("Stop Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/maintenanceConfigurations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets a maintenance configuration"),
	// 				Operation: to.Ptr("Get a maintenance configuration"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Maintenance Configurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/maintenanceConfigurations/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new MaintenanceConfiguration or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update maintenance configuratio"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Maintenance Configurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/maintenanceConfigurations/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes a maintenance configuration"),
	// 				Operation: to.Ptr("Delete Maintenance Configuration"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Maintenance Configurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets an agent pool"),
	// 				Operation: to.Ptr("Get Agent Pool"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Agent Pools"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new agent pool or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update Agent Pool"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Agent Pools"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes an agent pool"),
	// 				Operation: to.Ptr("Delete Agent Pool"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Agent Pools"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/upgradeProfiles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the upgrade profile of the Agent Pool"),
	// 				Operation: to.Ptr("Get Agent Pool UpgradeProfile"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Agent Pools"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/agentPools/upgradeNodeImageVersion/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Upgrade the node image version of agent pool"),
	// 				Operation: to.Ptr("Upgrade agent pool node image version"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Agent Pools"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/availableAgentPoolVersions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the available agent pool versions of the cluster"),
	// 				Operation: to.Ptr("Get Available Agent Pool Versions"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/accessProfiles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a managed cluster access profile by role name"),
	// 				Operation: to.Ptr("Get Managed Cluster AccessProfile"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/accessProfiles/listCredential/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a managed cluster access profile by role name using list credential"),
	// 				Operation: to.Ptr("Get Managed Cluster AccessProfile by List Credential"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/upgradeProfiles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the upgrade profile of the cluster"),
	// 				Operation: to.Ptr("Get UpgradeProfile"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("UpgradeProfile"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/listClusterAdminCredential/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("List the clusterAdmin credential of a managed cluster"),
	// 				Operation: to.Ptr("List clusterAdmin credential"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/listClusterUserCredential/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("List the clusterUser credential of a managed cluster"),
	// 				Operation: to.Ptr("List clusterUser credential"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/listClusterMonitoringUserCredential/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("List the clusterMonitoringUser credential of a managed cluster"),
	// 				Operation: to.Ptr("List clusterMonitoringUser credential"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resetServicePrincipalProfile/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reset the service principal profile of a managed cluster"),
	// 				Operation: to.Ptr("Reset service principal profile"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resolvePrivateLinkServiceId/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Resolve the private link service id of a managed cluster"),
	// 				Operation: to.Ptr("Resolve private link service id"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resetAADProfile/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reset the AAD profile of a managed cluster"),
	// 				Operation: to.Ptr("Reset AAD profile"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rotateClusterCertificates/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Rotate certificates of a managed cluster"),
	// 				Operation: to.Ptr("Rotate certificates of the cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/runCommand/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Run user issued command against managed kubernetes server."),
	// 				Operation: to.Ptr("RunCommand"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/commandResults/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Retrieve result from previous issued command."),
	// 				Operation: to.Ptr("CommandResult"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/providers/Microsoft.Insights/diagnosticSettings/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get the diagnostic setting for a managed cluster resource"),
	// 				Operation: to.Ptr("Read Diagnostic Setting"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/providers/Microsoft.Insights/diagnosticSettings/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates or updates the diagnostic setting for a managed cluster resource"),
	// 				Operation: to.Ptr("Write Diagnostic Setting"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Clusters"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/detectors/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get Managed Cluster Detector"),
	// 				Operation: to.Ptr("Get Managed Cluster Detector"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Managed Cluster Detector"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/diagnosticsState/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the diagnostics state of the cluster"),
	// 				Operation: to.Ptr("Get Diagnostics State"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Diagnostics State"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/privateEndpointConnectionsApproval/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Determines if user is allowed to approve a private endpoint connection"),
	// 				Operation: to.Ptr("Approve Private Endpoint Connections"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Approve Private Endpoint Connections"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/privateEndpointConnections/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get private endpoint connection"),
	// 				Operation: to.Ptr("Get private endpoint connection"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Private Endpoint Connections"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/privateEndpointConnections/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Approve or Reject a private endpoint connection"),
	// 				Operation: to.Ptr("Update private endpoint connection"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Private Endpoint Connections"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/privateEndpointConnections/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Delete private endpoint connection"),
	// 				Operation: to.Ptr("Delete private endpoint connection"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Private Endpoint Connections"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensionaddons/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets an extension addon"),
	// 				Operation: to.Ptr("Get an extension addon"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("ExtensionAddons"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensionaddons/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new extension addon or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update extension addon"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("ExtensionAddons"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensionaddons/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes an extension addon"),
	// 				Operation: to.Ptr("Delete an extension addon"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("ExtensionAddons"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/snapshots/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a snapshot"),
	// 				Operation: to.Ptr("Get Snapshot"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Snapshots"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/snapshots/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new snapshot"),
	// 				Operation: to.Ptr("Create Snapshot"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Snapshots"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/snapshots/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes a snapshot"),
	// 				Operation: to.Ptr("Delete Snapshot"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Snapshots"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/eventGridFilters/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get eventgrid filter"),
	// 				Operation: to.Ptr("Get eventgrid filter"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("EventGridFilters"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/eventGridFilters/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Create or Update eventgrid filter"),
	// 				Operation: to.Ptr("Create or Update eventgrid filter"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("EventGridFilters"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/eventGridFilters/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Delete an eventgrid filter"),
	// 				Operation: to.Ptr("Delete an eventgrid filter"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("EventGridFilters"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/initializerconfigurations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads initializerconfigurations"),
	// 				Operation: to.Ptr("Gets/List initializerconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Initializerconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/initializerconfigurations/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes initializerconfigurations"),
	// 				Operation: to.Ptr("Creates/Updates initializerconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Initializerconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/initializerconfigurations/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes/DeletesCollection initializerconfigurations resource"),
	// 				Operation: to.Ptr("Initializerconfigurations"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Initializerconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/mutatingwebhookconfigurations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads mutatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Gets/List mutatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Mutatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/mutatingwebhookconfigurations/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes mutatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Creates/Updates mutatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Mutatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/mutatingwebhookconfigurations/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes mutatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection mutatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Mutatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/validatingwebhookconfigurations/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads validatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Gets/List validatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Validatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/validatingwebhookconfigurations/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes validatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Creates/Updates validatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Validatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/admissionregistration.k8s.io/validatingwebhookconfigurations/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes validatingwebhookconfigurations"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection validatingwebhookconfigurations resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Validatingwebhookconfigurations"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiextensions.k8s.io/customresourcedefinitions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads customresourcedefinitions"),
	// 				Operation: to.Ptr("Gets/List customresourcedefinitions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Customresourcedefinitions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiextensions.k8s.io/customresourcedefinitions/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes customresourcedefinitions"),
	// 				Operation: to.Ptr("Creates/Updates customresourcedefinitions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Customresourcedefinitions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiextensions.k8s.io/customresourcedefinitions/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes customresourcedefinitions"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection customresourcedefinitions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Customresourcedefinitions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiregistration.k8s.io/apiservices/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservices"),
	// 				Operation: to.Ptr("Gets/List apiservices resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiservices"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiregistration.k8s.io/apiservices/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes apiservices"),
	// 				Operation: to.Ptr("Creates/Updates apiservices resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiservices"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apiregistration.k8s.io/apiservices/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes apiservices"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection apiservices resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiservices"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/controllerrevisions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads controllerrevisions"),
	// 				Operation: to.Ptr("Gets/List controllerrevisions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Controllerrevisions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/controllerrevisions/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes controllerrevisions"),
	// 				Operation: to.Ptr("Creates/Updates controllerrevisions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Controllerrevisions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/controllerrevisions/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes controllerrevisions"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection controllerrevisions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Controllerrevisions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/daemonsets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads daemonsets"),
	// 				Operation: to.Ptr("Gets/List daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/daemonsets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes daemonsets"),
	// 				Operation: to.Ptr("Creates/Updates daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/daemonsets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes daemonsets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/deployments/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads deployments"),
	// 				Operation: to.Ptr("Gets/List deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/deployments/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes deployments"),
	// 				Operation: to.Ptr("Creates/Updates deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/deployments/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes deployments"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/replicasets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads replicasets"),
	// 				Operation: to.Ptr("Gets/List replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/replicasets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes replicasets"),
	// 				Operation: to.Ptr("Creates/Updates replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/replicasets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes replicasets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/statefulsets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads statefulsets"),
	// 				Operation: to.Ptr("Gets/List statefulsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Statefulsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/statefulsets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes statefulsets"),
	// 				Operation: to.Ptr("Creates/Updates statefulsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Statefulsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apps/statefulsets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes statefulsets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection statefulsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Statefulsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authentication.k8s.io/tokenreviews/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes tokenreviews"),
	// 				Operation: to.Ptr("Creates/Updates tokenreviews resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Tokenreviews"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authorization.k8s.io/localsubjectaccessreviews/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes localsubjectaccessreviews"),
	// 				Operation: to.Ptr("Creates/Updates localsubjectaccessreviews resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Localsubjectaccessreviews"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authorization.k8s.io/selfsubjectaccessreviews/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes selfsubjectaccessreviews"),
	// 				Operation: to.Ptr("Creates/Updates selfsubjectaccessreviews resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Selfsubjectaccessreviews"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authorization.k8s.io/selfsubjectrulesreviews/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes selfsubjectrulesreviews"),
	// 				Operation: to.Ptr("Creates/Updates selfsubjectrulesreviews resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Selfsubjectrulesreviews"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authorization.k8s.io/subjectaccessreviews/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes subjectaccessreviews"),
	// 				Operation: to.Ptr("Creates/Updates subjectaccessreviews resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Subjectaccessreviews"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/autoscaling/horizontalpodautoscalers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads horizontalpodautoscalers"),
	// 				Operation: to.Ptr("Gets/List horizontalpodautoscalers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Horizontalpodautoscalers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/autoscaling/horizontalpodautoscalers/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes horizontalpodautoscalers"),
	// 				Operation: to.Ptr("Creates/Updates horizontalpodautoscalers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Horizontalpodautoscalers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/autoscaling/horizontalpodautoscalers/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes horizontalpodautoscalers"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection horizontalpodautoscalers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Horizontalpodautoscalers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/cronjobs/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads cronjobs"),
	// 				Operation: to.Ptr("Gets/List cronjobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Cronjobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/cronjobs/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes cronjobs"),
	// 				Operation: to.Ptr("Creates/Updates cronjobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Cronjobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/cronjobs/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes cronjobs"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection cronjobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Cronjobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/jobs/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads jobs"),
	// 				Operation: to.Ptr("Gets/List jobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Jobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/jobs/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes jobs"),
	// 				Operation: to.Ptr("Creates/Updates jobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Jobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/batch/jobs/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes jobs"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection jobs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Jobs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/certificates.k8s.io/certificatesigningrequests/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads certificatesigningrequests"),
	// 				Operation: to.Ptr("Gets/List certificatesigningrequests resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Certificatesigningrequests"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/certificates.k8s.io/certificatesigningrequests/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes certificatesigningrequests"),
	// 				Operation: to.Ptr("Creates/Updates certificatesigningrequests resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Certificatesigningrequests"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/certificates.k8s.io/certificatesigningrequests/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes certificatesigningrequests"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection certificatesigningrequests resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Certificatesigningrequests"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/coordination.k8s.io/leases/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads leases"),
	// 				Operation: to.Ptr("Gets/List leases resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Leases"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/coordination.k8s.io/leases/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes leases"),
	// 				Operation: to.Ptr("Creates/Updates leases resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Leases"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/coordination.k8s.io/leases/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes leases"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection leases resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Leases"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/bindings/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes bindings"),
	// 				Operation: to.Ptr("Creates/Updates bindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Bindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/componentstatuses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads componentstatuses"),
	// 				Operation: to.Ptr("Gets/List componentstatuses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Componentstatuses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/componentstatuses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes componentstatuses"),
	// 				Operation: to.Ptr("Creates/Updates componentstatuses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Componentstatuses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/componentstatuses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes componentstatuses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection componentstatuses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Componentstatuses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/configmaps/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads configmaps"),
	// 				Operation: to.Ptr("Gets/List configmaps resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Configmaps"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/configmaps/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes configmaps"),
	// 				Operation: to.Ptr("Creates/Updates configmaps resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Configmaps"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/configmaps/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes configmaps"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection configmaps resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Configmaps"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/endpoints/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads endpoints"),
	// 				Operation: to.Ptr("Gets/List endpoints resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Endpoints"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/endpoints/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes endpoints"),
	// 				Operation: to.Ptr("Creates/Updates endpoints resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Endpoints"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/endpoints/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes endpoints"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection endpoints resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Endpoints"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads events"),
	// 				Operation: to.Ptr("Gets/List events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes events"),
	// 				Operation: to.Ptr("Creates/Updates events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes events"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/limitranges/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads limitranges"),
	// 				Operation: to.Ptr("Gets/List limitranges resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Limitranges"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/limitranges/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes limitranges"),
	// 				Operation: to.Ptr("Creates/Updates limitranges resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Limitranges"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/limitranges/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes limitranges"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection limitranges resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Limitranges"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/namespaces/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads namespaces"),
	// 				Operation: to.Ptr("Gets/List namespaces resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Namespaces"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/namespaces/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes namespaces"),
	// 				Operation: to.Ptr("Creates/Updates namespaces resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Namespaces"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/namespaces/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes namespaces"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection namespaces resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Namespaces"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/nodes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads nodes"),
	// 				Operation: to.Ptr("Gets/List nodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Nodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/nodes/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes nodes"),
	// 				Operation: to.Ptr("Creates/Updates nodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Nodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/nodes/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes nodes"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection nodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Nodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumeclaims/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads persistentvolumeclaims"),
	// 				Operation: to.Ptr("Gets/List persistentvolumeclaims resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumeclaims"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumeclaims/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes persistentvolumeclaims"),
	// 				Operation: to.Ptr("Creates/Updates persistentvolumeclaims resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumeclaims"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumeclaims/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes persistentvolumeclaims"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection persistentvolumeclaims resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumeclaims"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads persistentvolumes"),
	// 				Operation: to.Ptr("Gets/List persistentvolumes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumes/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes persistentvolumes"),
	// 				Operation: to.Ptr("Creates/Updates persistentvolumes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/persistentvolumes/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes persistentvolumes"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection persistentvolumes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Persistentvolumes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/pods/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads pods"),
	// 				Operation: to.Ptr("Gets/List pods resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Pods"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/pods/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes pods"),
	// 				Operation: to.Ptr("Creates/Updates pods resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Pods"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/pods/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes pods"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection pods resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Pods"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/pods/exec/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Exec into pods resource"),
	// 				Operation: to.Ptr("Exec into pods resource "),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Pods"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/podtemplates/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads podtemplates"),
	// 				Operation: to.Ptr("Gets/List podtemplates resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podtemplates"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/podtemplates/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes podtemplates"),
	// 				Operation: to.Ptr("Creates/Updates podtemplates resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podtemplates"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/podtemplates/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes podtemplates"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection podtemplates resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podtemplates"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/replicationcontrollers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads replicationcontrollers"),
	// 				Operation: to.Ptr("Gets/List replicationcontrollers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicationcontrollers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/replicationcontrollers/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes replicationcontrollers"),
	// 				Operation: to.Ptr("Creates/Updates replicationcontrollers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicationcontrollers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/replicationcontrollers/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes replicationcontrollers"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection replicationcontrollers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicationcontrollers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resourcequotas/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads resourcequotas"),
	// 				Operation: to.Ptr("Gets/List resourcequotas resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Resourcequotas"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resourcequotas/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes resourcequotas"),
	// 				Operation: to.Ptr("Creates/Updates resourcequotas resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Resourcequotas"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resourcequotas/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes resourcequotas"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection resourcequotas resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Resourcequotas"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/secrets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads secrets"),
	// 				Operation: to.Ptr("Gets/List secrets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Secrets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/secrets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes secrets"),
	// 				Operation: to.Ptr("Creates/Updates secrets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Secrets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/secrets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes secrets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection secrets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Secrets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/serviceaccounts/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads serviceaccounts"),
	// 				Operation: to.Ptr("Gets/List serviceaccounts resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Serviceaccounts"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/serviceaccounts/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes serviceaccounts"),
	// 				Operation: to.Ptr("Creates/Updates serviceaccounts resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Serviceaccounts"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/serviceaccounts/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes serviceaccounts"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection serviceaccounts resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Serviceaccounts"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/services/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads services"),
	// 				Operation: to.Ptr("Gets/List services resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/services/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes services"),
	// 				Operation: to.Ptr("Creates/Updates services resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/services/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes services"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection services resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Services"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events.k8s.io/events/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads events"),
	// 				Operation: to.Ptr("Gets/List events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events.k8s.io/events/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes events"),
	// 				Operation: to.Ptr("Creates/Updates events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/events.k8s.io/events/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes events"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection events resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/daemonsets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads daemonsets"),
	// 				Operation: to.Ptr("Gets/List daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/daemonsets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes daemonsets"),
	// 				Operation: to.Ptr("Creates/Updates daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/daemonsets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes daemonsets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection daemonsets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Daemonsets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/deployments/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads deployments"),
	// 				Operation: to.Ptr("Gets/List deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/deployments/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes deployments"),
	// 				Operation: to.Ptr("Creates/Updates deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/deployments/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes deployments"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection deployments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Deployments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/ingresses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ingresses"),
	// 				Operation: to.Ptr("Gets/List ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/ingresses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes ingresses"),
	// 				Operation: to.Ptr("Creates/Updates ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/ingresses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes ingresses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/networkpolicies/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads networkpolicies"),
	// 				Operation: to.Ptr("Gets/List networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/networkpolicies/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes networkpolicies"),
	// 				Operation: to.Ptr("Creates/Updates networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/networkpolicies/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes networkpolicies"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/podsecuritypolicies/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads podsecuritypolicies"),
	// 				Operation: to.Ptr("Gets/List podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/podsecuritypolicies/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes podsecuritypolicies"),
	// 				Operation: to.Ptr("Creates/Updates podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/podsecuritypolicies/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes podsecuritypolicies"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/replicasets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads replicasets"),
	// 				Operation: to.Ptr("Gets/List replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/replicasets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes replicasets"),
	// 				Operation: to.Ptr("Creates/Updates replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/extensions/replicasets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes replicasets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection replicasets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Replicasets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/metrics.k8s.io/pods/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads pods"),
	// 				Operation: to.Ptr("Gets/List pods resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Pods"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/metrics.k8s.io/nodes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads nodes"),
	// 				Operation: to.Ptr("Gets/List nodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Nodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/networkpolicies/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads networkpolicies"),
	// 				Operation: to.Ptr("Gets/List networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/networkpolicies/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes networkpolicies"),
	// 				Operation: to.Ptr("Creates/Updates networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/networkpolicies/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes networkpolicies"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection networkpolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networkpolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/ingresses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ingresses"),
	// 				Operation: to.Ptr("Gets/List ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/ingresses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes ingresses"),
	// 				Operation: to.Ptr("Creates/Updates ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/networking.k8s.io/ingresses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes ingresses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection ingresses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ingresses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/node.k8s.io/runtimeclasses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads runtimeclasses"),
	// 				Operation: to.Ptr("Gets/List runtimeclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Runtimeclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/node.k8s.io/runtimeclasses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes runtimeclasses"),
	// 				Operation: to.Ptr("Creates/Updates runtimeclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Runtimeclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/node.k8s.io/runtimeclasses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes runtimeclasses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection runtimeclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Runtimeclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/api/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads api"),
	// 				Operation: to.Ptr("Gets/List api resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Api"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/api/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads api/v1"),
	// 				Operation: to.Ptr("Gets/List api/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Api/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apis"),
	// 				Operation: to.Ptr("Gets/List apis resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apis"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/admissionregistration.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads admissionregistration.k8s.io"),
	// 				Operation: to.Ptr("Gets/List admissionregistration.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Admissionregistration.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/admissionregistration.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads admissionregistration.k8s.io/v1"),
	// 				Operation: to.Ptr("Gets/List admissionregistration.k8s.io/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Admissionregistration.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/admissionregistration.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads admissionregistration.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List admissionregistration.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Admissionregistration.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiextensions.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiextensions.k8s.io"),
	// 				Operation: to.Ptr("Gets/List apiextensions.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiextensions.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiextensions.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiextensions.k8s.io/v1"),
	// 				Operation: to.Ptr("Gets/List apiextensions.k8s.io/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiextensions.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiextensions.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiextensions.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List apiextensions.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiextensions.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiregistration.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiregistration.k8s.io"),
	// 				Operation: to.Ptr("Gets/List apiregistration.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiregistration.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiregistration.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiregistration.k8s.io/v1"),
	// 				Operation: to.Ptr("Gets/List apiregistration.k8s.io/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiregistration.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apiregistration.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiregistration.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List apiregistration.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apiregistration.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apps/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apps"),
	// 				Operation: to.Ptr("Gets/List apps resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apps"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apps/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apps/v1"),
	// 				Operation: to.Ptr("Gets/List apps/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apps/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apps/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apps/v1beta1"),
	// 				Operation: to.Ptr("Gets/List apps/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apps/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/apps/v1beta2/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apps/v1beta2"),
	// 				Operation: to.Ptr("Gets/List apps/v1beta2 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Apps/V1beta2"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authentication.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authentication.k8s.io"),
	// 				Operation: to.Ptr("Gets/List authentication.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authentication.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authentication.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authentication.k8s.io/v1"),
	// 				Operation: to.Ptr("Gets/List authentication.k8s.io/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authentication.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authentication.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authentication.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List authentication.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authentication.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authorization.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authorization.k8s.io"),
	// 				Operation: to.Ptr("Gets/List authorization.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authorization.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authorization.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authorization.k8s.io/v1"),
	// 				Operation: to.Ptr("Gets/List authorization.k8s.io/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authorization.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/authorization.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads authorization.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List authorization.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Authorization.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/autoscaling/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoscaling"),
	// 				Operation: to.Ptr("Gets/List autoscaling resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Autoscaling"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/autoscaling/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoscaling/v1"),
	// 				Operation: to.Ptr("Gets/List autoscaling/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Autoscaling/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/autoscaling/v2beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoscaling/v2beta1"),
	// 				Operation: to.Ptr("Gets/List autoscaling/v2beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Autoscaling/V2beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/autoscaling/v2beta2/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoscaling/v2beta2"),
	// 				Operation: to.Ptr("Gets/List autoscaling/v2beta2 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Autoscaling/V2beta2"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/batch/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads batch"),
	// 				Operation: to.Ptr("Gets/List batch resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Batch"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/batch/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads batch/v1"),
	// 				Operation: to.Ptr("Gets/List batch/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Batch/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/batch/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads batch/v1beta1"),
	// 				Operation: to.Ptr("Gets/List batch/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Batch/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/certificates.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads certificates.k8s.io"),
	// 				Operation: to.Ptr("Gets/List certificates.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Certificates.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/certificates.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads certificates.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List certificates.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Certificates.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/coordination.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads coordination.k8s.io"),
	// 				Operation: to.Ptr("Gets/List coordination.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Coordination.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/coordination.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads coordination/v1"),
	// 				Operation: to.Ptr("Gets/List coordination/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Coordination.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/coordination.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads coordination.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List coordination.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Coordination.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/events.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads events.k8s.io"),
	// 				Operation: to.Ptr("Gets/List events.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/events.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads events.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List events.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Events.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/extensions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads extensions"),
	// 				Operation: to.Ptr("Gets/List extensions resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Extensions"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/extensions/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads extensions/v1beta1"),
	// 				Operation: to.Ptr("Gets/List extensions/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Extensions/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/metrics.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads metrics.k8s.io"),
	// 				Operation: to.Ptr("Gets/List metrics.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Metrics.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/metrics.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads metrics.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List metrics.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Metrics.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/networking.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads networking.k8s.io"),
	// 				Operation: to.Ptr("Gets/List networking.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networking.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/networking.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads networking/v1"),
	// 				Operation: to.Ptr("Gets/List networking/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networking.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/networking.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads networking.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List networking.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Networking.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/node.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads node.k8s.io"),
	// 				Operation: to.Ptr("Gets/List node.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Node.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/node.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads node.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List node.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Node.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/policy/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads policy"),
	// 				Operation: to.Ptr("Gets/List policy resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Policy"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/policy/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads policy/v1beta1"),
	// 				Operation: to.Ptr("Gets/List policy/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Policy/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/rbac.authorization.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads rbac.authorization.k8s.io"),
	// 				Operation: to.Ptr("Gets/List rbac.authorization.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rbac.Authorization.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/rbac.authorization.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads rbac.authorization/v1"),
	// 				Operation: to.Ptr("Gets/List rbac.authorization/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rbac.Authorization.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/rbac.authorization.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads rbac.authorization.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List rbac.authorization.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rbac.Authorization.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/scheduling.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads scheduling.k8s.io"),
	// 				Operation: to.Ptr("Gets/List scheduling.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Scheduling.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/scheduling.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads scheduling/v1"),
	// 				Operation: to.Ptr("Gets/List scheduling/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Scheduling.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/scheduling.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads scheduling.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List scheduling.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Scheduling.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/storage.k8s.io/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads storage.k8s.io"),
	// 				Operation: to.Ptr("Gets/List storage.k8s.io resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storage.K8s.Io"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/storage.k8s.io/v1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads storage/v1"),
	// 				Operation: to.Ptr("Gets/List storage/v1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storage.K8s.Io/V1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/apis/storage.k8s.io/v1beta1/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads storage.k8s.io/v1beta1"),
	// 				Operation: to.Ptr("Gets/List storage.k8s.io/v1beta1 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storage.K8s.Io/V1beta1"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads healthz"),
	// 				Operation: to.Ptr("Gets/List healthz resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/autoregister-completion/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoregister-completion"),
	// 				Operation: to.Ptr("Gets/List autoregister-completion resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Autoregister-Completion"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/etcd/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads etcd"),
	// 				Operation: to.Ptr("Gets/List etcd resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Etcd"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/log/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads log"),
	// 				Operation: to.Ptr("Gets/List log resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Log"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/ping/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ping"),
	// 				Operation: to.Ptr("Gets/List ping resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Ping"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/apiservice-openapi-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-openapi-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-openapi-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Apiservice-Openapi-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/apiservice-registration-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-registration-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-registration-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Apiservice-Registration-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/apiservice-status-available-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-status-available-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-status-available-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Apiservice-Status-Available-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/bootstrap-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-controller"),
	// 				Operation: to.Ptr("Gets/List bootstrap-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Bootstrap-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/ca-registration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ca-registration"),
	// 				Operation: to.Ptr("Gets/List ca-registration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Ca-Registration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/crd-informer-synced/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads crd-informer-synced"),
	// 				Operation: to.Ptr("Gets/List crd-informer-synced resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Crd-Informer-Synced"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/generic-apiserver-start-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads generic-apiserver-start-informers"),
	// 				Operation: to.Ptr("Gets/List generic-apiserver-start-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Generic-Apiserver-Start-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/kube-apiserver-autoregistration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads kube-apiserver-autoregistration"),
	// 				Operation: to.Ptr("Gets/List kube-apiserver-autoregistration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Kube-Apiserver-Autoregistration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/rbac/bootstrap-roles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-roles"),
	// 				Operation: to.Ptr("Gets/List bootstrap-roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Bootstrap-Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/scheduling/bootstrap-system-priority-classes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-system-priority-classes"),
	// 				Operation: to.Ptr("Gets/List bootstrap-system-priority-classes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Bootstrap-System-Priority-Classes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/start-apiextensions-controllers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-controllers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-controllers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Start-Apiextensions-Controllers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/start-apiextensions-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-informers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Start-Apiextensions-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/start-kube-aggregator-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-aggregator-informers"),
	// 				Operation: to.Ptr("Gets/List start-kube-aggregator-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Start-Kube-Aggregator-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/healthz/poststarthook/start-kube-apiserver-admission-initializer/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-apiserver-admission-initializer"),
	// 				Operation: to.Ptr("Gets/List start-kube-apiserver-admission-initializer resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Healthz/Poststarthook/Start-Kube-Apiserver-Admission-Initializer"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads livez"),
	// 				Operation: to.Ptr("Gets/List livez resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/autoregister-completion/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoregister-completion"),
	// 				Operation: to.Ptr("Gets/List autoregister-completion resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Autoregister-Completion"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/etcd/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads etcd"),
	// 				Operation: to.Ptr("Gets/List etcd resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Etcd"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/log/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads log"),
	// 				Operation: to.Ptr("Gets/List log resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Log"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/ping/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ping"),
	// 				Operation: to.Ptr("Gets/List ping resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Ping"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/apiservice-openapi-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-openapi-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-openapi-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Apiservice-Openapi-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/apiservice-registration-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-registration-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-registration-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Apiservice-Registration-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/apiservice-status-available-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-status-available-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-status-available-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Apiservice-Status-Available-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/bootstrap-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-controller"),
	// 				Operation: to.Ptr("Gets/List bootstrap-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Bootstrap-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/ca-registration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ca-registration"),
	// 				Operation: to.Ptr("Gets/List ca-registration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Ca-Registration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/crd-informer-synced/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads crd-informer-synced"),
	// 				Operation: to.Ptr("Gets/List crd-informer-synced resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Crd-Informer-Synced"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/generic-apiserver-start-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads generic-apiserver-start-informers"),
	// 				Operation: to.Ptr("Gets/List generic-apiserver-start-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Generic-Apiserver-Start-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/kube-apiserver-autoregistration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads kube-apiserver-autoregistration"),
	// 				Operation: to.Ptr("Gets/List kube-apiserver-autoregistration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Kube-Apiserver-Autoregistration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/rbac/bootstrap-roles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-roles"),
	// 				Operation: to.Ptr("Gets/List bootstrap-roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Bootstrap-Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/scheduling/bootstrap-system-priority-classes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-system-priority-classes"),
	// 				Operation: to.Ptr("Gets/List bootstrap-system-priority-classes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Bootstrap-System-Priority-Classes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/start-apiextensions-controllers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-controllers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-controllers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Start-Apiextensions-Controllers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/start-apiextensions-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-informers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Start-Apiextensions-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/start-kube-aggregator-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-aggregator-informers"),
	// 				Operation: to.Ptr("Gets/List start-kube-aggregator-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Start-Kube-Aggregator-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/livez/poststarthook/start-kube-apiserver-admission-initializer/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-apiserver-admission-initializer"),
	// 				Operation: to.Ptr("Gets/List start-kube-apiserver-admission-initializer resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Livez/Poststarthook/Start-Kube-Apiserver-Admission-Initializer"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/logs/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads logs"),
	// 				Operation: to.Ptr("Gets/List logs resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Logs"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/metrics/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads metrics"),
	// 				Operation: to.Ptr("Gets/List metrics resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Metrics"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/openapi/v2/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads v2"),
	// 				Operation: to.Ptr("Gets/List v2 resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Openapi/V2"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads readyz"),
	// 				Operation: to.Ptr("Gets/List readyz resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/autoregister-completion/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads autoregister-completion"),
	// 				Operation: to.Ptr("Gets/List autoregister-completion resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Autoregister-Completion"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/etcd/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads etcd"),
	// 				Operation: to.Ptr("Gets/List etcd resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Etcd"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/log/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads log"),
	// 				Operation: to.Ptr("Gets/List log resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Log"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/ping/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ping"),
	// 				Operation: to.Ptr("Gets/List ping resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Ping"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/apiservice-openapi-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-openapi-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-openapi-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Apiservice-Openapi-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/apiservice-registration-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-registration-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-registration-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Apiservice-Registration-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/apiservice-status-available-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads apiservice-status-available-controller"),
	// 				Operation: to.Ptr("Gets/List apiservice-status-available-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Apiservice-Status-Available-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/bootstrap-controller/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-controller"),
	// 				Operation: to.Ptr("Gets/List bootstrap-controller resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Bootstrap-Controller"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/ca-registration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ca-registration"),
	// 				Operation: to.Ptr("Gets/List ca-registration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Ca-Registration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/crd-informer-synced/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads crd-informer-synced"),
	// 				Operation: to.Ptr("Gets/List crd-informer-synced resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Crd-Informer-Synced"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/generic-apiserver-start-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads generic-apiserver-start-informers"),
	// 				Operation: to.Ptr("Gets/List generic-apiserver-start-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Generic-Apiserver-Start-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/kube-apiserver-autoregistration/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads kube-apiserver-autoregistration"),
	// 				Operation: to.Ptr("Gets/List kube-apiserver-autoregistration resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Kube-Apiserver-Autoregistration"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/rbac/bootstrap-roles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-roles"),
	// 				Operation: to.Ptr("Gets/List bootstrap-roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Bootstrap-Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/scheduling/bootstrap-system-priority-classes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads bootstrap-system-priority-classes"),
	// 				Operation: to.Ptr("Gets/List bootstrap-system-priority-classes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Bootstrap-System-Priority-Classes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/start-apiextensions-controllers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-controllers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-controllers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Start-Apiextensions-Controllers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/start-apiextensions-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-apiextensions-informers"),
	// 				Operation: to.Ptr("Gets/List start-apiextensions-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Start-Apiextensions-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/start-kube-aggregator-informers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-aggregator-informers"),
	// 				Operation: to.Ptr("Gets/List start-kube-aggregator-informers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Start-Kube-Aggregator-Informers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/poststarthook/start-kube-apiserver-admission-initializer/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads start-kube-apiserver-admission-initializer"),
	// 				Operation: to.Ptr("Gets/List start-kube-apiserver-admission-initializer resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Poststarthook/Start-Kube-Apiserver-Admission-Initializer"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/readyz/shutdown/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads shutdown"),
	// 				Operation: to.Ptr("Gets/List shutdown resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Readyz/Shutdown"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/resetMetrics/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads resetMetrics"),
	// 				Operation: to.Ptr("Gets/List resetMetrics resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Resetmetrics"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/swagger-ui/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads swagger-ui"),
	// 				Operation: to.Ptr("Gets/List swagger-ui resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Swagger-Ui"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/swagger-api/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads swagger-api"),
	// 				Operation: to.Ptr("Gets/List swagger-api resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Swagger-Api"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/ui/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads ui"),
	// 				Operation: to.Ptr("Gets/List ui resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Ui"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/version/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads version"),
	// 				Operation: to.Ptr("Gets/List version resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Version"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/poddisruptionbudgets/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads poddisruptionbudgets"),
	// 				Operation: to.Ptr("Gets/List poddisruptionbudgets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Poddisruptionbudgets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/poddisruptionbudgets/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes poddisruptionbudgets"),
	// 				Operation: to.Ptr("Creates/Updates poddisruptionbudgets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Poddisruptionbudgets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/poddisruptionbudgets/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes poddisruptionbudgets"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection poddisruptionbudgets resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Poddisruptionbudgets"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/podsecuritypolicies/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads podsecuritypolicies"),
	// 				Operation: to.Ptr("Gets/List podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/podsecuritypolicies/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes podsecuritypolicies"),
	// 				Operation: to.Ptr("Creates/Updates podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/podsecuritypolicies/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes podsecuritypolicies"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterrolebindings/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads clusterrolebindings"),
	// 				Operation: to.Ptr("Gets/List clusterrolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterrolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterrolebindings/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes clusterrolebindings"),
	// 				Operation: to.Ptr("Creates/Updates clusterrolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterrolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterrolebindings/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes clusterrolebindings"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection clusterrolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterrolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterroles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads clusterroles"),
	// 				Operation: to.Ptr("Gets/List clusterroles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterroles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterroles/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes clusterroles"),
	// 				Operation: to.Ptr("Creates/Updates clusterroles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterroles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterroles/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes clusterroles"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection clusterroles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterroles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/rolebindings/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads rolebindings"),
	// 				Operation: to.Ptr("Gets/List rolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/rolebindings/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes rolebindings"),
	// 				Operation: to.Ptr("Creates/Updates rolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/rolebindings/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes rolebindings"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection rolebindings resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Rolebindings"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/roles/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads roles"),
	// 				Operation: to.Ptr("Gets/List roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/roles/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes roles"),
	// 				Operation: to.Ptr("Creates/Updates roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/roles/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes roles"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/scheduling.k8s.io/priorityclasses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads priorityclasses"),
	// 				Operation: to.Ptr("Gets/List priorityclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Priorityclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/scheduling.k8s.io/priorityclasses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes priorityclasses"),
	// 				Operation: to.Ptr("Creates/Updates priorityclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Priorityclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/scheduling.k8s.io/priorityclasses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes priorityclasses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection priorityclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Priorityclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/policy/podsecuritypolicies/use/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Use action on podsecuritypolicies"),
	// 				Operation: to.Ptr("Use podsecuritypolicies resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Podsecuritypolicies"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterroles/bind/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Binds clusterroles"),
	// 				Operation: to.Ptr("Bind clusterroles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterroles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/clusterroles/escalate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Escalates"),
	// 				Operation: to.Ptr("Escalate clusterroles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Clusterroles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/roles/bind/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Binds roles"),
	// 				Operation: to.Ptr("Bind roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/rbac.authorization.k8s.io/roles/escalate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Escalates roles"),
	// 				Operation: to.Ptr("Escalate roles resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Roles"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/serviceaccounts/impersonate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Impersonate serviceaccounts"),
	// 				Operation: to.Ptr("Impersonate serviceaccounts resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Serviceaccounts"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/users/impersonate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Impersonate users"),
	// 				Operation: to.Ptr("Impersonate users resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Users"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/groups/impersonate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Impersonate groups"),
	// 				Operation: to.Ptr("Impersonate groups resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Groups"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/authentication.k8s.io/userextras/impersonate/action"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Impersonate userextras"),
	// 				Operation: to.Ptr("Impersonate userextras resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Userextras"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/storageclasses/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads storageclasses"),
	// 				Operation: to.Ptr("Gets/List storageclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storageclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/storageclasses/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes storageclasses"),
	// 				Operation: to.Ptr("Creates/Updates storageclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storageclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/storageclasses/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes storageclasses"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection storageclasses resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Storageclasses"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/volumeattachments/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads volumeattachments"),
	// 				Operation: to.Ptr("Gets/List volumeattachments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Volumeattachments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/volumeattachments/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes volumeattachments"),
	// 				Operation: to.Ptr("Creates/Updates volumeattachments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Volumeattachments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/volumeattachments/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes volumeattachments"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection volumeattachments resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Volumeattachments"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csidrivers/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads csidrivers"),
	// 				Operation: to.Ptr("Gets/List csidrivers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csidrivers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csidrivers/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes csidrivers"),
	// 				Operation: to.Ptr("Creates/Updates csidrivers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csidrivers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csidrivers/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes csidrivers"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection csidrivers resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csidrivers"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csinodes/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Reads csinodes"),
	// 				Operation: to.Ptr("Gets/List csinodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csinodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csinodes/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Writes csinodes"),
	// 				Operation: to.Ptr("Creates/Updates csinodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csinodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/storage.k8s.io/csinodes/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Deletes csinodes"),
	// 				Operation: to.Ptr("Deletes/DeletesCollection csinodes resource"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Csinodes"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/providers/Microsoft.Insights/metricDefinitions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the available metrics for Managed Cluster"),
	// 				Operation: to.Ptr("Read Managed Cluster metric definitions"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("The metric definition of Managed Cluster"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/managedClusters/providers/Microsoft.Insights/logDefinitions/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Gets the available logs for Managed Cluster"),
	// 				Operation: to.Ptr("Read Managed Cluster log definitions"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("The log definition of Managed Cluster"),
	// 			},
	// 			Origin: to.Ptr("system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftManagedClusters/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a Open Shift Managed Cluster"),
	// 				Operation: to.Ptr("Get Open Shift Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Managed Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftManagedClusters/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new Open Shift Managed Cluster or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update Open Shift Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Managed Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftManagedClusters/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Delete a Open Shift Managed Cluster"),
	// 				Operation: to.Ptr("Delete Open Shift Managed Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Managed Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftClusters/read"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Get a Open Shift Cluster"),
	// 				Operation: to.Ptr("Get Open Shift Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftClusters/write"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Creates a new Open Shift Cluster or updates an existing one"),
	// 				Operation: to.Ptr("Create or Update Open Shift Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 		},
	// 		{
	// 			Name: to.Ptr("Microsoft.ContainerService/openShiftClusters/delete"),
	// 			Display: &armcontainerservice.OperationValueDisplay{
	// 				Description: to.Ptr("Delete a Open Shift Cluster"),
	// 				Operation: to.Ptr("Delete Open Shift Cluster"),
	// 				Provider: to.Ptr("Microsoft Container Service"),
	// 				Resource: to.Ptr("Open Shift Cluster"),
	// 			},
	// 			Origin: to.Ptr("user,system"),
	// 	}},
	// }
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// The List Operation response.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OutboundEnvironmentEndpoint 

type OutboundEnvironmentEndpoint struct {
	// The category of endpoints accessed by the AKS agent node, e.g. azure-resource-management, apiserver, etc.
	Category *string

	// The endpoints that AKS agent nodes connect to
	Endpoints []*EndpointDependency
}

OutboundEnvironmentEndpoint - Egress endpoints which AKS agent nodes connect to for common purpose.

func (OutboundEnvironmentEndpoint) MarshalJSON 

func (o OutboundEnvironmentEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OutboundEnvironmentEndpoint.

func (*OutboundEnvironmentEndpoint) UnmarshalJSON 

func (o *OutboundEnvironmentEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OutboundEnvironmentEndpoint.

type OutboundEnvironmentEndpointCollection 

type OutboundEnvironmentEndpointCollection struct {
	// REQUIRED; Collection of resources.
	Value []*OutboundEnvironmentEndpoint

	// READ-ONLY; Link to next page of resources.
	NextLink *string
}

OutboundEnvironmentEndpointCollection - Collection of OutboundEnvironmentEndpoint

func (OutboundEnvironmentEndpointCollection) MarshalJSON 

func (o OutboundEnvironmentEndpointCollection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OutboundEnvironmentEndpointCollection.

func (*OutboundEnvironmentEndpointCollection) UnmarshalJSON 

func (o *OutboundEnvironmentEndpointCollection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OutboundEnvironmentEndpointCollection.

type OutboundType 

type OutboundType string

OutboundType - This can only be set at cluster creation time and cannot be changed later. For more information see egress outbound type [https://docs.microsoft.com/azure/aks/egress-outboundtype]. 

const (
	// OutboundTypeLoadBalancer - The load balancer is used for egress through an AKS assigned public IP. This supports Kubernetes
	// services of type 'loadBalancer'. For more information see [outbound type loadbalancer](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-loadbalancer).
	OutboundTypeLoadBalancer OutboundType = "loadBalancer"
	// OutboundTypeManagedNATGateway - The AKS-managed NAT gateway is used for egress.
	OutboundTypeManagedNATGateway OutboundType = "managedNATGateway"
	// OutboundTypeUserAssignedNATGateway - The user-assigned NAT gateway associated to the cluster subnet is used for egress.
	// This is an advanced scenario and requires proper network configuration.
	OutboundTypeUserAssignedNATGateway OutboundType = "userAssignedNATGateway"
	// OutboundTypeUserDefinedRouting - Egress paths must be defined by the user. This is an advanced scenario and requires proper
	// network configuration. For more information see [outbound type userDefinedRouting](https://docs.microsoft.com/azure/aks/egress-outboundtype#outbound-type-of-userdefinedrouting).
	OutboundTypeUserDefinedRouting OutboundType = "userDefinedRouting"
)

func PossibleOutboundTypeValues 

func PossibleOutboundTypeValues() []OutboundType

PossibleOutboundTypeValues returns the possible values for the OutboundType const type.

type PortRange 

type PortRange struct {
	// The maximum port that is included in the range. It should be ranged from 1 to 65535, and be greater than or equal to portStart.
	PortEnd *int32

	// The minimum port that is included in the range. It should be ranged from 1 to 65535, and be less than or equal to portEnd.
	PortStart *int32

	// The network protocol of the port.
	Protocol *Protocol
}

PortRange - The port range.

func (PortRange) MarshalJSON 

func (p PortRange) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PortRange.

func (*PortRange) UnmarshalJSON 

func (p *PortRange) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PortRange.

type PowerState 

type PowerState struct {
	// Tells whether the cluster is Running or Stopped
	Code *Code
}

PowerState - Describes the Power State of the cluster

func (PowerState) MarshalJSON 

func (p PowerState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PowerState.

func (*PowerState) UnmarshalJSON 

func (p *PowerState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PowerState.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// The resource ID of the private endpoint
	ID *string
}

PrivateEndpoint - Private endpoint which a connection belongs to.

func (PrivateEndpoint) MarshalJSON 

func (p PrivateEndpoint) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpoint.

func (*PrivateEndpoint) UnmarshalJSON 

func (p *PrivateEndpoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpoint.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// The properties of a private endpoint connection.
	Properties *PrivateEndpointConnectionProperties

	// READ-ONLY; The ID of the private endpoint connection.
	ID *string

	// READ-ONLY; The name of the private endpoint connection.
	Name *string

	// READ-ONLY; The resource type.
	Type *string
}

PrivateEndpointConnection - A private endpoint connection

func (PrivateEndpointConnection) MarshalJSON 

func (p PrivateEndpointConnection) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnection.

func (*PrivateEndpointConnection) UnmarshalJSON 

func (p *PrivateEndpointConnection) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnection.

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// The collection value.
	Value []*PrivateEndpointConnection
}

PrivateEndpointConnectionListResult - A list of private endpoint connections

func (PrivateEndpointConnectionListResult) MarshalJSON 

func (p PrivateEndpointConnectionListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionListResult.

func (*PrivateEndpointConnectionListResult) UnmarshalJSON 

func (p *PrivateEndpointConnectionListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionListResult.

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState

	// The resource of private endpoint.
	PrivateEndpoint *PrivateEndpoint

	// READ-ONLY; The current provisioning state.
	ProvisioningState *PrivateEndpointConnectionProvisioningState
}

PrivateEndpointConnectionProperties - Properties of a private endpoint connection.

func (PrivateEndpointConnectionProperties) MarshalJSON 

func (p PrivateEndpointConnectionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateEndpointConnectionProperties.

func (*PrivateEndpointConnectionProperties) UnmarshalJSON 

func (p *PrivateEndpointConnectionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateEndpointConnectionProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

const (
	PrivateEndpointConnectionProvisioningStateCanceled  PrivateEndpointConnectionProvisioningState = "Canceled"
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

type PrivateEndpointConnectionsClient struct {
	// contains filtered or unexported fields
}

PrivateEndpointConnectionsClient contains the methods for the PrivateEndpointConnections group. Don't use this type directly, use NewPrivateEndpointConnectionsClient() instead.

func NewPrivateEndpointConnectionsClient 

func NewPrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateEndpointConnectionsClient, error)

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateEndpointConnectionsClient) BeginDelete 

func (client *PrivateEndpointConnectionsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientBeginDeleteOptions) (*runtime.Poller[PrivateEndpointConnectionsClientDeleteResponse], error)

BeginDelete - Deletes a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • options - PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/PrivateEndpointConnectionsDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewPrivateEndpointConnectionsClient().BeginDelete(ctx, "rg1", "clustername1", "privateendpointconnection1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*PrivateEndpointConnectionsClient) Get 

func (client *PrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientGetOptions) (PrivateEndpointConnectionsClientGetResponse, error)

Get - To learn more about private clusters, see: https://docs.microsoft.com/azure/aks/private-clusters If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • options - PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/PrivateEndpointConnectionsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateEndpointConnectionsClient().Get(ctx, "rg1", "clustername1", "privateendpointconnection1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.PrivateEndpointConnection = armcontainerservice.PrivateEndpointConnection{
// 	Name: to.Ptr("privateendpointconnection1"),
// 	Type: to.Ptr("Microsoft.Network/privateLinkServices/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedCluster/clustername1/privateEndpointConnections/privateendpointconnection1"),
// 	Properties: &armcontainerservice.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armcontainerservice.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subid2/resourceGroups/rg2/providers/Microsoft.Network/privateEndpoints/pe2"),
// 		},
// 		PrivateLinkServiceConnectionState: &armcontainerservice.PrivateLinkServiceConnectionState{
// 			Status: to.Ptr(armcontainerservice.ConnectionStatusApproved),
// 		},
// 		ProvisioningState: to.Ptr(armcontainerservice.PrivateEndpointConnectionProvisioningStateSucceeded),
// 	},
// }

Output:

func (*PrivateEndpointConnectionsClient) List 

func (client *PrivateEndpointConnectionsClient) List(ctx context.Context, resourceGroupName string, resourceName string, options *PrivateEndpointConnectionsClientListOptions) (PrivateEndpointConnectionsClientListResponse, error)

List - To learn more about private clusters, see: https://docs.microsoft.com/azure/aks/private-clusters If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.List method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/PrivateEndpointConnectionsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateEndpointConnectionsClient().List(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.PrivateEndpointConnectionListResult = armcontainerservice.PrivateEndpointConnectionListResult{
// 	Value: []*armcontainerservice.PrivateEndpointConnection{
// 		{
// 			Name: to.Ptr("privateendpointconnection1"),
// 			Type: to.Ptr("Microsoft.Network/privateLinkServices/privateEndpointConnections"),
// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedCluster/clustername1/privateEndpointConnections/privateendpointconnection1"),
// 			Properties: &armcontainerservice.PrivateEndpointConnectionProperties{
// 				PrivateEndpoint: &armcontainerservice.PrivateEndpoint{
// 					ID: to.Ptr("/subscriptions/subid2/resourceGroups/rg2/providers/Microsoft.Network/privateEndpoints/pe2"),
// 				},
// 				PrivateLinkServiceConnectionState: &armcontainerservice.PrivateLinkServiceConnectionState{
// 					Status: to.Ptr(armcontainerservice.ConnectionStatusApproved),
// 				},
// 				ProvisioningState: to.Ptr(armcontainerservice.PrivateEndpointConnectionProvisioningStateSucceeded),
// 			},
// 	}},
// }

Output:

func (*PrivateEndpointConnectionsClient) Update 

func (client *PrivateEndpointConnectionsClient) Update(ctx context.Context, resourceGroupName string, resourceName string, privateEndpointConnectionName string, parameters PrivateEndpointConnection, options *PrivateEndpointConnectionsClientUpdateOptions) (PrivateEndpointConnectionsClientUpdateResponse, error)

Update - Updates a private endpoint connection. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • privateEndpointConnectionName - The name of the private endpoint connection.
  • parameters - The updated private endpoint connection.
  • options - PrivateEndpointConnectionsClientUpdateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/PrivateEndpointConnectionsUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateEndpointConnectionsClient().Update(ctx, "rg1", "clustername1", "privateendpointconnection1", armcontainerservice.PrivateEndpointConnection{
	Properties: &armcontainerservice.PrivateEndpointConnectionProperties{
		PrivateLinkServiceConnectionState: &armcontainerservice.PrivateLinkServiceConnectionState{
			Status: to.Ptr(armcontainerservice.ConnectionStatusApproved),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.PrivateEndpointConnection = armcontainerservice.PrivateEndpointConnection{
// 	Name: to.Ptr("privateendpointconnection1"),
// 	Type: to.Ptr("Microsoft.Network/privateLinkServices/privateEndpointConnections"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedCluster/clustername1/privateEndpointConnections/privateendpointconnection1"),
// 	Properties: &armcontainerservice.PrivateEndpointConnectionProperties{
// 		PrivateEndpoint: &armcontainerservice.PrivateEndpoint{
// 			ID: to.Ptr("/subscriptions/subid2/resourceGroups/rg2/providers/Microsoft.Network/privateEndpoints/pe2"),
// 		},
// 		PrivateLinkServiceConnectionState: &armcontainerservice.PrivateLinkServiceConnectionState{
// 			Status: to.Ptr(armcontainerservice.ConnectionStatusApproved),
// 		},
// 		ProvisioningState: to.Ptr(armcontainerservice.PrivateEndpointConnectionProvisioningStateSucceeded),
// 	},
// }

Output:

type PrivateEndpointConnectionsClientBeginDeleteOptions 

type PrivateEndpointConnectionsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.

type PrivateEndpointConnectionsClientDeleteResponse 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.BeginDelete.

type PrivateEndpointConnectionsClientGetOptions 

type PrivateEndpointConnectionsClientGetOptions struct {
}

PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

type PrivateEndpointConnectionsClientGetResponse 

type PrivateEndpointConnectionsClientGetResponse struct {
	// A private endpoint connection
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListOptions 

type PrivateEndpointConnectionsClientListOptions struct {
}

PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.List method.

type PrivateEndpointConnectionsClientListResponse 

type PrivateEndpointConnectionsClientListResponse struct {
	// A list of private endpoint connections
	PrivateEndpointConnectionListResult
}

PrivateEndpointConnectionsClientListResponse contains the response from method PrivateEndpointConnectionsClient.List.

type PrivateEndpointConnectionsClientUpdateOptions 

type PrivateEndpointConnectionsClientUpdateOptions struct {
}

PrivateEndpointConnectionsClientUpdateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Update method.

type PrivateEndpointConnectionsClientUpdateResponse 

type PrivateEndpointConnectionsClientUpdateResponse struct {
	// A private endpoint connection
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientUpdateResponse contains the response from method PrivateEndpointConnectionsClient.Update.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// The group ID of the resource.
	GroupID *string

	// The ID of the private link resource.
	ID *string

	// The name of the private link resource.
	Name *string

	// The RequiredMembers of the resource
	RequiredMembers []*string

	// The resource type.
	Type *string

	// READ-ONLY; The private link service ID of the resource, this field is exposed only to NRP internally.
	PrivateLinkServiceID *string
}

PrivateLinkResource - A private link resource

func (PrivateLinkResource) MarshalJSON 

func (p PrivateLinkResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResource.

func (*PrivateLinkResource) UnmarshalJSON 

func (p *PrivateLinkResource) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResource.

type PrivateLinkResourcesClient 

type PrivateLinkResourcesClient struct {
	// contains filtered or unexported fields
}

PrivateLinkResourcesClient contains the methods for the PrivateLinkResources group. Don't use this type directly, use NewPrivateLinkResourcesClient() instead.

func NewPrivateLinkResourcesClient 

func NewPrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinkResourcesClient, error)

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*PrivateLinkResourcesClient) List 

func (client *PrivateLinkResourcesClient) List(ctx context.Context, resourceGroupName string, resourceName string, options *PrivateLinkResourcesClientListOptions) (PrivateLinkResourcesClientListResponse, error)

List - To learn more about private clusters, see: https://docs.microsoft.com/azure/aks/private-clusters If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - PrivateLinkResourcesClientListOptions contains the optional parameters for the PrivateLinkResourcesClient.List method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/PrivateLinkResourcesList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewPrivateLinkResourcesClient().List(ctx, "rg1", "clustername1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.PrivateLinkResourcesListResult = armcontainerservice.PrivateLinkResourcesListResult{
// 	Value: []*armcontainerservice.PrivateLinkResource{
// 		{
// 			Name: to.Ptr("management"),
// 			Type: to.Ptr("Microsoft.ContainerService/managedClusters/privateLinkResources"),
// 			GroupID: to.Ptr("management"),
// 			PrivateLinkServiceID: to.Ptr("/subscriptions/subid2/resourceGroups/rg2/providers/Microsoft.Network/privateLinkServices/plsName"),
// 			RequiredMembers: []*string{
// 				to.Ptr("management")},
// 		}},
// 	}

Output:

type PrivateLinkResourcesClientListOptions 

type PrivateLinkResourcesClientListOptions struct {
}

PrivateLinkResourcesClientListOptions contains the optional parameters for the PrivateLinkResourcesClient.List method.

type PrivateLinkResourcesClientListResponse 

type PrivateLinkResourcesClientListResponse struct {
	// A list of private link resources
	PrivateLinkResourcesListResult
}

PrivateLinkResourcesClientListResponse contains the response from method PrivateLinkResourcesClient.List.

type PrivateLinkResourcesListResult 

type PrivateLinkResourcesListResult struct {
	// The collection value.
	Value []*PrivateLinkResource
}

PrivateLinkResourcesListResult - A list of private link resources

func (PrivateLinkResourcesListResult) MarshalJSON 

func (p PrivateLinkResourcesListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourcesListResult.

func (*PrivateLinkResourcesListResult) UnmarshalJSON 

func (p *PrivateLinkResourcesListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkResourcesListResult.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// The private link service connection description.
	Description *string

	// The private link service connection status.
	Status *ConnectionStatus
}

PrivateLinkServiceConnectionState - The state of a private link service connection.

func (PrivateLinkServiceConnectionState) MarshalJSON 

func (p PrivateLinkServiceConnectionState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PrivateLinkServiceConnectionState.

func (*PrivateLinkServiceConnectionState) UnmarshalJSON 

func (p *PrivateLinkServiceConnectionState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PrivateLinkServiceConnectionState.

type Protocol 

type Protocol string

Protocol - The network protocol of the port. 

const (
	// ProtocolTCP - TCP protocol.
	ProtocolTCP Protocol = "TCP"
	// ProtocolUDP - UDP protocol.
	ProtocolUDP Protocol = "UDP"
)

func PossibleProtocolValues 

func PossibleProtocolValues() []Protocol

PossibleProtocolValues returns the possible values for the Protocol const type.

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - Allow or deny public network access for AKS 

const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type RelativeMonthlySchedule 

type RelativeMonthlySchedule struct {
	// REQUIRED; Specifies on which day of the week the maintenance occurs.
	DayOfWeek *WeekDay

	// REQUIRED; Specifies the number of months between each set of occurrences.
	IntervalMonths *int32

	// REQUIRED; Specifies on which week of the month the dayOfWeek applies.
	WeekIndex *Type
}

RelativeMonthlySchedule - For schedules like: 'recur every month on the first Monday' or 'recur every 3 months on last Friday'.

func (RelativeMonthlySchedule) MarshalJSON 

func (r RelativeMonthlySchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RelativeMonthlySchedule.

func (*RelativeMonthlySchedule) UnmarshalJSON 

func (r *RelativeMonthlySchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RelativeMonthlySchedule.

type ResolvePrivateLinkServiceIDClient 

type ResolvePrivateLinkServiceIDClient struct {
	// contains filtered or unexported fields
}

ResolvePrivateLinkServiceIDClient contains the methods for the ResolvePrivateLinkServiceID group. Don't use this type directly, use NewResolvePrivateLinkServiceIDClient() instead.

func NewResolvePrivateLinkServiceIDClient 

func NewResolvePrivateLinkServiceIDClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ResolvePrivateLinkServiceIDClient, error)

NewResolvePrivateLinkServiceIDClient creates a new instance of ResolvePrivateLinkServiceIDClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ResolvePrivateLinkServiceIDClient) POST 

func (client *ResolvePrivateLinkServiceIDClient) POST(ctx context.Context, resourceGroupName string, resourceName string, parameters PrivateLinkResource, options *ResolvePrivateLinkServiceIDClientPOSTOptions) (ResolvePrivateLinkServiceIDClientPOSTResponse, error)

POST - Gets the private link service ID for the specified managed cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - Parameters required in order to resolve a private link service ID.
  • options - ResolvePrivateLinkServiceIDClientPOSTOptions contains the optional parameters for the ResolvePrivateLinkServiceIDClient.POST method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/ResolvePrivateLinkServiceId.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewResolvePrivateLinkServiceIDClient().POST(ctx, "rg1", "clustername1", armcontainerservice.PrivateLinkResource{
	Name: to.Ptr("management"),
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.PrivateLinkResource = armcontainerservice.PrivateLinkResource{
// 	PrivateLinkServiceID: to.Ptr("/subscriptions/subid2/resourceGroups/rg2/providers/Microsoft.Network/privateLinkServices/plsName"),
// }

Output:

type ResolvePrivateLinkServiceIDClientPOSTOptions 

type ResolvePrivateLinkServiceIDClientPOSTOptions struct {
}

ResolvePrivateLinkServiceIDClientPOSTOptions contains the optional parameters for the ResolvePrivateLinkServiceIDClient.POST method.

type ResolvePrivateLinkServiceIDClientPOSTResponse 

type ResolvePrivateLinkServiceIDClientPOSTResponse struct {
	// A private link resource
	PrivateLinkResource
}

ResolvePrivateLinkServiceIDClientPOSTResponse contains the response from method ResolvePrivateLinkServiceIDClient.POST.

type ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - For more information see use managed identities in AKS [https://docs.microsoft.com/azure/aks/use-managed-identity]. 

const (
	// ResourceIdentityTypeNone - Do not use a managed identity for the Managed Cluster, service principal will be used instead.
	ResourceIdentityTypeNone ResourceIdentityType = "None"
	// ResourceIdentityTypeSystemAssigned - Use an implicitly created system assigned managed identity to manage cluster resources.
	// Master components in the control plane such as kube-controller-manager will use the system assigned managed identity to
	// manipulate Azure resources.
	ResourceIdentityTypeSystemAssigned ResourceIdentityType = "SystemAssigned"
	// ResourceIdentityTypeUserAssigned - Use a user-specified identity to manage cluster resources. Master components in the
	// control plane such as kube-controller-manager will use the specified user assigned managed identity to manipulate Azure
	// resources.
	ResourceIdentityTypeUserAssigned ResourceIdentityType = "UserAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type ResourceReference 

type ResourceReference struct {
	// The fully qualified Azure resource id.
	ID *string
}

ResourceReference - A reference to an Azure resource.

func (ResourceReference) MarshalJSON 

func (r ResourceReference) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourceReference.

func (*ResourceReference) UnmarshalJSON 

func (r *ResourceReference) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourceReference.

type RestrictionLevel added in v6.3.0 

type RestrictionLevel string

RestrictionLevel - The restriction level applied to the cluster's node resource group. If not specified, the default is 'Unrestricted' 

const (
	// RestrictionLevelReadOnly - Only */read RBAC permissions allowed on the managed node resource group
	RestrictionLevelReadOnly RestrictionLevel = "ReadOnly"
	// RestrictionLevelUnrestricted - All RBAC permissions are allowed on the managed node resource group
	RestrictionLevelUnrestricted RestrictionLevel = "Unrestricted"
)

func PossibleRestrictionLevelValues added in v6.3.0 

func PossibleRestrictionLevelValues() []RestrictionLevel

PossibleRestrictionLevelValues returns the possible values for the RestrictionLevel const type.

type RunCommandRequest 

type RunCommandRequest struct {
	// REQUIRED; The command to run.
	Command *string

	// AuthToken issued for AKS AAD Server App.
	ClusterToken *string

	// A base64 encoded zip file containing the files required by the command.
	Context *string
}

RunCommandRequest - A run command request

func (RunCommandRequest) MarshalJSON 

func (r RunCommandRequest) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RunCommandRequest.

func (*RunCommandRequest) UnmarshalJSON 

func (r *RunCommandRequest) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RunCommandRequest.

type RunCommandResult 

type RunCommandResult struct {
	// Properties of command result.
	Properties *CommandResultProperties

	// READ-ONLY; The command id.
	ID *string
}

RunCommandResult - run command result.

func (RunCommandResult) MarshalJSON 

func (r RunCommandResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RunCommandResult.

func (*RunCommandResult) UnmarshalJSON 

func (r *RunCommandResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RunCommandResult.

type SSHConfiguration 

type SSHConfiguration struct {
	// REQUIRED; The list of SSH public keys used to authenticate with Linux-based VMs. A maximum of 1 key may be specified.
	PublicKeys []*SSHPublicKey
}

SSHConfiguration - SSH configuration for Linux-based VMs running on Azure.

func (SSHConfiguration) MarshalJSON 

func (s SSHConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSHConfiguration.

func (*SSHConfiguration) UnmarshalJSON 

func (s *SSHConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SSHConfiguration.

type SSHPublicKey 

type SSHPublicKey struct {
	// REQUIRED; Certificate public key used to authenticate with VMs through SSH. The certificate must be in PEM format with
	// or without headers.
	KeyData *string
}

SSHPublicKey - Contains information about SSH certificate public key data.

func (SSHPublicKey) MarshalJSON 

func (s SSHPublicKey) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSHPublicKey.

func (*SSHPublicKey) UnmarshalJSON 

func (s *SSHPublicKey) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SSHPublicKey.

type ScaleDownMode 

type ScaleDownMode string

ScaleDownMode - Describes how VMs are added to or removed from Agent Pools. See billing states [https://docs.microsoft.com/azure/virtual-machines/states-billing]. 

const (
	// ScaleDownModeDeallocate - Attempt to start deallocated instances (if they exist) during scale up and deallocate instances
	// during scale down.
	ScaleDownModeDeallocate ScaleDownMode = "Deallocate"
	// ScaleDownModeDelete - Create new instances during scale up and remove instances during scale down.
	ScaleDownModeDelete ScaleDownMode = "Delete"
)

func PossibleScaleDownModeValues 

func PossibleScaleDownModeValues() []ScaleDownMode

PossibleScaleDownModeValues returns the possible values for the ScaleDownMode const type.

type ScaleSetEvictionPolicy 

type ScaleSetEvictionPolicy string

ScaleSetEvictionPolicy - The eviction policy specifies what to do with the VM when it is evicted. The default is Delete. For more information about eviction see spot VMs [https://docs.microsoft.com/azure/virtual-machines/spot-vms] 

const (
	// ScaleSetEvictionPolicyDeallocate - Nodes in the underlying Scale Set of the node pool are set to the stopped-deallocated
	// state upon eviction. Nodes in the stopped-deallocated state count against your compute quota and can cause issues with
	// cluster scaling or upgrading.
	ScaleSetEvictionPolicyDeallocate ScaleSetEvictionPolicy = "Deallocate"
	// ScaleSetEvictionPolicyDelete - Nodes in the underlying Scale Set of the node pool are deleted when they're evicted.
	ScaleSetEvictionPolicyDelete ScaleSetEvictionPolicy = "Delete"
)

func PossibleScaleSetEvictionPolicyValues 

func PossibleScaleSetEvictionPolicyValues() []ScaleSetEvictionPolicy

PossibleScaleSetEvictionPolicyValues returns the possible values for the ScaleSetEvictionPolicy const type.

type ScaleSetPriority 

type ScaleSetPriority string

ScaleSetPriority - The Virtual Machine Scale Set priority. 

const (
	// ScaleSetPriorityRegular - Regular VMs will be used.
	ScaleSetPriorityRegular ScaleSetPriority = "Regular"
	// ScaleSetPrioritySpot - Spot priority VMs will be used. There is no SLA for spot nodes. See [spot on AKS](https://docs.microsoft.com/azure/aks/spot-node-pool)
	// for more information.
	ScaleSetPrioritySpot ScaleSetPriority = "Spot"
)

func PossibleScaleSetPriorityValues 

func PossibleScaleSetPriorityValues() []ScaleSetPriority

PossibleScaleSetPriorityValues returns the possible values for the ScaleSetPriority const type.

type Schedule 

type Schedule struct {
	// For schedules like: 'recur every month on the 15th' or 'recur every 3 months on the 20th'.
	AbsoluteMonthly *AbsoluteMonthlySchedule

	// For schedules like: 'recur every day' or 'recur every 3 days'.
	Daily *DailySchedule

	// For schedules like: 'recur every month on the first Monday' or 'recur every 3 months on last Friday'.
	RelativeMonthly *RelativeMonthlySchedule

	// For schedules like: 'recur every Monday' or 'recur every 3 weeks on Wednesday'.
	Weekly *WeeklySchedule
}

Schedule - One and only one of the schedule types should be specified. Choose either 'daily', 'weekly', 'absoluteMonthly' or 'relativeMonthly' for your maintenance schedule.

func (Schedule) MarshalJSON 

func (s Schedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Schedule.

func (*Schedule) UnmarshalJSON 

func (s *Schedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Schedule.

type ServiceMeshMode 

type ServiceMeshMode string

ServiceMeshMode - Mode of the service mesh. 

const (
	// ServiceMeshModeDisabled - Mesh is disabled.
	ServiceMeshModeDisabled ServiceMeshMode = "Disabled"
	// ServiceMeshModeIstio - Istio deployed as an AKS addon.
	ServiceMeshModeIstio ServiceMeshMode = "Istio"
)

func PossibleServiceMeshModeValues 

func PossibleServiceMeshModeValues() []ServiceMeshMode

PossibleServiceMeshModeValues returns the possible values for the ServiceMeshMode const type.

type ServiceMeshProfile 

type ServiceMeshProfile struct {
	// REQUIRED; Mode of the service mesh.
	Mode *ServiceMeshMode

	// Istio service mesh configuration.
	Istio *IstioServiceMesh
}

ServiceMeshProfile - Service mesh profile for a managed cluster.

func (ServiceMeshProfile) MarshalJSON 

func (s ServiceMeshProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServiceMeshProfile.

func (*ServiceMeshProfile) UnmarshalJSON 

func (s *ServiceMeshProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceMeshProfile.

type Snapshot 

type Snapshot struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Properties of a snapshot.
	Properties *SnapshotProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

Snapshot - A node pool snapshot resource.

func (Snapshot) MarshalJSON 

func (s Snapshot) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Snapshot.

func (*Snapshot) UnmarshalJSON 

func (s *Snapshot) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Snapshot.

type SnapshotListResult 

type SnapshotListResult struct {
	// The list of snapshots.
	Value []*Snapshot

	// READ-ONLY; The URL to get the next set of snapshot results.
	NextLink *string
}

SnapshotListResult - The response from the List Snapshots operation.

func (SnapshotListResult) MarshalJSON 

func (s SnapshotListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotListResult.

func (*SnapshotListResult) UnmarshalJSON 

func (s *SnapshotListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotListResult.

type SnapshotProperties 

type SnapshotProperties struct {
	// CreationData to be used to specify the source agent pool resource ID to create this snapshot.
	CreationData *CreationData

	// The type of a snapshot. The default is NodePool.
	SnapshotType *SnapshotType

	// READ-ONLY; Whether to use a FIPS-enabled OS.
	EnableFIPS *bool

	// READ-ONLY; The version of Kubernetes.
	KubernetesVersion *string

	// READ-ONLY; The version of node image.
	NodeImageVersion *string

	// READ-ONLY; Specifies the OS SKU used by the agent pool. The default is Ubuntu if OSType is Linux. The default is Windows2019
	// when Kubernetes = 1.25 if OSType is Windows.
	OSSKU *OSSKU

	// READ-ONLY; The operating system type. The default is Linux.
	OSType *OSType

	// READ-ONLY; The size of the VM.
	VMSize *string
}

SnapshotProperties - Properties used to configure a node pool snapshot.

func (SnapshotProperties) MarshalJSON 

func (s SnapshotProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SnapshotProperties.

func (*SnapshotProperties) UnmarshalJSON 

func (s *SnapshotProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SnapshotProperties.

type SnapshotType 

type SnapshotType string

SnapshotType - The type of a snapshot. The default is NodePool. 

const (
	// SnapshotTypeNodePool - The snapshot is a snapshot of a node pool.
	SnapshotTypeNodePool SnapshotType = "NodePool"
)

func PossibleSnapshotTypeValues 

func PossibleSnapshotTypeValues() []SnapshotType

PossibleSnapshotTypeValues returns the possible values for the SnapshotType const type.

type SnapshotsClient 

type SnapshotsClient struct {
	// contains filtered or unexported fields
}

SnapshotsClient contains the methods for the Snapshots group. Don't use this type directly, use NewSnapshotsClient() instead.

func NewSnapshotsClient 

func NewSnapshotsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SnapshotsClient, error)

NewSnapshotsClient creates a new instance of SnapshotsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*SnapshotsClient) CreateOrUpdate 

func (client *SnapshotsClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters Snapshot, options *SnapshotsClientCreateOrUpdateOptions) (SnapshotsClientCreateOrUpdateResponse, error)

CreateOrUpdate - Creates or updates a snapshot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - The snapshot to create or update.
  • options - SnapshotsClientCreateOrUpdateOptions contains the optional parameters for the SnapshotsClient.CreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsCreate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotsClient().CreateOrUpdate(ctx, "rg1", "snapshot1", armcontainerservice.Snapshot{
	Location: to.Ptr("westus"),
	Tags: map[string]*string{
		"key1": to.Ptr("val1"),
		"key2": to.Ptr("val2"),
	},
	Properties: &armcontainerservice.SnapshotProperties{
		CreationData: &armcontainerservice.CreationData{
			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
		},
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.Snapshot = armcontainerservice.Snapshot{
// 	Name: to.Ptr("snapshot1"),
// 	Type: to.Ptr("Microsoft.ContainerService/Snapshots"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
// 	SystemData: &armcontainerservice.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-09T20:13:23.298Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("val1"),
// 		"key2": to.Ptr("val2"),
// 	},
// 	Properties: &armcontainerservice.SnapshotProperties{
// 		CreationData: &armcontainerservice.CreationData{
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
// 		},
// 		EnableFIPS: to.Ptr(false),
// 		KubernetesVersion: to.Ptr("1.20.5"),
// 		NodeImageVersion: to.Ptr("AKSUbuntu-1804gen2containerd-2021.09.11"),
// 		OSSKU: to.Ptr(armcontainerservice.OSSKUUbuntu),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		SnapshotType: to.Ptr(armcontainerservice.SnapshotTypeNodePool),
// 		VMSize: to.Ptr("Standard_D2s_v3"),
// 	},
// }

Output:

func (*SnapshotsClient) Delete 

func (client *SnapshotsClient) Delete(ctx context.Context, resourceGroupName string, resourceName string, options *SnapshotsClientDeleteOptions) (SnapshotsClientDeleteResponse, error)

Delete - Deletes a snapshot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - SnapshotsClientDeleteOptions contains the optional parameters for the SnapshotsClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsDelete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
_, err = clientFactory.NewSnapshotsClient().Delete(ctx, "rg1", "snapshot1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}

Output:

func (*SnapshotsClient) Get 

func (client *SnapshotsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *SnapshotsClientGetOptions) (SnapshotsClientGetResponse, error)

Get - Gets a snapshot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - SnapshotsClientGetOptions contains the optional parameters for the SnapshotsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsGet.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotsClient().Get(ctx, "rg1", "snapshot1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.Snapshot = armcontainerservice.Snapshot{
// 	Name: to.Ptr("snapshot1"),
// 	Type: to.Ptr("Microsoft.ContainerService/Snapshots"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
// 	SystemData: &armcontainerservice.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-09T20:13:23.298Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("val1"),
// 		"key2": to.Ptr("val2"),
// 	},
// 	Properties: &armcontainerservice.SnapshotProperties{
// 		CreationData: &armcontainerservice.CreationData{
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
// 		},
// 		EnableFIPS: to.Ptr(false),
// 		KubernetesVersion: to.Ptr("1.20.5"),
// 		NodeImageVersion: to.Ptr("AKSUbuntu-1804gen2containerd-2021.09.11"),
// 		OSSKU: to.Ptr(armcontainerservice.OSSKUUbuntu),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		SnapshotType: to.Ptr(armcontainerservice.SnapshotTypeNodePool),
// 		VMSize: to.Ptr("Standard_D2s_v3"),
// 	},
// }

Output:

func (*SnapshotsClient) NewListByResourceGroupPager 

func (client *SnapshotsClient) NewListByResourceGroupPager(resourceGroupName string, options *SnapshotsClientListByResourceGroupOptions) *runtime.Pager[SnapshotsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists snapshots in the specified subscription and resource group.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - SnapshotsClientListByResourceGroupOptions contains the optional parameters for the SnapshotsClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsListByResourceGroup.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSnapshotsClient().NewListByResourceGroupPager("rg1", 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.SnapshotListResult = armcontainerservice.SnapshotListResult{
	// 	Value: []*armcontainerservice.Snapshot{
	// 		{
	// 			Name: to.Ptr("snapshot1"),
	// 			Type: to.Ptr("Microsoft.ContainerService/Snapshots"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
	// 			SystemData: &armcontainerservice.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-09T20:13:23.298Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("val1"),
	// 				"key2": to.Ptr("val2"),
	// 			},
	// 			Properties: &armcontainerservice.SnapshotProperties{
	// 				CreationData: &armcontainerservice.CreationData{
	// 					SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
	// 				},
	// 				EnableFIPS: to.Ptr(false),
	// 				KubernetesVersion: to.Ptr("1.20.5"),
	// 				NodeImageVersion: to.Ptr("AKSUbuntu-1804gen2containerd-2021.09.11"),
	// 				OSSKU: to.Ptr(armcontainerservice.OSSKUUbuntu),
	// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
	// 				SnapshotType: to.Ptr(armcontainerservice.SnapshotTypeNodePool),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 			},
	// 	}},
	// }
}

Output:

func (*SnapshotsClient) NewListPager 

func (client *SnapshotsClient) NewListPager(options *SnapshotsClientListOptions) *runtime.Pager[SnapshotsClientListResponse]

NewListPager - Gets a list of snapshots in the specified subscription.

Generated from API version 2024-09-01

  • options - SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsList.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewSnapshotsClient().NewListPager(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.SnapshotListResult = armcontainerservice.SnapshotListResult{
	// 	Value: []*armcontainerservice.Snapshot{
	// 		{
	// 			Name: to.Ptr("snapshot1"),
	// 			Type: to.Ptr("Microsoft.ContainerService/Snapshots"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
	// 			SystemData: &armcontainerservice.SystemData{
	// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-09T20:13:23.298Z"); return t}()),
	// 				CreatedBy: to.Ptr("user1"),
	// 				CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
	// 			},
	// 			Location: to.Ptr("westus"),
	// 			Tags: map[string]*string{
	// 				"key1": to.Ptr("val1"),
	// 				"key2": to.Ptr("val2"),
	// 			},
	// 			Properties: &armcontainerservice.SnapshotProperties{
	// 				CreationData: &armcontainerservice.CreationData{
	// 					SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
	// 				},
	// 				EnableFIPS: to.Ptr(false),
	// 				KubernetesVersion: to.Ptr("1.20.5"),
	// 				NodeImageVersion: to.Ptr("AKSUbuntu-1804gen2containerd-2021.09.11"),
	// 				OSSKU: to.Ptr(armcontainerservice.OSSKUUbuntu),
	// 				OSType: to.Ptr(armcontainerservice.OSTypeLinux),
	// 				SnapshotType: to.Ptr(armcontainerservice.SnapshotTypeNodePool),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 			},
	// 	}},
	// }
}

Output:

func (*SnapshotsClient) UpdateTags 

func (client *SnapshotsClient) UpdateTags(ctx context.Context, resourceGroupName string, resourceName string, parameters TagsObject, options *SnapshotsClientUpdateTagsOptions) (SnapshotsClientUpdateTagsResponse, error)

UpdateTags - Updates tags on a snapshot. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • parameters - Parameters supplied to the Update snapshot Tags operation.
  • options - SnapshotsClientUpdateTagsOptions contains the optional parameters for the SnapshotsClient.UpdateTags method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/SnapshotsUpdateTags.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewSnapshotsClient().UpdateTags(ctx, "rg1", "snapshot1", armcontainerservice.TagsObject{
	Tags: map[string]*string{
		"key2": to.Ptr("new-val2"),
		"key3": to.Ptr("val3"),
	},
}, nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.Snapshot = armcontainerservice.Snapshot{
// 	Name: to.Ptr("snapshot1"),
// 	Type: to.Ptr("Microsoft.ContainerService/Snapshots"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/snapshots/snapshot1"),
// 	SystemData: &armcontainerservice.SystemData{
// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-09T20:13:23.298Z"); return t}()),
// 		CreatedBy: to.Ptr("user1"),
// 		CreatedByType: to.Ptr(armcontainerservice.CreatedByTypeUser),
// 	},
// 	Location: to.Ptr("westus"),
// 	Tags: map[string]*string{
// 		"key1": to.Ptr("val1"),
// 		"key2": to.Ptr("val2"),
// 	},
// 	Properties: &armcontainerservice.SnapshotProperties{
// 		CreationData: &armcontainerservice.CreationData{
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
// 		},
// 		EnableFIPS: to.Ptr(false),
// 		KubernetesVersion: to.Ptr("1.20.5"),
// 		NodeImageVersion: to.Ptr("AKSUbuntu-1804gen2containerd-2021.09.11"),
// 		OSSKU: to.Ptr(armcontainerservice.OSSKUUbuntu),
// 		OSType: to.Ptr(armcontainerservice.OSTypeLinux),
// 		SnapshotType: to.Ptr(armcontainerservice.SnapshotTypeNodePool),
// 		VMSize: to.Ptr("Standard_D2s_v3"),
// 	},
// }

Output:

type SnapshotsClientCreateOrUpdateOptions 

type SnapshotsClientCreateOrUpdateOptions struct {
}

SnapshotsClientCreateOrUpdateOptions contains the optional parameters for the SnapshotsClient.CreateOrUpdate method.

type SnapshotsClientCreateOrUpdateResponse 

type SnapshotsClientCreateOrUpdateResponse struct {
	// A node pool snapshot resource.
	Snapshot
}

SnapshotsClientCreateOrUpdateResponse contains the response from method SnapshotsClient.CreateOrUpdate.

type SnapshotsClientDeleteOptions 

type SnapshotsClientDeleteOptions struct {
}

SnapshotsClientDeleteOptions contains the optional parameters for the SnapshotsClient.Delete method.

type SnapshotsClientDeleteResponse 

type SnapshotsClientDeleteResponse struct {
}

SnapshotsClientDeleteResponse contains the response from method SnapshotsClient.Delete.

type SnapshotsClientGetOptions 

type SnapshotsClientGetOptions struct {
}

SnapshotsClientGetOptions contains the optional parameters for the SnapshotsClient.Get method.

type SnapshotsClientGetResponse 

type SnapshotsClientGetResponse struct {
	// A node pool snapshot resource.
	Snapshot
}

SnapshotsClientGetResponse contains the response from method SnapshotsClient.Get.

type SnapshotsClientListByResourceGroupOptions 

type SnapshotsClientListByResourceGroupOptions struct {
}

SnapshotsClientListByResourceGroupOptions contains the optional parameters for the SnapshotsClient.NewListByResourceGroupPager method.

type SnapshotsClientListByResourceGroupResponse 

type SnapshotsClientListByResourceGroupResponse struct {
	// The response from the List Snapshots operation.
	SnapshotListResult
}

SnapshotsClientListByResourceGroupResponse contains the response from method SnapshotsClient.NewListByResourceGroupPager.

type SnapshotsClientListOptions 

type SnapshotsClientListOptions struct {
}

SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.NewListPager method.

type SnapshotsClientListResponse 

type SnapshotsClientListResponse struct {
	// The response from the List Snapshots operation.
	SnapshotListResult
}

SnapshotsClientListResponse contains the response from method SnapshotsClient.NewListPager.

type SnapshotsClientUpdateTagsOptions 

type SnapshotsClientUpdateTagsOptions struct {
}

SnapshotsClientUpdateTagsOptions contains the optional parameters for the SnapshotsClient.UpdateTags method.

type SnapshotsClientUpdateTagsResponse 

type SnapshotsClientUpdateTagsResponse struct {
	// A node pool snapshot resource.
	Snapshot
}

SnapshotsClientUpdateTagsResponse contains the response from method SnapshotsClient.UpdateTags.

type SysctlConfig 

type SysctlConfig struct {
	// Sysctl setting fs.aio-max-nr.
	FsAioMaxNr *int32

	// Sysctl setting fs.file-max.
	FsFileMax *int32

	// Sysctl setting fs.inotify.maxuserwatches.
	FsInotifyMaxUserWatches *int32

	// Sysctl setting fs.nr_open.
	FsNrOpen *int32

	// Sysctl setting kernel.threads-max.
	KernelThreadsMax *int32

	// Sysctl setting net.core.netdevmaxbacklog.
	NetCoreNetdevMaxBacklog *int32

	// Sysctl setting net.core.optmem_max.
	NetCoreOptmemMax *int32

	// Sysctl setting net.core.rmem_default.
	NetCoreRmemDefault *int32

	// Sysctl setting net.core.rmem_max.
	NetCoreRmemMax *int32

	// Sysctl setting net.core.somaxconn.
	NetCoreSomaxconn *int32

	// Sysctl setting net.core.wmem_default.
	NetCoreWmemDefault *int32

	// Sysctl setting net.core.wmem_max.
	NetCoreWmemMax *int32

	// Sysctl setting net.ipv4.iplocalport_range.
	NetIPv4IPLocalPortRange *string

	// Sysctl setting net.ipv4.neigh.default.gc_thresh1.
	NetIPv4NeighDefaultGcThresh1 *int32

	// Sysctl setting net.ipv4.neigh.default.gc_thresh2.
	NetIPv4NeighDefaultGcThresh2 *int32

	// Sysctl setting net.ipv4.neigh.default.gc_thresh3.
	NetIPv4NeighDefaultGcThresh3 *int32

	// Sysctl setting net.ipv4.tcpfintimeout.
	NetIPv4TCPFinTimeout *int32

	// Sysctl setting net.ipv4.tcpkeepaliveprobes.
	NetIPv4TCPKeepaliveProbes *int32

	// Sysctl setting net.ipv4.tcpkeepalivetime.
	NetIPv4TCPKeepaliveTime *int32

	// Sysctl setting net.ipv4.tcpmaxsyn_backlog.
	NetIPv4TCPMaxSynBacklog *int32

	// Sysctl setting net.ipv4.tcpmaxtw_buckets.
	NetIPv4TCPMaxTwBuckets *int32

	// Sysctl setting net.ipv4.tcptwreuse.
	NetIPv4TCPTwReuse *bool

	// Sysctl setting net.ipv4.tcpkeepaliveintvl.
	NetIPv4TcpkeepaliveIntvl *int32

	// Sysctl setting net.netfilter.nfconntrackbuckets.
	NetNetfilterNfConntrackBuckets *int32

	// Sysctl setting net.netfilter.nfconntrackmax.
	NetNetfilterNfConntrackMax *int32

	// Sysctl setting vm.maxmapcount.
	VMMaxMapCount *int32

	// Sysctl setting vm.swappiness.
	VMSwappiness *int32

	// Sysctl setting vm.vfscachepressure.
	VMVfsCachePressure *int32
}

SysctlConfig - Sysctl settings for Linux agent nodes.

func (SysctlConfig) MarshalJSON 

func (s SysctlConfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SysctlConfig.

func (*SysctlConfig) UnmarshalJSON 

func (s *SysctlConfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SysctlConfig.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TagsObject 

type TagsObject struct {
	// Resource tags.
	Tags map[string]*string
}

TagsObject - Tags object for patch operations.

func (TagsObject) MarshalJSON 

func (t TagsObject) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagsObject.

func (*TagsObject) UnmarshalJSON 

func (t *TagsObject) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TagsObject.

type TimeInWeek 

type TimeInWeek struct {
	// The day of the week.
	Day *WeekDay

	// Each integer hour represents a time range beginning at 0m after the hour ending at the next hour (non-inclusive). 0 corresponds
	// to 00:00 UTC, 23 corresponds to 23:00 UTC. Specifying [0, 1] means the
	// 00:00 - 02:00 UTC time range.
	HourSlots []*int32
}

TimeInWeek - Time in a week.

func (TimeInWeek) MarshalJSON 

func (t TimeInWeek) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeInWeek.

func (*TimeInWeek) UnmarshalJSON 

func (t *TimeInWeek) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TimeInWeek.

type TimeSpan 

type TimeSpan struct {
	// The end of a time span
	End *time.Time

	// The start of a time span
	Start *time.Time
}

TimeSpan - For example, between 2021-05-25T13:00:00Z and 2021-05-25T14:00:00Z.

func (TimeSpan) MarshalJSON 

func (t TimeSpan) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeSpan.

func (*TimeSpan) UnmarshalJSON 

func (t *TimeSpan) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TimeSpan.

type TrustedAccessRole 

type TrustedAccessRole struct {
	// READ-ONLY; Name of role, name is unique under a source resource type
	Name *string

	// READ-ONLY; List of rules for the role. This maps to 'rules' property of Kubernetes Cluster Role [https://kubernetes.io/docs/reference/kubernetes-api/authorization-resources/cluster-role-v1/#ClusterRole].
	Rules []*TrustedAccessRoleRule

	// READ-ONLY; Resource type of Azure resource
	SourceResourceType *string
}

TrustedAccessRole - Trusted access role definition.

func (TrustedAccessRole) MarshalJSON 

func (t TrustedAccessRole) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRole.

func (*TrustedAccessRole) UnmarshalJSON 

func (t *TrustedAccessRole) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRole.

type TrustedAccessRoleBinding 

type TrustedAccessRoleBinding struct {
	// REQUIRED; Properties for trusted access role binding
	Properties *TrustedAccessRoleBindingProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

TrustedAccessRoleBinding - Defines binding between a resource and role

func (TrustedAccessRoleBinding) MarshalJSON 

func (t TrustedAccessRoleBinding) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRoleBinding.

func (*TrustedAccessRoleBinding) UnmarshalJSON 

func (t *TrustedAccessRoleBinding) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRoleBinding.

type TrustedAccessRoleBindingListResult 

type TrustedAccessRoleBindingListResult struct {
	// Role binding list
	Value []*TrustedAccessRoleBinding

	// READ-ONLY; Link to next page of resources.
	NextLink *string
}

TrustedAccessRoleBindingListResult - List of trusted access role bindings

func (TrustedAccessRoleBindingListResult) MarshalJSON 

func (t TrustedAccessRoleBindingListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRoleBindingListResult.

func (*TrustedAccessRoleBindingListResult) UnmarshalJSON 

func (t *TrustedAccessRoleBindingListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRoleBindingListResult.

type TrustedAccessRoleBindingProperties 

type TrustedAccessRoleBindingProperties struct {
	// REQUIRED; A list of roles to bind, each item is a resource type qualified role name. For example: 'Microsoft.MachineLearningServices/workspaces/reader'.
	Roles []*string

	// REQUIRED; The ARM resource ID of source resource that trusted access is configured for.
	SourceResourceID *string

	// READ-ONLY; The current provisioning state of trusted access role binding.
	ProvisioningState *TrustedAccessRoleBindingProvisioningState
}

TrustedAccessRoleBindingProperties - Properties for trusted access role binding

func (TrustedAccessRoleBindingProperties) MarshalJSON 

func (t TrustedAccessRoleBindingProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRoleBindingProperties.

func (*TrustedAccessRoleBindingProperties) UnmarshalJSON 

func (t *TrustedAccessRoleBindingProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRoleBindingProperties.

type TrustedAccessRoleBindingProvisioningState 

type TrustedAccessRoleBindingProvisioningState string

TrustedAccessRoleBindingProvisioningState - The current provisioning state of trusted access role binding. 

const (
	TrustedAccessRoleBindingProvisioningStateCanceled  TrustedAccessRoleBindingProvisioningState = "Canceled"
	TrustedAccessRoleBindingProvisioningStateDeleting  TrustedAccessRoleBindingProvisioningState = "Deleting"
	TrustedAccessRoleBindingProvisioningStateFailed    TrustedAccessRoleBindingProvisioningState = "Failed"
	TrustedAccessRoleBindingProvisioningStateSucceeded TrustedAccessRoleBindingProvisioningState = "Succeeded"
	TrustedAccessRoleBindingProvisioningStateUpdating  TrustedAccessRoleBindingProvisioningState = "Updating"
)

func PossibleTrustedAccessRoleBindingProvisioningStateValues 

func PossibleTrustedAccessRoleBindingProvisioningStateValues() []TrustedAccessRoleBindingProvisioningState

PossibleTrustedAccessRoleBindingProvisioningStateValues returns the possible values for the TrustedAccessRoleBindingProvisioningState const type.

type TrustedAccessRoleBindingsClient 

type TrustedAccessRoleBindingsClient struct {
	// contains filtered or unexported fields
}

TrustedAccessRoleBindingsClient contains the methods for the TrustedAccessRoleBindings group. Don't use this type directly, use NewTrustedAccessRoleBindingsClient() instead.

func NewTrustedAccessRoleBindingsClient 

func NewTrustedAccessRoleBindingsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*TrustedAccessRoleBindingsClient, error)

NewTrustedAccessRoleBindingsClient creates a new instance of TrustedAccessRoleBindingsClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*TrustedAccessRoleBindingsClient) BeginCreateOrUpdate 

func (client *TrustedAccessRoleBindingsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, trustedAccessRoleBindingName string, trustedAccessRoleBinding TrustedAccessRoleBinding, options *TrustedAccessRoleBindingsClientBeginCreateOrUpdateOptions) (*runtime.Poller[TrustedAccessRoleBindingsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create or update a trusted access role binding If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • trustedAccessRoleBindingName - The name of trusted access role binding.
  • trustedAccessRoleBinding - A trusted access role binding
  • options - TrustedAccessRoleBindingsClientBeginCreateOrUpdateOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.BeginCreateOrUpdate method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/TrustedAccessRoleBindings_CreateOrUpdate.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTrustedAccessRoleBindingsClient().BeginCreateOrUpdate(ctx, "rg1", "clustername1", "binding1", armcontainerservice.TrustedAccessRoleBinding{
	Properties: &armcontainerservice.TrustedAccessRoleBindingProperties{
		Roles: []*string{
			to.Ptr("Microsoft.MachineLearningServices/workspaces/reader"),
			to.Ptr("Microsoft.MachineLearningServices/workspaces/writer")},
		SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/b/providers/Microsoft.MachineLearningServices/workspaces/c"),
	},
}, 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.TrustedAccessRoleBinding = armcontainerservice.TrustedAccessRoleBinding{
// 	Name: to.Ptr("binding1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/trustedAccessRoleBindings"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/trustedAccessRoleBindings/binding1"),
// 	Properties: &armcontainerservice.TrustedAccessRoleBindingProperties{
// 		Roles: []*string{
// 			to.Ptr("Microsoft.MachineLearningServices/workspaces/reader"),
// 			to.Ptr("Microsoft.MachineLearningServices/workspaces/writer")},
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/b/providers/Microsoft.MachineLearningServices/workspaces/c"),
// 		},
// 	}

Output:

func (*TrustedAccessRoleBindingsClient) BeginDelete 

func (client *TrustedAccessRoleBindingsClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, trustedAccessRoleBindingName string, options *TrustedAccessRoleBindingsClientBeginDeleteOptions) (*runtime.Poller[TrustedAccessRoleBindingsClientDeleteResponse], error)

BeginDelete - Delete a trusted access role binding. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • trustedAccessRoleBindingName - The name of trusted access role binding.
  • options - TrustedAccessRoleBindingsClientBeginDeleteOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.BeginDelete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/TrustedAccessRoleBindings_Delete.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewTrustedAccessRoleBindingsClient().BeginDelete(ctx, "rg1", "clustername1", "binding1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %v", err)
}
_, err = poller.PollUntilDone(ctx, nil)
if err != nil {
	log.Fatalf("failed to pull the result: %v", err)
}

Output:

func (*TrustedAccessRoleBindingsClient) Get 

func (client *TrustedAccessRoleBindingsClient) Get(ctx context.Context, resourceGroupName string, resourceName string, trustedAccessRoleBindingName string, options *TrustedAccessRoleBindingsClientGetOptions) (TrustedAccessRoleBindingsClientGetResponse, error)

Get - Get a trusted access role binding. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • trustedAccessRoleBindingName - The name of trusted access role binding.
  • options - TrustedAccessRoleBindingsClientGetOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/TrustedAccessRoleBindings_Get.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
res, err := clientFactory.NewTrustedAccessRoleBindingsClient().Get(ctx, "rg1", "clustername1", "binding1", nil)
if err != nil {
	log.Fatalf("failed to finish the request: %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.TrustedAccessRoleBinding = armcontainerservice.TrustedAccessRoleBinding{
// 	Name: to.Ptr("binding1"),
// 	Type: to.Ptr("Microsoft.ContainerService/managedClusters/trustedAccessRoleBindings"),
// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/trustedAccessRoleBindings/binding1"),
// 	Properties: &armcontainerservice.TrustedAccessRoleBindingProperties{
// 		Roles: []*string{
// 			to.Ptr("Microsoft.MachineLearningServices/workspaces/reader"),
// 			to.Ptr("Microsoft.MachineLearningServices/workspaces/writer")},
// 			SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/b/providers/Microsoft.MachineLearningServices/workspaces/c"),
// 		},
// 	}

Output:

func (*TrustedAccessRoleBindingsClient) NewListPager 

func (client *TrustedAccessRoleBindingsClient) NewListPager(resourceGroupName string, resourceName string, options *TrustedAccessRoleBindingsClientListOptions) *runtime.Pager[TrustedAccessRoleBindingsClientListResponse]

NewListPager - List trusted access role bindings.

Generated from API version 2024-09-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • resourceName - The name of the managed cluster resource.
  • options - TrustedAccessRoleBindingsClientListOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/TrustedAccessRoleBindings_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewTrustedAccessRoleBindingsClient().NewListPager("rg1", "clustername1", 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.TrustedAccessRoleBindingListResult = armcontainerservice.TrustedAccessRoleBindingListResult{
	// 	Value: []*armcontainerservice.TrustedAccessRoleBinding{
	// 		{
	// 			Name: to.Ptr("binding1"),
	// 			Type: to.Ptr("Microsoft.ContainerService/managedClusters/trustedAccessRoleBindings"),
	// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/clustername1/trustedAccessRoleBindings/binding1"),
	// 			Properties: &armcontainerservice.TrustedAccessRoleBindingProperties{
	// 				Roles: []*string{
	// 					to.Ptr("Microsoft.MachineLearningServices/workspaces/reader"),
	// 					to.Ptr("Microsoft.MachineLearningServices/workspaces/writer")},
	// 					SourceResourceID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/b/providers/Microsoft.MachineLearningServices/workspaces/c"),
	// 				},
	// 		}},
	// 	}
}

Output:

type TrustedAccessRoleBindingsClientBeginCreateOrUpdateOptions 

type TrustedAccessRoleBindingsClientBeginCreateOrUpdateOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

TrustedAccessRoleBindingsClientBeginCreateOrUpdateOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.BeginCreateOrUpdate method.

type TrustedAccessRoleBindingsClientBeginDeleteOptions 

type TrustedAccessRoleBindingsClientBeginDeleteOptions struct {
	// Resumes the LRO from the provided token.
	ResumeToken string
}

TrustedAccessRoleBindingsClientBeginDeleteOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.BeginDelete method.

type TrustedAccessRoleBindingsClientCreateOrUpdateResponse 

type TrustedAccessRoleBindingsClientCreateOrUpdateResponse struct {
	// Defines binding between a resource and role
	TrustedAccessRoleBinding
}

TrustedAccessRoleBindingsClientCreateOrUpdateResponse contains the response from method TrustedAccessRoleBindingsClient.BeginCreateOrUpdate.

type TrustedAccessRoleBindingsClientDeleteResponse 

type TrustedAccessRoleBindingsClientDeleteResponse struct {
}

TrustedAccessRoleBindingsClientDeleteResponse contains the response from method TrustedAccessRoleBindingsClient.BeginDelete.

type TrustedAccessRoleBindingsClientGetOptions 

type TrustedAccessRoleBindingsClientGetOptions struct {
}

TrustedAccessRoleBindingsClientGetOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.Get method.

type TrustedAccessRoleBindingsClientGetResponse 

type TrustedAccessRoleBindingsClientGetResponse struct {
	// Defines binding between a resource and role
	TrustedAccessRoleBinding
}

TrustedAccessRoleBindingsClientGetResponse contains the response from method TrustedAccessRoleBindingsClient.Get.

type TrustedAccessRoleBindingsClientListOptions 

type TrustedAccessRoleBindingsClientListOptions struct {
}

TrustedAccessRoleBindingsClientListOptions contains the optional parameters for the TrustedAccessRoleBindingsClient.NewListPager method.

type TrustedAccessRoleBindingsClientListResponse 

type TrustedAccessRoleBindingsClientListResponse struct {
	// List of trusted access role bindings
	TrustedAccessRoleBindingListResult
}

TrustedAccessRoleBindingsClientListResponse contains the response from method TrustedAccessRoleBindingsClient.NewListPager.

type TrustedAccessRoleListResult 

type TrustedAccessRoleListResult struct {
	// READ-ONLY; Link to next page of resources.
	NextLink *string

	// READ-ONLY; Role list
	Value []*TrustedAccessRole
}

TrustedAccessRoleListResult - List of trusted access roles

func (TrustedAccessRoleListResult) MarshalJSON 

func (t TrustedAccessRoleListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRoleListResult.

func (*TrustedAccessRoleListResult) UnmarshalJSON 

func (t *TrustedAccessRoleListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRoleListResult.

type TrustedAccessRoleRule 

type TrustedAccessRoleRule struct {
	// READ-ONLY; List of allowed apiGroups
	APIGroups []*string

	// READ-ONLY; List of allowed nonResourceURLs
	NonResourceURLs []*string

	// READ-ONLY; List of allowed names
	ResourceNames []*string

	// READ-ONLY; List of allowed resources
	Resources []*string

	// READ-ONLY; List of allowed verbs
	Verbs []*string
}

TrustedAccessRoleRule - Rule for trusted access role

func (TrustedAccessRoleRule) MarshalJSON 

func (t TrustedAccessRoleRule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrustedAccessRoleRule.

func (*TrustedAccessRoleRule) UnmarshalJSON 

func (t *TrustedAccessRoleRule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TrustedAccessRoleRule.

type TrustedAccessRolesClient 

type TrustedAccessRolesClient struct {
	// contains filtered or unexported fields
}

TrustedAccessRolesClient contains the methods for the TrustedAccessRoles group. Don't use this type directly, use NewTrustedAccessRolesClient() instead.

func NewTrustedAccessRolesClient 

func NewTrustedAccessRolesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*TrustedAccessRolesClient, error)

NewTrustedAccessRolesClient creates a new instance of TrustedAccessRolesClient with the specified values.

  • subscriptionID - The ID of the target subscription. The value must be an UUID.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*TrustedAccessRolesClient) NewListPager 

func (client *TrustedAccessRolesClient) NewListPager(location string, options *TrustedAccessRolesClientListOptions) *runtime.Pager[TrustedAccessRolesClientListResponse]

NewListPager - List supported trusted access roles.

Generated from API version 2024-09-01

  • location - The name of the Azure region.
  • options - TrustedAccessRolesClientListOptions contains the optional parameters for the TrustedAccessRolesClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e838027e88cca634c1545e744630de9262a6e72a/specification/containerservice/resource-manager/Microsoft.ContainerService/aks/stable/2024-09-01/examples/TrustedAccessRoles_List.json 

cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
	log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armcontainerservice.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
	log.Fatalf("failed to create client: %v", err)
}
pager := clientFactory.NewTrustedAccessRolesClient().NewListPager("westus2", 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.TrustedAccessRoleListResult = armcontainerservice.TrustedAccessRoleListResult{
	// 	Value: []*armcontainerservice.TrustedAccessRole{
	// 		{
	// 			Name: to.Ptr("reader"),
	// 			Rules: []*armcontainerservice.TrustedAccessRoleRule{
	// 				{
	// 					APIGroups: []*string{
	// 						to.Ptr("")},
	// 						NonResourceURLs: []*string{
	// 						},
	// 						ResourceNames: []*string{
	// 						},
	// 						Resources: []*string{
	// 							to.Ptr("pods")},
	// 							Verbs: []*string{
	// 								to.Ptr("get")},
	// 						}},
	// 						SourceResourceType: to.Ptr("Microsoft.MachineLearningServices/workspaces"),
	// 				}},
	// 			}
}

Output:

type TrustedAccessRolesClientListOptions 

type TrustedAccessRolesClientListOptions struct {
}

TrustedAccessRolesClientListOptions contains the optional parameters for the TrustedAccessRolesClient.NewListPager method.

type TrustedAccessRolesClientListResponse 

type TrustedAccessRolesClientListResponse struct {
	// List of trusted access roles
	TrustedAccessRoleListResult
}

TrustedAccessRolesClientListResponse contains the response from method TrustedAccessRolesClient.NewListPager.

type Type 

type Type string

Type - Specifies on which week of the month the dayOfWeek applies. 

const (
	// TypeFirst - First week of the month.
	TypeFirst Type = "First"
	// TypeFourth - Fourth week of the month.
	TypeFourth Type = "Fourth"
	// TypeLast - Last week of the month.
	TypeLast Type = "Last"
	// TypeSecond - Second week of the month.
	TypeSecond Type = "Second"
	// TypeThird - Third week of the month.
	TypeThird Type = "Third"
)

func PossibleTypeValues 

func PossibleTypeValues() []Type

PossibleTypeValues returns the possible values for the Type const type.

type UpgradeChannel 

type UpgradeChannel string

UpgradeChannel - For more information see setting the AKS cluster auto-upgrade channel [https://docs.microsoft.com/azure/aks/upgrade-cluster#set-auto-upgrade-channel]. 

const (
	// UpgradeChannelNodeImage - Automatically upgrade the node image to the latest version available. Consider using nodeOSUpgradeChannel
	// instead as that allows you to configure node OS patching separate from Kubernetes version patching
	UpgradeChannelNodeImage UpgradeChannel = "node-image"
	// UpgradeChannelNone - Disables auto-upgrades and keeps the cluster at its current version of Kubernetes.
	UpgradeChannelNone UpgradeChannel = "none"
	// UpgradeChannelPatch - Automatically upgrade the cluster to the latest supported patch version when it becomes available
	// while keeping the minor version the same. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4,
	// 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.17.9.
	UpgradeChannelPatch UpgradeChannel = "patch"
	// UpgradeChannelRapid - Automatically upgrade the cluster to the latest supported patch release on the latest supported minor
	// version. In cases where the cluster is at a version of Kubernetes that is at an N-2 minor version where N is the latest
	// supported minor version, the cluster first upgrades to the latest supported patch version on N-1 minor version. For example,
	// if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4, 1.18.6, and 1.19.1 are available, your cluster first
	// is upgraded to 1.18.6, then is upgraded to 1.19.1.
	UpgradeChannelRapid UpgradeChannel = "rapid"
	// UpgradeChannelStable - Automatically upgrade the cluster to the latest supported patch release on minor version N-1, where
	// N is the latest supported minor version. For example, if a cluster is running version 1.17.7 and versions 1.17.9, 1.18.4,
	// 1.18.6, and 1.19.1 are available, your cluster is upgraded to 1.18.6.
	UpgradeChannelStable UpgradeChannel = "stable"
)

func PossibleUpgradeChannelValues 

func PossibleUpgradeChannelValues() []UpgradeChannel

PossibleUpgradeChannelValues returns the possible values for the UpgradeChannel const type.

type UpgradeOverrideSettings 

type UpgradeOverrideSettings struct {
	// Whether to force upgrade the cluster. Note that this option instructs upgrade operation to bypass upgrade protections such
	// as checking for deprecated API usage. Enable this option only with caution.
	ForceUpgrade *bool

	// Until when the overrides are effective. Note that this only matches the start time of an upgrade, and the effectiveness
	// won't change once an upgrade starts even if the until expires as upgrade
	// proceeds. This field is not set by default. It must be set for the overrides to take effect.
	Until *time.Time
}

UpgradeOverrideSettings - Settings for overrides when upgrading a cluster.

func (UpgradeOverrideSettings) MarshalJSON 

func (u UpgradeOverrideSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UpgradeOverrideSettings.

func (*UpgradeOverrideSettings) UnmarshalJSON 

func (u *UpgradeOverrideSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeOverrideSettings.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// The client ID of the user assigned identity.
	ClientID *string

	// The object ID of the user assigned identity.
	ObjectID *string

	// The resource ID of the user assigned identity.
	ResourceID *string
}

UserAssignedIdentity - Details about a user assigned identity.

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type WeekDay 

type WeekDay string

WeekDay - The weekday enum. 

const (
	WeekDayFriday    WeekDay = "Friday"
	WeekDayMonday    WeekDay = "Monday"
	WeekDaySaturday  WeekDay = "Saturday"
	WeekDaySunday    WeekDay = "Sunday"
	WeekDayThursday  WeekDay = "Thursday"
	WeekDayTuesday   WeekDay = "Tuesday"
	WeekDayWednesday WeekDay = "Wednesday"
)

func PossibleWeekDayValues 

func PossibleWeekDayValues() []WeekDay

PossibleWeekDayValues returns the possible values for the WeekDay const type.

type WeeklySchedule 

type WeeklySchedule struct {
	// REQUIRED; Specifies on which day of the week the maintenance occurs.
	DayOfWeek *WeekDay

	// REQUIRED; Specifies the number of weeks between each set of occurrences.
	IntervalWeeks *int32
}

WeeklySchedule - For schedules like: 'recur every Monday' or 'recur every 3 weeks on Wednesday'.

func (WeeklySchedule) MarshalJSON 

func (w WeeklySchedule) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WeeklySchedule.

func (*WeeklySchedule) UnmarshalJSON 

func (w *WeeklySchedule) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WeeklySchedule.

type WindowsGmsaProfile 

type WindowsGmsaProfile struct {
	// Specifies the DNS server for Windows gMSA.
	// Set it to empty if you have configured the DNS server in the vnet which is used to create the managed cluster.
	DNSServer *string

	// Specifies whether to enable Windows gMSA in the managed cluster.
	Enabled *bool

	// Specifies the root domain name for Windows gMSA.
	// Set it to empty if you have configured the DNS server in the vnet which is used to create the managed cluster.
	RootDomainName *string
}

WindowsGmsaProfile - Windows gMSA Profile in the managed cluster.

func (WindowsGmsaProfile) MarshalJSON 

func (w WindowsGmsaProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WindowsGmsaProfile.

func (*WindowsGmsaProfile) UnmarshalJSON 

func (w *WindowsGmsaProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WindowsGmsaProfile.

type WorkloadRuntime 

type WorkloadRuntime string

WorkloadRuntime - Determines the type of workload a node can run. 

const (
	// WorkloadRuntimeOCIContainer - Nodes will use Kubelet to run standard OCI container workloads.
	WorkloadRuntimeOCIContainer WorkloadRuntime = "OCIContainer"
	// WorkloadRuntimeWasmWasi - Nodes will use Krustlet to run WASM workloads using the WASI provider (Preview).
	WorkloadRuntimeWasmWasi WorkloadRuntime = "WasmWasi"
)

func PossibleWorkloadRuntimeValues 

func PossibleWorkloadRuntimeValues() []WorkloadRuntime

PossibleWorkloadRuntimeValues returns the possible values for the WorkloadRuntime const type.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.