armcontainerservice

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: May 16, 2022 License: MIT Imports: 16 Imported by: 26

README

Azure Container Service Module for Go

PkgGoDev

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

Source code

Getting started

Prerequisites

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

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.

Clients

Azure Container Service modules consist of one or more clients. A client groups a set of related APIs, providing access to its functionality within the specified subscription. Create one or more clients to access the APIs you require using your credential.

client, err := armcontainerservice.NewSnapshotsClient(<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,
    },
}
client, err := armcontainerservice.NewSnapshotsClient(<subscription ID>, cred, &options)

More sample code

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 AccessProfile 

type AccessProfile struct {
	// Base64-encoded Kubernetes configuration file.
	KubeConfig []byte `json:"kubeConfig,omitempty"`
}

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 AgentPool 

type AgentPool struct {
	// Properties of an agent pool.
	Properties *ManagedClusterAgentPoolProfileProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// 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 `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

AgentPool - Agent Pool.

type AgentPoolAvailableVersions 

type AgentPoolAvailableVersions struct {
	// REQUIRED; Properties of agent pool available versions.
	Properties *AgentPoolAvailableVersionsProperties `json:"properties,omitempty"`

	// READ-ONLY; The ID of the agent pool version list.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the agent pool version list.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Type of the agent pool version list.
	Type *string `json:"type,omitempty" azure:"ro"`
}

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

type AgentPoolAvailableVersionsProperties 

type AgentPoolAvailableVersionsProperties struct {
	// List of versions available for agent pool.
	AgentPoolVersions []*AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem `json:"agentPoolVersions,omitempty"`
}

AgentPoolAvailableVersionsProperties - The list of available agent pool versions.

type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem 

type AgentPoolAvailableVersionsPropertiesAgentPoolVersionsItem struct {
	// Whether this version is the default agent pool version.
	Default *bool `json:"default,omitempty"`

	// Whether Kubernetes version is currently in preview.
	IsPreview *bool `json:"isPreview,omitempty"`

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string `json:"kubernetesVersion,omitempty"`
}

type AgentPoolListResult 

type AgentPoolListResult struct {
	// The list of agent pools.
	Value []*AgentPool `json:"value,omitempty"`

	// READ-ONLY; The URL to get the next set of agent pool results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

AgentPoolListResult - The response from the List Agent Pools operation.

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 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 `json:"properties,omitempty"`

	// READ-ONLY; The ID of the agent pool upgrade profile.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the agent pool upgrade profile.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the agent pool upgrade profile.
	Type *string `json:"type,omitempty" azure:"ro"`
}

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

type AgentPoolUpgradeProfileProperties 

type AgentPoolUpgradeProfileProperties struct {
	// REQUIRED; The Kubernetes version (major.minor.patch).
	KubernetesVersion *string `json:"kubernetesVersion,omitempty"`

	// REQUIRED; The operating system type. The default is Linux.
	OSType *OSType `json:"osType,omitempty"`

	// The latest AKS supported node image version.
	LatestNodeImageVersion *string `json:"latestNodeImageVersion,omitempty"`

	// List of orchestrator types and versions available for upgrade.
	Upgrades []*AgentPoolUpgradeProfilePropertiesUpgradesItem `json:"upgrades,omitempty"`
}

AgentPoolUpgradeProfileProperties - The list of available upgrade versions.

type AgentPoolUpgradeProfilePropertiesUpgradesItem 

type AgentPoolUpgradeProfilePropertiesUpgradesItem struct {
	// Whether the Kubernetes version is currently in preview.
	IsPreview *bool `json:"isPreview,omitempty"`

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string `json:"kubernetesVersion,omitempty"`
}

type AgentPoolUpgradeSettings 

type AgentPoolUpgradeSettings struct {
	// 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 `json:"maxSurge,omitempty"`
}

AgentPoolUpgradeSettings - Settings for upgrading an agentpool

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. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsCreate_Snapshot.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreateOrUpdate(ctx,
		"rg1",
		"clustername1",
		"agentpool1",
		armcontainerservice.AgentPool{
			Properties: &armcontainerservice.ManagedClusterAgentPoolProfileProperties{
				Count: to.Ptr[int32](3),
				CreationData: &armcontainerservice.CreationData{
					SourceResourceID: to.Ptr("/subscriptions/subid1/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"),
			},
		},
		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)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(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) 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsUpgradeNodeImageVersion.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"clustername1",
		"agentpool1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsGetAgentPoolAvailableVersions.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetAvailableAgentPoolVersions(ctx,
		"rg1",
		"clustername1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsGetUpgradeProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetUpgradeProfile(ctx,
		"rg1",
		"clustername1",
		"agentpool1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*AgentPoolsClient) NewListPager added in v0.5.0 

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. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-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.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/AgentPoolsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewAgentPoolsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager("rg1",
		"clustername1",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

type AgentPoolsClientBeginCreateOrUpdateOptions added in v0.3.0 

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

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

type AgentPoolsClientBeginDeleteOptions added in v0.3.0 

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

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

type AgentPoolsClientBeginUpgradeNodeImageVersionOptions added in v0.3.0 

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

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

type AgentPoolsClientCreateOrUpdateResponse added in v0.3.0 

type AgentPoolsClientCreateOrUpdateResponse struct {
	AgentPool
}

AgentPoolsClientCreateOrUpdateResponse contains the response from method AgentPoolsClient.CreateOrUpdate.

type AgentPoolsClientDeleteResponse added in v0.3.0 

type AgentPoolsClientDeleteResponse struct {
}

AgentPoolsClientDeleteResponse contains the response from method AgentPoolsClient.Delete.

type AgentPoolsClientGetAvailableAgentPoolVersionsOptions added in v0.3.0 

type AgentPoolsClientGetAvailableAgentPoolVersionsOptions struct {
}

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

type AgentPoolsClientGetAvailableAgentPoolVersionsResponse added in v0.3.0 

type AgentPoolsClientGetAvailableAgentPoolVersionsResponse struct {
	AgentPoolAvailableVersions
}

AgentPoolsClientGetAvailableAgentPoolVersionsResponse contains the response from method AgentPoolsClient.GetAvailableAgentPoolVersions.

type AgentPoolsClientGetOptions added in v0.3.0 

type AgentPoolsClientGetOptions struct {
}

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

type AgentPoolsClientGetResponse added in v0.3.0 

type AgentPoolsClientGetResponse struct {
	AgentPool
}

AgentPoolsClientGetResponse contains the response from method AgentPoolsClient.Get.

type AgentPoolsClientGetUpgradeProfileOptions added in v0.3.0 

type AgentPoolsClientGetUpgradeProfileOptions struct {
}

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

type AgentPoolsClientGetUpgradeProfileResponse added in v0.3.0 

type AgentPoolsClientGetUpgradeProfileResponse struct {
	AgentPoolUpgradeProfile
}

AgentPoolsClientGetUpgradeProfileResponse contains the response from method AgentPoolsClient.GetUpgradeProfile.

type AgentPoolsClientListOptions added in v0.3.0 

type AgentPoolsClientListOptions struct {
}

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

type AgentPoolsClientListResponse added in v0.3.0 

type AgentPoolsClientListResponse struct {
	AgentPoolListResult
}

AgentPoolsClientListResponse contains the response from method AgentPoolsClient.List.

type AgentPoolsClientUpgradeNodeImageVersionResponse added in v0.3.0 

type AgentPoolsClientUpgradeNodeImageVersionResponse struct {
	AgentPool
}

AgentPoolsClientUpgradeNodeImageVersionResponse contains the response from method AgentPoolsClient.UpgradeNodeImageVersion.

type CloudError 

type CloudError struct {
	// Details about the error.
	Error *CloudErrorBody `json:"error,omitempty"`
}

CloudError - An error response from the Container service.

type CloudErrorBody 

type CloudErrorBody struct {
	// An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
	Code *string `json:"code,omitempty"`

	// A list of additional details about the error.
	Details []*CloudErrorBody `json:"details,omitempty"`

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

	// The target of the particular error. For example, the name of the property in error.
	Target *string `json:"target,omitempty"`
}

CloudErrorBody - An error response from the Container service.

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 `json:"exitCode,omitempty" azure:"ro"`

	// READ-ONLY; The time when the command finished.
	FinishedAt *time.Time `json:"finishedAt,omitempty" azure:"ro"`

	// READ-ONLY; The command output.
	Logs *string `json:"logs,omitempty" azure:"ro"`

	// READ-ONLY; provisioning State
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; An explanation of why provisioningState is set to failed (if so).
	Reason *string `json:"reason,omitempty" azure:"ro"`

	// READ-ONLY; The time when the command started.
	StartedAt *time.Time `json:"startedAt,omitempty" azure:"ro"`
}

CommandResultProperties - The results of a run command

func (*CommandResultProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CommandResultProperties.

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 ContainerServiceStorageProfileTypes 

type ContainerServiceStorageProfileTypes string

ContainerServiceStorageProfileTypes - Specifies what kind of storage to use. If omitted, the default will be chosen on your behalf based on the choice of orchestrator. 

const (
	ContainerServiceStorageProfileTypesManagedDisks   ContainerServiceStorageProfileTypes = "ManagedDisks"
	ContainerServiceStorageProfileTypesStorageAccount ContainerServiceStorageProfileTypes = "StorageAccount"
)

func PossibleContainerServiceStorageProfileTypesValues 

func PossibleContainerServiceStorageProfileTypesValues() []ContainerServiceStorageProfileTypes

PossibleContainerServiceStorageProfileTypesValues returns the possible values for the ContainerServiceStorageProfileTypes const type.

type ContainerServiceVMSizeTypes 

type ContainerServiceVMSizeTypes string

ContainerServiceVMSizeTypes - Size of agent VMs. Note: This is no longer maintained. 

const (
	ContainerServiceVMSizeTypesStandardA1          ContainerServiceVMSizeTypes = "Standard_A1"
	ContainerServiceVMSizeTypesStandardA10         ContainerServiceVMSizeTypes = "Standard_A10"
	ContainerServiceVMSizeTypesStandardA11         ContainerServiceVMSizeTypes = "Standard_A11"
	ContainerServiceVMSizeTypesStandardA1V2        ContainerServiceVMSizeTypes = "Standard_A1_v2"
	ContainerServiceVMSizeTypesStandardA2          ContainerServiceVMSizeTypes = "Standard_A2"
	ContainerServiceVMSizeTypesStandardA2MV2       ContainerServiceVMSizeTypes = "Standard_A2m_v2"
	ContainerServiceVMSizeTypesStandardA2V2        ContainerServiceVMSizeTypes = "Standard_A2_v2"
	ContainerServiceVMSizeTypesStandardA3          ContainerServiceVMSizeTypes = "Standard_A3"
	ContainerServiceVMSizeTypesStandardA4          ContainerServiceVMSizeTypes = "Standard_A4"
	ContainerServiceVMSizeTypesStandardA4MV2       ContainerServiceVMSizeTypes = "Standard_A4m_v2"
	ContainerServiceVMSizeTypesStandardA4V2        ContainerServiceVMSizeTypes = "Standard_A4_v2"
	ContainerServiceVMSizeTypesStandardA5          ContainerServiceVMSizeTypes = "Standard_A5"
	ContainerServiceVMSizeTypesStandardA6          ContainerServiceVMSizeTypes = "Standard_A6"
	ContainerServiceVMSizeTypesStandardA7          ContainerServiceVMSizeTypes = "Standard_A7"
	ContainerServiceVMSizeTypesStandardA8          ContainerServiceVMSizeTypes = "Standard_A8"
	ContainerServiceVMSizeTypesStandardA8MV2       ContainerServiceVMSizeTypes = "Standard_A8m_v2"
	ContainerServiceVMSizeTypesStandardA8V2        ContainerServiceVMSizeTypes = "Standard_A8_v2"
	ContainerServiceVMSizeTypesStandardA9          ContainerServiceVMSizeTypes = "Standard_A9"
	ContainerServiceVMSizeTypesStandardB2Ms        ContainerServiceVMSizeTypes = "Standard_B2ms"
	ContainerServiceVMSizeTypesStandardB2S         ContainerServiceVMSizeTypes = "Standard_B2s"
	ContainerServiceVMSizeTypesStandardB4Ms        ContainerServiceVMSizeTypes = "Standard_B4ms"
	ContainerServiceVMSizeTypesStandardB8Ms        ContainerServiceVMSizeTypes = "Standard_B8ms"
	ContainerServiceVMSizeTypesStandardD1          ContainerServiceVMSizeTypes = "Standard_D1"
	ContainerServiceVMSizeTypesStandardD11         ContainerServiceVMSizeTypes = "Standard_D11"
	ContainerServiceVMSizeTypesStandardD11V2       ContainerServiceVMSizeTypes = "Standard_D11_v2"
	ContainerServiceVMSizeTypesStandardD11V2Promo  ContainerServiceVMSizeTypes = "Standard_D11_v2_Promo"
	ContainerServiceVMSizeTypesStandardD12         ContainerServiceVMSizeTypes = "Standard_D12"
	ContainerServiceVMSizeTypesStandardD12V2       ContainerServiceVMSizeTypes = "Standard_D12_v2"
	ContainerServiceVMSizeTypesStandardD12V2Promo  ContainerServiceVMSizeTypes = "Standard_D12_v2_Promo"
	ContainerServiceVMSizeTypesStandardD13         ContainerServiceVMSizeTypes = "Standard_D13"
	ContainerServiceVMSizeTypesStandardD13V2       ContainerServiceVMSizeTypes = "Standard_D13_v2"
	ContainerServiceVMSizeTypesStandardD13V2Promo  ContainerServiceVMSizeTypes = "Standard_D13_v2_Promo"
	ContainerServiceVMSizeTypesStandardD14         ContainerServiceVMSizeTypes = "Standard_D14"
	ContainerServiceVMSizeTypesStandardD14V2       ContainerServiceVMSizeTypes = "Standard_D14_v2"
	ContainerServiceVMSizeTypesStandardD14V2Promo  ContainerServiceVMSizeTypes = "Standard_D14_v2_Promo"
	ContainerServiceVMSizeTypesStandardD15V2       ContainerServiceVMSizeTypes = "Standard_D15_v2"
	ContainerServiceVMSizeTypesStandardD16SV3      ContainerServiceVMSizeTypes = "Standard_D16s_v3"
	ContainerServiceVMSizeTypesStandardD16V3       ContainerServiceVMSizeTypes = "Standard_D16_v3"
	ContainerServiceVMSizeTypesStandardD1V2        ContainerServiceVMSizeTypes = "Standard_D1_v2"
	ContainerServiceVMSizeTypesStandardD2          ContainerServiceVMSizeTypes = "Standard_D2"
	ContainerServiceVMSizeTypesStandardD2SV3       ContainerServiceVMSizeTypes = "Standard_D2s_v3"
	ContainerServiceVMSizeTypesStandardD2V2        ContainerServiceVMSizeTypes = "Standard_D2_v2"
	ContainerServiceVMSizeTypesStandardD2V2Promo   ContainerServiceVMSizeTypes = "Standard_D2_v2_Promo"
	ContainerServiceVMSizeTypesStandardD2V3        ContainerServiceVMSizeTypes = "Standard_D2_v3"
	ContainerServiceVMSizeTypesStandardD3          ContainerServiceVMSizeTypes = "Standard_D3"
	ContainerServiceVMSizeTypesStandardD32SV3      ContainerServiceVMSizeTypes = "Standard_D32s_v3"
	ContainerServiceVMSizeTypesStandardD32V3       ContainerServiceVMSizeTypes = "Standard_D32_v3"
	ContainerServiceVMSizeTypesStandardD3V2        ContainerServiceVMSizeTypes = "Standard_D3_v2"
	ContainerServiceVMSizeTypesStandardD3V2Promo   ContainerServiceVMSizeTypes = "Standard_D3_v2_Promo"
	ContainerServiceVMSizeTypesStandardD4          ContainerServiceVMSizeTypes = "Standard_D4"
	ContainerServiceVMSizeTypesStandardD4SV3       ContainerServiceVMSizeTypes = "Standard_D4s_v3"
	ContainerServiceVMSizeTypesStandardD4V2        ContainerServiceVMSizeTypes = "Standard_D4_v2"
	ContainerServiceVMSizeTypesStandardD4V2Promo   ContainerServiceVMSizeTypes = "Standard_D4_v2_Promo"
	ContainerServiceVMSizeTypesStandardD4V3        ContainerServiceVMSizeTypes = "Standard_D4_v3"
	ContainerServiceVMSizeTypesStandardD5V2        ContainerServiceVMSizeTypes = "Standard_D5_v2"
	ContainerServiceVMSizeTypesStandardD5V2Promo   ContainerServiceVMSizeTypes = "Standard_D5_v2_Promo"
	ContainerServiceVMSizeTypesStandardD64SV3      ContainerServiceVMSizeTypes = "Standard_D64s_v3"
	ContainerServiceVMSizeTypesStandardD64V3       ContainerServiceVMSizeTypes = "Standard_D64_v3"
	ContainerServiceVMSizeTypesStandardD8SV3       ContainerServiceVMSizeTypes = "Standard_D8s_v3"
	ContainerServiceVMSizeTypesStandardD8V3        ContainerServiceVMSizeTypes = "Standard_D8_v3"
	ContainerServiceVMSizeTypesStandardDS1         ContainerServiceVMSizeTypes = "Standard_DS1"
	ContainerServiceVMSizeTypesStandardDS11        ContainerServiceVMSizeTypes = "Standard_DS11"
	ContainerServiceVMSizeTypesStandardDS11V2      ContainerServiceVMSizeTypes = "Standard_DS11_v2"
	ContainerServiceVMSizeTypesStandardDS11V2Promo ContainerServiceVMSizeTypes = "Standard_DS11_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS12        ContainerServiceVMSizeTypes = "Standard_DS12"
	ContainerServiceVMSizeTypesStandardDS12V2      ContainerServiceVMSizeTypes = "Standard_DS12_v2"
	ContainerServiceVMSizeTypesStandardDS12V2Promo ContainerServiceVMSizeTypes = "Standard_DS12_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS13        ContainerServiceVMSizeTypes = "Standard_DS13"
	ContainerServiceVMSizeTypesStandardDS132V2     ContainerServiceVMSizeTypes = "Standard_DS13-2_v2"
	ContainerServiceVMSizeTypesStandardDS134V2     ContainerServiceVMSizeTypes = "Standard_DS13-4_v2"
	ContainerServiceVMSizeTypesStandardDS13V2      ContainerServiceVMSizeTypes = "Standard_DS13_v2"
	ContainerServiceVMSizeTypesStandardDS13V2Promo ContainerServiceVMSizeTypes = "Standard_DS13_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS14        ContainerServiceVMSizeTypes = "Standard_DS14"
	ContainerServiceVMSizeTypesStandardDS144V2     ContainerServiceVMSizeTypes = "Standard_DS14-4_v2"
	ContainerServiceVMSizeTypesStandardDS148V2     ContainerServiceVMSizeTypes = "Standard_DS14-8_v2"
	ContainerServiceVMSizeTypesStandardDS14V2      ContainerServiceVMSizeTypes = "Standard_DS14_v2"
	ContainerServiceVMSizeTypesStandardDS14V2Promo ContainerServiceVMSizeTypes = "Standard_DS14_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS15V2      ContainerServiceVMSizeTypes = "Standard_DS15_v2"
	ContainerServiceVMSizeTypesStandardDS1V2       ContainerServiceVMSizeTypes = "Standard_DS1_v2"
	ContainerServiceVMSizeTypesStandardDS2         ContainerServiceVMSizeTypes = "Standard_DS2"
	ContainerServiceVMSizeTypesStandardDS2V2       ContainerServiceVMSizeTypes = "Standard_DS2_v2"
	ContainerServiceVMSizeTypesStandardDS2V2Promo  ContainerServiceVMSizeTypes = "Standard_DS2_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS3         ContainerServiceVMSizeTypes = "Standard_DS3"
	ContainerServiceVMSizeTypesStandardDS3V2       ContainerServiceVMSizeTypes = "Standard_DS3_v2"
	ContainerServiceVMSizeTypesStandardDS3V2Promo  ContainerServiceVMSizeTypes = "Standard_DS3_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS4         ContainerServiceVMSizeTypes = "Standard_DS4"
	ContainerServiceVMSizeTypesStandardDS4V2       ContainerServiceVMSizeTypes = "Standard_DS4_v2"
	ContainerServiceVMSizeTypesStandardDS4V2Promo  ContainerServiceVMSizeTypes = "Standard_DS4_v2_Promo"
	ContainerServiceVMSizeTypesStandardDS5V2       ContainerServiceVMSizeTypes = "Standard_DS5_v2"
	ContainerServiceVMSizeTypesStandardDS5V2Promo  ContainerServiceVMSizeTypes = "Standard_DS5_v2_Promo"
	ContainerServiceVMSizeTypesStandardE16SV3      ContainerServiceVMSizeTypes = "Standard_E16s_v3"
	ContainerServiceVMSizeTypesStandardE16V3       ContainerServiceVMSizeTypes = "Standard_E16_v3"
	ContainerServiceVMSizeTypesStandardE2SV3       ContainerServiceVMSizeTypes = "Standard_E2s_v3"
	ContainerServiceVMSizeTypesStandardE2V3        ContainerServiceVMSizeTypes = "Standard_E2_v3"
	ContainerServiceVMSizeTypesStandardE3216SV3    ContainerServiceVMSizeTypes = "Standard_E32-16s_v3"
	ContainerServiceVMSizeTypesStandardE328SV3     ContainerServiceVMSizeTypes = "Standard_E32-8s_v3"
	ContainerServiceVMSizeTypesStandardE32SV3      ContainerServiceVMSizeTypes = "Standard_E32s_v3"
	ContainerServiceVMSizeTypesStandardE32V3       ContainerServiceVMSizeTypes = "Standard_E32_v3"
	ContainerServiceVMSizeTypesStandardE4SV3       ContainerServiceVMSizeTypes = "Standard_E4s_v3"
	ContainerServiceVMSizeTypesStandardE4V3        ContainerServiceVMSizeTypes = "Standard_E4_v3"
	ContainerServiceVMSizeTypesStandardE6416SV3    ContainerServiceVMSizeTypes = "Standard_E64-16s_v3"
	ContainerServiceVMSizeTypesStandardE6432SV3    ContainerServiceVMSizeTypes = "Standard_E64-32s_v3"
	ContainerServiceVMSizeTypesStandardE64SV3      ContainerServiceVMSizeTypes = "Standard_E64s_v3"
	ContainerServiceVMSizeTypesStandardE64V3       ContainerServiceVMSizeTypes = "Standard_E64_v3"
	ContainerServiceVMSizeTypesStandardE8SV3       ContainerServiceVMSizeTypes = "Standard_E8s_v3"
	ContainerServiceVMSizeTypesStandardE8V3        ContainerServiceVMSizeTypes = "Standard_E8_v3"
	ContainerServiceVMSizeTypesStandardF1          ContainerServiceVMSizeTypes = "Standard_F1"
	ContainerServiceVMSizeTypesStandardF16         ContainerServiceVMSizeTypes = "Standard_F16"
	ContainerServiceVMSizeTypesStandardF16S        ContainerServiceVMSizeTypes = "Standard_F16s"
	ContainerServiceVMSizeTypesStandardF16SV2      ContainerServiceVMSizeTypes = "Standard_F16s_v2"
	ContainerServiceVMSizeTypesStandardF1S         ContainerServiceVMSizeTypes = "Standard_F1s"
	ContainerServiceVMSizeTypesStandardF2          ContainerServiceVMSizeTypes = "Standard_F2"
	ContainerServiceVMSizeTypesStandardF2S         ContainerServiceVMSizeTypes = "Standard_F2s"
	ContainerServiceVMSizeTypesStandardF2SV2       ContainerServiceVMSizeTypes = "Standard_F2s_v2"
	ContainerServiceVMSizeTypesStandardF32SV2      ContainerServiceVMSizeTypes = "Standard_F32s_v2"
	ContainerServiceVMSizeTypesStandardF4          ContainerServiceVMSizeTypes = "Standard_F4"
	ContainerServiceVMSizeTypesStandardF4S         ContainerServiceVMSizeTypes = "Standard_F4s"
	ContainerServiceVMSizeTypesStandardF4SV2       ContainerServiceVMSizeTypes = "Standard_F4s_v2"
	ContainerServiceVMSizeTypesStandardF64SV2      ContainerServiceVMSizeTypes = "Standard_F64s_v2"
	ContainerServiceVMSizeTypesStandardF72SV2      ContainerServiceVMSizeTypes = "Standard_F72s_v2"
	ContainerServiceVMSizeTypesStandardF8          ContainerServiceVMSizeTypes = "Standard_F8"
	ContainerServiceVMSizeTypesStandardF8S         ContainerServiceVMSizeTypes = "Standard_F8s"
	ContainerServiceVMSizeTypesStandardF8SV2       ContainerServiceVMSizeTypes = "Standard_F8s_v2"
	ContainerServiceVMSizeTypesStandardG1          ContainerServiceVMSizeTypes = "Standard_G1"
	ContainerServiceVMSizeTypesStandardG2          ContainerServiceVMSizeTypes = "Standard_G2"
	ContainerServiceVMSizeTypesStandardG3          ContainerServiceVMSizeTypes = "Standard_G3"
	ContainerServiceVMSizeTypesStandardG4          ContainerServiceVMSizeTypes = "Standard_G4"
	ContainerServiceVMSizeTypesStandardG5          ContainerServiceVMSizeTypes = "Standard_G5"
	ContainerServiceVMSizeTypesStandardGS1         ContainerServiceVMSizeTypes = "Standard_GS1"
	ContainerServiceVMSizeTypesStandardGS2         ContainerServiceVMSizeTypes = "Standard_GS2"
	ContainerServiceVMSizeTypesStandardGS3         ContainerServiceVMSizeTypes = "Standard_GS3"
	ContainerServiceVMSizeTypesStandardGS4         ContainerServiceVMSizeTypes = "Standard_GS4"
	ContainerServiceVMSizeTypesStandardGS44        ContainerServiceVMSizeTypes = "Standard_GS4-4"
	ContainerServiceVMSizeTypesStandardGS48        ContainerServiceVMSizeTypes = "Standard_GS4-8"
	ContainerServiceVMSizeTypesStandardGS5         ContainerServiceVMSizeTypes = "Standard_GS5"
	ContainerServiceVMSizeTypesStandardGS516       ContainerServiceVMSizeTypes = "Standard_GS5-16"
	ContainerServiceVMSizeTypesStandardGS58        ContainerServiceVMSizeTypes = "Standard_GS5-8"
	ContainerServiceVMSizeTypesStandardH16         ContainerServiceVMSizeTypes = "Standard_H16"
	ContainerServiceVMSizeTypesStandardH16M        ContainerServiceVMSizeTypes = "Standard_H16m"
	ContainerServiceVMSizeTypesStandardH16Mr       ContainerServiceVMSizeTypes = "Standard_H16mr"
	ContainerServiceVMSizeTypesStandardH16R        ContainerServiceVMSizeTypes = "Standard_H16r"
	ContainerServiceVMSizeTypesStandardH8          ContainerServiceVMSizeTypes = "Standard_H8"
	ContainerServiceVMSizeTypesStandardH8M         ContainerServiceVMSizeTypes = "Standard_H8m"
	ContainerServiceVMSizeTypesStandardL16S        ContainerServiceVMSizeTypes = "Standard_L16s"
	ContainerServiceVMSizeTypesStandardL32S        ContainerServiceVMSizeTypes = "Standard_L32s"
	ContainerServiceVMSizeTypesStandardL4S         ContainerServiceVMSizeTypes = "Standard_L4s"
	ContainerServiceVMSizeTypesStandardL8S         ContainerServiceVMSizeTypes = "Standard_L8s"
	ContainerServiceVMSizeTypesStandardM12832Ms    ContainerServiceVMSizeTypes = "Standard_M128-32ms"
	ContainerServiceVMSizeTypesStandardM12864Ms    ContainerServiceVMSizeTypes = "Standard_M128-64ms"
	ContainerServiceVMSizeTypesStandardM128Ms      ContainerServiceVMSizeTypes = "Standard_M128ms"
	ContainerServiceVMSizeTypesStandardM128S       ContainerServiceVMSizeTypes = "Standard_M128s"
	ContainerServiceVMSizeTypesStandardM6416Ms     ContainerServiceVMSizeTypes = "Standard_M64-16ms"
	ContainerServiceVMSizeTypesStandardM6432Ms     ContainerServiceVMSizeTypes = "Standard_M64-32ms"
	ContainerServiceVMSizeTypesStandardM64Ms       ContainerServiceVMSizeTypes = "Standard_M64ms"
	ContainerServiceVMSizeTypesStandardM64S        ContainerServiceVMSizeTypes = "Standard_M64s"
	ContainerServiceVMSizeTypesStandardNC12        ContainerServiceVMSizeTypes = "Standard_NC12"
	ContainerServiceVMSizeTypesStandardNC12SV2     ContainerServiceVMSizeTypes = "Standard_NC12s_v2"
	ContainerServiceVMSizeTypesStandardNC12SV3     ContainerServiceVMSizeTypes = "Standard_NC12s_v3"
	ContainerServiceVMSizeTypesStandardNC24        ContainerServiceVMSizeTypes = "Standard_NC24"
	ContainerServiceVMSizeTypesStandardNC24R       ContainerServiceVMSizeTypes = "Standard_NC24r"
	ContainerServiceVMSizeTypesStandardNC24RsV2    ContainerServiceVMSizeTypes = "Standard_NC24rs_v2"
	ContainerServiceVMSizeTypesStandardNC24RsV3    ContainerServiceVMSizeTypes = "Standard_NC24rs_v3"
	ContainerServiceVMSizeTypesStandardNC24SV2     ContainerServiceVMSizeTypes = "Standard_NC24s_v2"
	ContainerServiceVMSizeTypesStandardNC24SV3     ContainerServiceVMSizeTypes = "Standard_NC24s_v3"
	ContainerServiceVMSizeTypesStandardNC6         ContainerServiceVMSizeTypes = "Standard_NC6"
	ContainerServiceVMSizeTypesStandardNC6SV2      ContainerServiceVMSizeTypes = "Standard_NC6s_v2"
	ContainerServiceVMSizeTypesStandardNC6SV3      ContainerServiceVMSizeTypes = "Standard_NC6s_v3"
	ContainerServiceVMSizeTypesStandardND12S       ContainerServiceVMSizeTypes = "Standard_ND12s"
	ContainerServiceVMSizeTypesStandardND24Rs      ContainerServiceVMSizeTypes = "Standard_ND24rs"
	ContainerServiceVMSizeTypesStandardND24S       ContainerServiceVMSizeTypes = "Standard_ND24s"
	ContainerServiceVMSizeTypesStandardND6S        ContainerServiceVMSizeTypes = "Standard_ND6s"
	ContainerServiceVMSizeTypesStandardNV12        ContainerServiceVMSizeTypes = "Standard_NV12"
	ContainerServiceVMSizeTypesStandardNV24        ContainerServiceVMSizeTypes = "Standard_NV24"
	ContainerServiceVMSizeTypesStandardNV6         ContainerServiceVMSizeTypes = "Standard_NV6"
)

func PossibleContainerServiceVMSizeTypesValues 

func PossibleContainerServiceVMSizeTypesValues() []ContainerServiceVMSizeTypes

PossibleContainerServiceVMSizeTypesValues returns the possible values for the ContainerServiceVMSizeTypes const type.

type Count 

type Count int32

Count - Number of masters (VMs) in the container service cluster. Allowed values are 1, 3, and 5. The default value is 1. 

const (
	CountOne   Count = 1
	CountThree Count = 3
	CountFive  Count = 5
)

func PossibleCountValues 

func PossibleCountValues() []Count

PossibleCountValues returns the possible values for the Count 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 `json:"sourceResourceId,omitempty"`
}

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

type CredentialResult 

type CredentialResult struct {
	// READ-ONLY; The name of the credential.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Base64-encoded Kubernetes configuration file.
	Value []byte `json:"value,omitempty" azure:"ro"`
}

CredentialResult - The credential result response.

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 `json:"kubeconfigs,omitempty" azure:"ro"`
}

CredentialResults - The list credential result response.

type DiagnosticsProfile added in v0.3.0 

type DiagnosticsProfile struct {
	// REQUIRED; Profile for diagnostics on the container service VMs.
	VMDiagnostics *VMDiagnostics `json:"vmDiagnostics,omitempty"`
}

DiagnosticsProfile - Profile for diagnostics on the container service cluster.

type EndpointDependency 

type EndpointDependency struct {
	// The domain name of the dependency.
	DomainName *string `json:"domainName,omitempty"`

	// The Ports and Protocols used when connecting to domainName.
	EndpointDetails []*EndpointDetail `json:"endpointDetails,omitempty"`
}

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

type EndpointDetail 

type EndpointDetail struct {
	// Description of the detail
	Description *string `json:"description,omitempty"`

	// An IP Address that Domain Name currently resolves to.
	IPAddress *string `json:"ipAddress,omitempty"`

	// The port an endpoint is connected to.
	Port *int32 `json:"port,omitempty"`

	// The protocol used for connection
	Protocol *string `json:"protocol,omitempty"`
}

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

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 `json:"name,omitempty"`

	// The type of the extended location.
	Type *ExtendedLocationTypes `json:"type,omitempty"`
}

ExtendedLocation - The complex type of the extended location.

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 added in v0.4.0 

type Format string
const (
	// FormatAzure - Return azure auth-provider kubeconfig. This format is deprecated in 1.22 and will be fully removed in 1.25.
	FormatAzure Format = "azure"
	// FormatExec - Return exec format kubeconfig. This format requires kubelogin binary in the path.
	FormatExec Format = "exec"
)

func PossibleFormatValues added in v0.4.0 

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 added in v0.3.0 

type IPFamily string

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

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

func PossibleIPFamilyValues added in v0.3.0 

func PossibleIPFamilyValues() []IPFamily

PossibleIPFamilyValues returns the possible values for the IPFamily const type.

type KubeletConfig 

type KubeletConfig struct {
	// Allowed list of unsafe sysctls or unsafe sysctl patterns (ending in *).
	AllowedUnsafeSysctls []*string `json:"allowedUnsafeSysctls,omitempty"`

	// The default is true.
	CPUCfsQuota *bool `json:"cpuCfsQuota,omitempty"`

	// 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 `json:"cpuCfsQuotaPeriod,omitempty"`

	// 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 `json:"cpuManagerPolicy,omitempty"`

	// The maximum number of container log files that can be present for a container. The number must be ≥ 2.
	ContainerLogMaxFiles *int32 `json:"containerLogMaxFiles,omitempty"`

	// The maximum size (e.g. 10Mi) of container log file before it is rotated.
	ContainerLogMaxSizeMB *int32 `json:"containerLogMaxSizeMB,omitempty"`

	// If set to true it will make the Kubelet fail to start if swap is enabled on the node.
	FailSwapOn *bool `json:"failSwapOn,omitempty"`

	// To disable image garbage collection, set to 100. The default is 85%
	ImageGcHighThreshold *int32 `json:"imageGcHighThreshold,omitempty"`

	// This cannot be set higher than imageGcHighThreshold. The default is 80%
	ImageGcLowThreshold *int32 `json:"imageGcLowThreshold,omitempty"`

	// The maximum number of processes per pod.
	PodMaxPids *int32 `json:"podMaxPids,omitempty"`

	// 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 `json:"topologyManagerPolicy,omitempty"`
}

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.

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 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 `json:"swapFileSizeMB,omitempty"`

	// Sysctl settings for Linux agent nodes.
	Sysctls *SysctlConfig `json:"sysctls,omitempty"`

	// 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 `json:"transparentHugePageDefrag,omitempty"`

	// 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 `json:"transparentHugePageEnabled,omitempty"`
}

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

type LinuxProfile added in v0.3.0 

type LinuxProfile struct {
	// REQUIRED; The administrator username to use for Linux VMs.
	AdminUsername *string `json:"adminUsername,omitempty"`

	// REQUIRED; The SSH configuration for Linux-based VMs running on Azure.
	SSH *SSHConfiguration `json:"ssh,omitempty"`
}

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

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 MaintenanceConfiguration 

type MaintenanceConfiguration struct {
	// Properties of a default maintenance configuration.
	Properties *MaintenanceConfigurationProperties `json:"properties,omitempty"`

	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// 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 `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The system metadata relating to this resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

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

type MaintenanceConfigurationListResult 

type MaintenanceConfigurationListResult struct {
	// The list of maintenance configurations.
	Value []*MaintenanceConfiguration `json:"value,omitempty"`

	// READ-ONLY; The URL to get the next set of maintenance configuration results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

MaintenanceConfigurationListResult - The response from the List maintenance configurations operation.

type MaintenanceConfigurationProperties 

type MaintenanceConfigurationProperties struct {
	// Time slots on which upgrade is not allowed.
	NotAllowedTime []*TimeSpan `json:"notAllowedTime,omitempty"`

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

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.

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. 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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/MaintenanceConfigurationsCreate_Update.json 

package main

import (
	"context"
	"log"

	"time"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewMaintenanceConfigurationsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.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:00Z"); return t }()),
						Start: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-11-26T03:00:00Z"); 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)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/MaintenanceConfigurationsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewMaintenanceConfigurationsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.Delete(ctx,
		"rg1",
		"clustername1",
		"default",
		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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/MaintenanceConfigurationsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewMaintenanceConfigurationsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"clustername1",
		"default",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*MaintenanceConfigurationsClient) NewListByManagedClusterPager added in v0.5.0 

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. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-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.ListByManagedCluster method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/MaintenanceConfigurationsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewMaintenanceConfigurationsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByManagedClusterPager("rg1",
		"clustername1",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

type MaintenanceConfigurationsClientCreateOrUpdateOptions added in v0.3.0 

type MaintenanceConfigurationsClientCreateOrUpdateOptions struct {
}

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

type MaintenanceConfigurationsClientCreateOrUpdateResponse added in v0.3.0 

type MaintenanceConfigurationsClientCreateOrUpdateResponse struct {
	MaintenanceConfiguration
}

MaintenanceConfigurationsClientCreateOrUpdateResponse contains the response from method MaintenanceConfigurationsClient.CreateOrUpdate.

type MaintenanceConfigurationsClientDeleteOptions added in v0.3.0 

type MaintenanceConfigurationsClientDeleteOptions struct {
}

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

type MaintenanceConfigurationsClientDeleteResponse added in v0.3.0 

type MaintenanceConfigurationsClientDeleteResponse struct {
}

MaintenanceConfigurationsClientDeleteResponse contains the response from method MaintenanceConfigurationsClient.Delete.

type MaintenanceConfigurationsClientGetOptions added in v0.3.0 

type MaintenanceConfigurationsClientGetOptions struct {
}

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

type MaintenanceConfigurationsClientGetResponse added in v0.3.0 

type MaintenanceConfigurationsClientGetResponse struct {
	MaintenanceConfiguration
}

MaintenanceConfigurationsClientGetResponse contains the response from method MaintenanceConfigurationsClient.Get.

type MaintenanceConfigurationsClientListByManagedClusterOptions added in v0.3.0 

type MaintenanceConfigurationsClientListByManagedClusterOptions struct {
}

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

type MaintenanceConfigurationsClientListByManagedClusterResponse added in v0.3.0 

type MaintenanceConfigurationsClientListByManagedClusterResponse struct {
	MaintenanceConfigurationListResult
}

MaintenanceConfigurationsClientListByManagedClusterResponse contains the response from method MaintenanceConfigurationsClient.ListByManagedCluster.

type ManagedCluster 

type ManagedCluster struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// The extended location of the Virtual Machine.
	ExtendedLocation *ExtendedLocation `json:"extendedLocation,omitempty"`

	// The identity of the managed cluster, if configured.
	Identity *ManagedClusterIdentity `json:"identity,omitempty"`

	// Properties of a managed cluster.
	Properties *ManagedClusterProperties `json:"properties,omitempty"`

	// The managed cluster SKU.
	SKU *ManagedClusterSKU `json:"sku,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

ManagedCluster - Managed cluster.

func (ManagedCluster) MarshalJSON 

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

MarshalJSON implements the json.Marshaller 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 `json:"adminGroupObjectIDs,omitempty"`

	// The client AAD application ID.
	ClientAppID *string `json:"clientAppID,omitempty"`

	// Whether to enable Azure RBAC for Kubernetes authorization.
	EnableAzureRBAC *bool `json:"enableAzureRBAC,omitempty"`

	// Whether to enable managed AAD.
	Managed *bool `json:"managed,omitempty"`

	// The server AAD application ID.
	ServerAppID *string `json:"serverAppID,omitempty"`

	// The server AAD application secret.
	ServerAppSecret *string `json:"serverAppSecret,omitempty"`

	// The AAD tenant ID to use for authentication. If not specified, will use the tenant of the deployment subscription.
	TenantID *string `json:"tenantID,omitempty"`
}

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.

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 `json:"authorizedIPRanges,omitempty"`

	// Whether to disable run command for the cluster or not.
	DisableRunCommand *bool `json:"disableRunCommand,omitempty"`

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

	// Whether to create additional public FQDN for private cluster or not.
	EnablePrivateClusterPublicFQDN *bool `json:"enablePrivateClusterPublicFQDN,omitempty"`

	// 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 `json:"privateDNSZone,omitempty"`
}

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.

type ManagedClusterAccessProfile 

type ManagedClusterAccessProfile struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// AccessProfile of a managed cluster.
	Properties *AccessProfile `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

ManagedClusterAccessProfile - Managed cluster Access Profile.

func (ManagedClusterAccessProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedClusterAccessProfile.

type ManagedClusterAddonProfile 

type ManagedClusterAddonProfile struct {
	// REQUIRED; Whether the add-on is enabled or not.
	Enabled *bool `json:"enabled,omitempty"`

	// Key-value pairs for configuring an add-on.
	Config map[string]*string `json:"config,omitempty"`

	// READ-ONLY; Information of user assigned identity used by this add-on.
	Identity *ManagedClusterAddonProfileIdentity `json:"identity,omitempty" azure:"ro"`
}

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.

type ManagedClusterAddonProfileIdentity 

type ManagedClusterAddonProfileIdentity struct {
	// The client ID of the user assigned identity.
	ClientID *string `json:"clientId,omitempty"`

	// The object ID of the user assigned identity.
	ObjectID *string `json:"objectId,omitempty"`

	// The resource ID of the user assigned identity.
	ResourceID *string `json:"resourceId,omitempty"`
}

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

type ManagedClusterAgentPoolProfile 

type ManagedClusterAgentPoolProfile struct {
	// REQUIRED; Windows agent pool names must be 6 characters or less.
	Name *string `json:"name,omitempty"`

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

	// 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 `json:"count,omitempty"`

	// CreationData to be used to specify the source Snapshot ID if the node pool will be created/upgraded using a snapshot.
	CreationData *CreationData `json:"creationData,omitempty"`

	// Whether to enable auto-scaler
	EnableAutoScaling *bool `json:"enableAutoScaling,omitempty"`

	// 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 `json:"enableEncryptionAtHost,omitempty"`

	// 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 `json:"enableFIPS,omitempty"`

	// 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 `json:"enableNodePublicIP,omitempty"`

	// Whether to enable UltraSSD
	EnableUltraSSD *bool `json:"enableUltraSSD,omitempty"`

	// GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU.
	GpuInstanceProfile *GPUInstanceProfile `json:"gpuInstanceProfile,omitempty"`

	// The Kubelet configuration on the agent pool nodes.
	KubeletConfig *KubeletConfig `json:"kubeletConfig,omitempty"`

	// Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage.
	KubeletDiskType *KubeletDiskType `json:"kubeletDiskType,omitempty"`

	// The OS configuration of Linux agent nodes.
	LinuxOSConfig *LinuxOSConfig `json:"linuxOSConfig,omitempty"`

	// The maximum number of nodes for auto-scaling
	MaxCount *int32 `json:"maxCount,omitempty"`

	// The maximum number of pods that can run on a node.
	MaxPods *int32 `json:"maxPods,omitempty"`

	// The minimum number of nodes for auto-scaling
	MinCount *int32 `json:"minCount,omitempty"`

	// 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 `json:"mode,omitempty"`

	// The node labels to be persisted across all nodes in agent pool.
	NodeLabels map[string]*string `json:"nodeLabels,omitempty"`

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}
	NodePublicIPPrefixID *string `json:"nodePublicIPPrefixID,omitempty"`

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

	// 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 `json:"osDiskSizeGB,omitempty"`

	// 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 `json:"osDiskType,omitempty"`

	// Specifies an OS SKU. This value must not be specified if OSType is Windows.
	OSSKU *OSSKU `json:"osSKU,omitempty"`

	// The operating system type. The default is Linux.
	OSType *OSType `json:"osType,omitempty"`

	// 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 `json:"orchestratorVersion,omitempty"`

	// 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 `json:"podSubnetID,omitempty"`

	// 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 `json:"powerState,omitempty"`

	// The ID for Proximity Placement Group.
	ProximityPlacementGroupID *string `json:"proximityPlacementGroupID,omitempty"`

	// This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
	ScaleDownMode *ScaleDownMode `json:"scaleDownMode,omitempty"`

	// This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
	ScaleSetEvictionPolicy *ScaleSetEvictionPolicy `json:"scaleSetEvictionPolicy,omitempty"`

	// The Virtual Machine Scale Set priority. If not specified, the default is 'Regular'.
	ScaleSetPriority *ScaleSetPriority `json:"scaleSetPriority,omitempty"`

	// 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 `json:"spotMaxPrice,omitempty"`

	// The tags to be persisted on the agent pool virtual machine scale set.
	Tags map[string]*string `json:"tags,omitempty"`

	// The type of Agent Pool.
	Type *AgentPoolType `json:"type,omitempty"`

	// Settings for upgrading the agentpool
	UpgradeSettings *AgentPoolUpgradeSettings `json:"upgradeSettings,omitempty"`

	// 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 `json:"vmSize,omitempty"`

	// 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 `json:"vnetSubnetID,omitempty"`

	// Determines the type of workload a node can run.
	WorkloadRuntime *WorkloadRuntime `json:"workloadRuntime,omitempty"`

	// 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 `json:"currentOrchestratorVersion,omitempty" azure:"ro"`

	// READ-ONLY; The version of node image
	NodeImageVersion *string `json:"nodeImageVersion,omitempty" azure:"ro"`

	// READ-ONLY; The current deployment or provisioning state.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

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.

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 `json:"availabilityZones,omitempty"`

	// 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 `json:"count,omitempty"`

	// CreationData to be used to specify the source Snapshot ID if the node pool will be created/upgraded using a snapshot.
	CreationData *CreationData `json:"creationData,omitempty"`

	// Whether to enable auto-scaler
	EnableAutoScaling *bool `json:"enableAutoScaling,omitempty"`

	// 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 `json:"enableEncryptionAtHost,omitempty"`

	// 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 `json:"enableFIPS,omitempty"`

	// 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 `json:"enableNodePublicIP,omitempty"`

	// Whether to enable UltraSSD
	EnableUltraSSD *bool `json:"enableUltraSSD,omitempty"`

	// GPUInstanceProfile to be used to specify GPU MIG instance profile for supported GPU VM SKU.
	GpuInstanceProfile *GPUInstanceProfile `json:"gpuInstanceProfile,omitempty"`

	// The Kubelet configuration on the agent pool nodes.
	KubeletConfig *KubeletConfig `json:"kubeletConfig,omitempty"`

	// Determines the placement of emptyDir volumes, container runtime data root, and Kubelet ephemeral storage.
	KubeletDiskType *KubeletDiskType `json:"kubeletDiskType,omitempty"`

	// The OS configuration of Linux agent nodes.
	LinuxOSConfig *LinuxOSConfig `json:"linuxOSConfig,omitempty"`

	// The maximum number of nodes for auto-scaling
	MaxCount *int32 `json:"maxCount,omitempty"`

	// The maximum number of pods that can run on a node.
	MaxPods *int32 `json:"maxPods,omitempty"`

	// The minimum number of nodes for auto-scaling
	MinCount *int32 `json:"minCount,omitempty"`

	// 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 `json:"mode,omitempty"`

	// The node labels to be persisted across all nodes in agent pool.
	NodeLabels map[string]*string `json:"nodeLabels,omitempty"`

	// This is of the form: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}
	NodePublicIPPrefixID *string `json:"nodePublicIPPrefixID,omitempty"`

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

	// 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 `json:"osDiskSizeGB,omitempty"`

	// 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 `json:"osDiskType,omitempty"`

	// Specifies an OS SKU. This value must not be specified if OSType is Windows.
	OSSKU *OSSKU `json:"osSKU,omitempty"`

	// The operating system type. The default is Linux.
	OSType *OSType `json:"osType,omitempty"`

	// 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 `json:"orchestratorVersion,omitempty"`

	// 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 `json:"podSubnetID,omitempty"`

	// 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 `json:"powerState,omitempty"`

	// The ID for Proximity Placement Group.
	ProximityPlacementGroupID *string `json:"proximityPlacementGroupID,omitempty"`

	// This also effects the cluster autoscaler behavior. If not specified, it defaults to Delete.
	ScaleDownMode *ScaleDownMode `json:"scaleDownMode,omitempty"`

	// This cannot be specified unless the scaleSetPriority is 'Spot'. If not specified, the default is 'Delete'.
	ScaleSetEvictionPolicy *ScaleSetEvictionPolicy `json:"scaleSetEvictionPolicy,omitempty"`

	// The Virtual Machine Scale Set priority. If not specified, the default is 'Regular'.
	ScaleSetPriority *ScaleSetPriority `json:"scaleSetPriority,omitempty"`

	// 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 `json:"spotMaxPrice,omitempty"`

	// The tags to be persisted on the agent pool virtual machine scale set.
	Tags map[string]*string `json:"tags,omitempty"`

	// The type of Agent Pool.
	Type *AgentPoolType `json:"type,omitempty"`

	// Settings for upgrading the agentpool
	UpgradeSettings *AgentPoolUpgradeSettings `json:"upgradeSettings,omitempty"`

	// 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 `json:"vmSize,omitempty"`

	// 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 `json:"vnetSubnetID,omitempty"`

	// Determines the type of workload a node can run.
	WorkloadRuntime *WorkloadRuntime `json:"workloadRuntime,omitempty"`

	// 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 `json:"currentOrchestratorVersion,omitempty" azure:"ro"`

	// READ-ONLY; The version of node image
	NodeImageVersion *string `json:"nodeImageVersion,omitempty" azure:"ro"`

	// READ-ONLY; The current deployment or provisioning state.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

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.

type ManagedClusterAutoUpgradeProfile 

type ManagedClusterAutoUpgradeProfile struct {
	// 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 `json:"upgradeChannel,omitempty"`
}

ManagedClusterAutoUpgradeProfile - Auto upgrade profile for a managed cluster.

type ManagedClusterHTTPProxyConfig 

type ManagedClusterHTTPProxyConfig struct {
	// The HTTP proxy server endpoint to use.
	HTTPProxy *string `json:"httpProxy,omitempty"`

	// The HTTPS proxy server endpoint to use.
	HTTPSProxy *string `json:"httpsProxy,omitempty"`

	// The endpoints that should not go through proxy.
	NoProxy []*string `json:"noProxy,omitempty"`

	// Alternative CA cert to use for connecting to proxy servers.
	TrustedCa *string `json:"trustedCa,omitempty"`
}

ManagedClusterHTTPProxyConfig - Cluster HTTP proxy configuration.

func (ManagedClusterHTTPProxyConfig) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedClusterHTTPProxyConfig.

type ManagedClusterIdentity 

type ManagedClusterIdentity struct {
	// For more information see use managed identities in AKS [https://docs.microsoft.com/azure/aks/use-managed-identity].
	Type *ResourceIdentityType `json:"type,omitempty"`

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

	// READ-ONLY; The principal id of the system assigned identity which is used by master components.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`

	// READ-ONLY; The tenant id of the system assigned identity which is used by master components.
	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
}

ManagedClusterIdentity - Identity for the managed cluster.

func (ManagedClusterIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedClusterIdentity.

type ManagedClusterListResult 

type ManagedClusterListResult struct {
	// The list of managed clusters.
	Value []*ManagedCluster `json:"value,omitempty"`

	// READ-ONLY; The URL to get the next set of managed cluster results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

ManagedClusterListResult - The response from the List Managed Clusters operation.

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 `json:"allocatedOutboundPorts,omitempty"`

	// The effective outbound IP resources of the cluster load balancer.
	EffectiveOutboundIPs []*ResourceReference `json:"effectiveOutboundIPs,omitempty"`

	// Enable multiple standard load balancers per AKS cluster or not.
	EnableMultipleStandardLoadBalancers *bool `json:"enableMultipleStandardLoadBalancers,omitempty"`

	// 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 `json:"idleTimeoutInMinutes,omitempty"`

	// Desired managed outbound IPs for the cluster load balancer.
	ManagedOutboundIPs *ManagedClusterLoadBalancerProfileManagedOutboundIPs `json:"managedOutboundIPs,omitempty"`

	// Desired outbound IP Prefix resources for the cluster load balancer.
	OutboundIPPrefixes *ManagedClusterLoadBalancerProfileOutboundIPPrefixes `json:"outboundIPPrefixes,omitempty"`

	// Desired outbound IP resources for the cluster load balancer.
	OutboundIPs *ManagedClusterLoadBalancerProfileOutboundIPs `json:"outboundIPs,omitempty"`
}

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.

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 `json:"count,omitempty"`

	// 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 `json:"countIPv6,omitempty"`
}

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

type ManagedClusterLoadBalancerProfileOutboundIPPrefixes 

type ManagedClusterLoadBalancerProfileOutboundIPPrefixes struct {
	// A list of public IP prefix resources.
	PublicIPPrefixes []*ResourceReference `json:"publicIPPrefixes,omitempty"`
}

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.

type ManagedClusterLoadBalancerProfileOutboundIPs 

type ManagedClusterLoadBalancerProfileOutboundIPs struct {
	// A list of public IP resources.
	PublicIPs []*ResourceReference `json:"publicIPs,omitempty"`
}

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.

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 `json:"count,omitempty"`
}

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

type ManagedClusterNATGatewayProfile 

type ManagedClusterNATGatewayProfile struct {
	// The effective outbound IP resources of the cluster NAT gateway.
	EffectiveOutboundIPs []*ResourceReference `json:"effectiveOutboundIPs,omitempty"`

	// 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 `json:"idleTimeoutInMinutes,omitempty"`

	// Profile of the managed outbound IP resources of the cluster NAT gateway.
	ManagedOutboundIPProfile *ManagedClusterManagedOutboundIPProfile `json:"managedOutboundIPProfile,omitempty"`
}

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.

type ManagedClusterPodIdentity 

type ManagedClusterPodIdentity struct {
	// REQUIRED; The user assigned identity details.
	Identity *UserAssignedIdentity `json:"identity,omitempty"`

	// REQUIRED; The name of the pod identity.
	Name *string `json:"name,omitempty"`

	// REQUIRED; The namespace of the pod identity.
	Namespace *string `json:"namespace,omitempty"`

	// The binding selector to use for the AzureIdentityBinding resource.
	BindingSelector *string `json:"bindingSelector,omitempty"`

	// READ-ONLY
	ProvisioningInfo *ManagedClusterPodIdentityProvisioningInfo `json:"provisioningInfo,omitempty" azure:"ro"`

	// READ-ONLY; The current provisioning state of the pod identity.
	ProvisioningState *ManagedClusterPodIdentityProvisioningState `json:"provisioningState,omitempty" azure:"ro"`
}

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

type ManagedClusterPodIdentityException 

type ManagedClusterPodIdentityException struct {
	// REQUIRED; The name of the pod identity exception.
	Name *string `json:"name,omitempty"`

	// REQUIRED; The namespace of the pod identity exception.
	Namespace *string `json:"namespace,omitempty"`

	// REQUIRED; The pod labels to match.
	PodLabels map[string]*string `json:"podLabels,omitempty"`
}

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.

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 `json:"allowNetworkPluginKubenet,omitempty"`

	// Whether the pod identity addon is enabled.
	Enabled *bool `json:"enabled,omitempty"`

	// The pod identities to use in the cluster.
	UserAssignedIdentities []*ManagedClusterPodIdentity `json:"userAssignedIdentities,omitempty"`

	// The pod identity exceptions to allow.
	UserAssignedIdentityExceptions []*ManagedClusterPodIdentityException `json:"userAssignedIdentityExceptions,omitempty"`
}

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.

type ManagedClusterPodIdentityProvisioningError 

type ManagedClusterPodIdentityProvisioningError struct {
	// Details about the error.
	Error *ManagedClusterPodIdentityProvisioningErrorBody `json:"error,omitempty"`
}

ManagedClusterPodIdentityProvisioningError - An error response from the pod identity provisioning.

type ManagedClusterPodIdentityProvisioningErrorBody 

type ManagedClusterPodIdentityProvisioningErrorBody struct {
	// An identifier for the error. Codes are invariant and are intended to be consumed programmatically.
	Code *string `json:"code,omitempty"`

	// A list of additional details about the error.
	Details []*ManagedClusterPodIdentityProvisioningErrorBody `json:"details,omitempty"`

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

	// The target of the particular error. For example, the name of the property in error.
	Target *string `json:"target,omitempty"`
}

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.

type ManagedClusterPodIdentityProvisioningInfo 

type ManagedClusterPodIdentityProvisioningInfo struct {
	// Pod identity assignment error (if any).
	Error *ManagedClusterPodIdentityProvisioningError `json:"error,omitempty"`
}

type ManagedClusterPodIdentityProvisioningState 

type ManagedClusterPodIdentityProvisioningState string

ManagedClusterPodIdentityProvisioningState - The current provisioning state of the pod identity. 

const (
	ManagedClusterPodIdentityProvisioningStateAssigned ManagedClusterPodIdentityProvisioningState = "Assigned"
	ManagedClusterPodIdentityProvisioningStateDeleting ManagedClusterPodIdentityProvisioningState = "Deleting"
	ManagedClusterPodIdentityProvisioningStateFailed   ManagedClusterPodIdentityProvisioningState = "Failed"
	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 `json:"kubernetesVersion,omitempty"`

	// REQUIRED; The operating system type. The default is Linux.
	OSType *OSType `json:"osType,omitempty"`

	// The Agent Pool name.
	Name *string `json:"name,omitempty"`

	// List of orchestrator types and versions available for upgrade.
	Upgrades []*ManagedClusterPoolUpgradeProfileUpgradesItem `json:"upgrades,omitempty"`
}

ManagedClusterPoolUpgradeProfile - The list of available upgrade versions.

type ManagedClusterPoolUpgradeProfileUpgradesItem 

type ManagedClusterPoolUpgradeProfileUpgradesItem struct {
	// Whether the Kubernetes version is currently in preview.
	IsPreview *bool `json:"isPreview,omitempty"`

	// The Kubernetes version (major.minor.patch).
	KubernetesVersion *string `json:"kubernetesVersion,omitempty"`
}

type ManagedClusterProperties 

type ManagedClusterProperties struct {
	// The Azure Active Directory configuration.
	AADProfile *ManagedClusterAADProfile `json:"aadProfile,omitempty"`

	// The access profile for managed cluster API server.
	APIServerAccessProfile *ManagedClusterAPIServerAccessProfile `json:"apiServerAccessProfile,omitempty"`

	// The profile of managed cluster add-on.
	AddonProfiles map[string]*ManagedClusterAddonProfile `json:"addonProfiles,omitempty"`

	// The agent pool properties.
	AgentPoolProfiles []*ManagedClusterAgentPoolProfile `json:"agentPoolProfiles,omitempty"`

	// Parameters to be applied to the cluster-autoscaler when enabled
	AutoScalerProfile *ManagedClusterPropertiesAutoScalerProfile `json:"autoScalerProfile,omitempty"`

	// The auto upgrade configuration.
	AutoUpgradeProfile *ManagedClusterAutoUpgradeProfile `json:"autoUpgradeProfile,omitempty"`

	// This cannot be updated once the Managed Cluster has been created.
	DNSPrefix *string `json:"dnsPrefix,omitempty"`

	// 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 `json:"disableLocalAccounts,omitempty"`

	// This is of the form: '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{encryptionSetName}'
	DiskEncryptionSetID *string `json:"diskEncryptionSetID,omitempty"`

	// (DEPRECATING) Whether to enable Kubernetes pod security policy (preview). This feature is set for removal on October 15th,
	// 2020. Learn more at aka.ms/aks/azpodpolicy.
	EnablePodSecurityPolicy *bool `json:"enablePodSecurityPolicy,omitempty"`

	// Whether to enable Kubernetes Role-Based Access Control.
	EnableRBAC *bool `json:"enableRBAC,omitempty"`

	// This cannot be updated once the Managed Cluster has been created.
	FqdnSubdomain *string `json:"fqdnSubdomain,omitempty"`

	// Configurations for provisioning the cluster with HTTP proxy servers.
	HTTPProxyConfig *ManagedClusterHTTPProxyConfig `json:"httpProxyConfig,omitempty"`

	// Identities associated with the cluster.
	IdentityProfile map[string]*UserAssignedIdentity `json:"identityProfile,omitempty"`

	// 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 `json:"kubernetesVersion,omitempty"`

	// The profile for Linux VMs in the Managed Cluster.
	LinuxProfile *LinuxProfile `json:"linuxProfile,omitempty"`

	// The network configuration profile.
	NetworkProfile *NetworkProfile `json:"networkProfile,omitempty"`

	// The name of the resource group containing agent pool nodes.
	NodeResourceGroup *string `json:"nodeResourceGroup,omitempty"`

	// 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 `json:"podIdentityProfile,omitempty"`

	// Private link resources associated with the cluster.
	PrivateLinkResources []*PrivateLinkResource `json:"privateLinkResources,omitempty"`

	// Allow or deny public network access for AKS
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// Security profile for the managed cluster.
	SecurityProfile *ManagedClusterSecurityProfile `json:"securityProfile,omitempty"`

	// Information about a service principal identity for the cluster to use for manipulating Azure APIs.
	ServicePrincipalProfile *ManagedClusterServicePrincipalProfile `json:"servicePrincipalProfile,omitempty"`

	// Storage profile for the managed cluster.
	StorageProfile *ManagedClusterStorageProfile `json:"storageProfile,omitempty"`

	// The profile for Windows VMs in the Managed Cluster.
	WindowsProfile *ManagedClusterWindowsProfile `json:"windowsProfile,omitempty"`

	// 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 `json:"azurePortalFQDN,omitempty" azure:"ro"`

	// 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 `json:"currentKubernetesVersion,omitempty" azure:"ro"`

	// READ-ONLY; The FQDN of the master pool.
	Fqdn *string `json:"fqdn,omitempty" azure:"ro"`

	// READ-ONLY; The max number of agent pools for the managed cluster.
	MaxAgentPools *int32 `json:"maxAgentPools,omitempty" azure:"ro"`

	// READ-ONLY; The Power State of the cluster.
	PowerState *PowerState `json:"powerState,omitempty" azure:"ro"`

	// READ-ONLY; The FQDN of private cluster.
	PrivateFQDN *string `json:"privateFQDN,omitempty" azure:"ro"`

	// READ-ONLY; The current provisioning state.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

ManagedClusterProperties - Properties of the managed cluster.

func (ManagedClusterProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedClusterProperties.

type ManagedClusterPropertiesAutoScalerProfile 

type ManagedClusterPropertiesAutoScalerProfile struct {
	// Valid values are 'true' and 'false'
	BalanceSimilarNodeGroups *string `json:"balance-similar-node-groups,omitempty"`

	// 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 `json:"expander,omitempty"`

	// The default is 10.
	MaxEmptyBulkDelete *string `json:"max-empty-bulk-delete,omitempty"`

	// The default is 600.
	MaxGracefulTerminationSec *string `json:"max-graceful-termination-sec,omitempty"`

	// 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 `json:"max-node-provision-time,omitempty"`

	// The default is 45. The maximum is 100 and the minimum is 0.
	MaxTotalUnreadyPercentage *string `json:"max-total-unready-percentage,omitempty"`

	// 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 `json:"new-pod-scale-up-delay,omitempty"`

	// This must be an integer. The default is 3.
	OkTotalUnreadyCount *string `json:"ok-total-unready-count,omitempty"`

	// 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 `json:"scale-down-delay-after-add,omitempty"`

	// 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 `json:"scale-down-delay-after-delete,omitempty"`

	// 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 `json:"scale-down-delay-after-failure,omitempty"`

	// 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 `json:"scale-down-unneeded-time,omitempty"`

	// 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 `json:"scale-down-unready-time,omitempty"`

	// The default is '0.5'.
	ScaleDownUtilizationThreshold *string `json:"scale-down-utilization-threshold,omitempty"`

	// The default is '10'. Values must be an integer number of seconds.
	ScanInterval *string `json:"scan-interval,omitempty"`

	// The default is true.
	SkipNodesWithLocalStorage *string `json:"skip-nodes-with-local-storage,omitempty"`

	// The default is true.
	SkipNodesWithSystemPods *string `json:"skip-nodes-with-system-pods,omitempty"`
}

ManagedClusterPropertiesAutoScalerProfile - Parameters to be applied to the cluster-autoscaler when enabled

type ManagedClusterSKU 

type ManagedClusterSKU struct {
	// The name of a managed cluster SKU.
	Name *ManagedClusterSKUName `json:"name,omitempty"`

	// If not specified, the default is 'Free'. See uptime SLA [https://docs.microsoft.com/azure/aks/uptime-sla] for more details.
	Tier *ManagedClusterSKUTier `json:"tier,omitempty"`
}

ManagedClusterSKU - The SKU of a Managed Cluster.

type ManagedClusterSKUName 

type ManagedClusterSKUName string

ManagedClusterSKUName - The name of a managed cluster SKU. 

const (
	ManagedClusterSKUNameBasic ManagedClusterSKUName = "Basic"
)

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 uptime SLA [https://docs.microsoft.com/azure/aks/uptime-sla] for more details. 

const (
	// ManagedClusterSKUTierFree - No guaranteed SLA, no additional charges. Free tier clusters have an SLO of 99.5%.
	ManagedClusterSKUTierFree ManagedClusterSKUTier = "Free"
	// ManagedClusterSKUTierPaid - 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.
	ManagedClusterSKUTierPaid ManagedClusterSKUTier = "Paid"
)

func PossibleManagedClusterSKUTierValues 

func PossibleManagedClusterSKUTierValues() []ManagedClusterSKUTier

PossibleManagedClusterSKUTierValues returns the possible values for the ManagedClusterSKUTier const type.

type ManagedClusterSecurityProfile 

type ManagedClusterSecurityProfile struct {
	// Azure Defender settings for the security profile.
	AzureDefender *ManagedClusterSecurityProfileAzureDefender `json:"azureDefender,omitempty"`
}

ManagedClusterSecurityProfile - Security profile for the container service cluster.

type ManagedClusterSecurityProfileAzureDefender 

type ManagedClusterSecurityProfileAzureDefender struct {
	// Whether to enable Azure Defender
	Enabled *bool `json:"enabled,omitempty"`

	// Resource ID of the Log Analytics workspace to be associated with Azure Defender. When Azure Defender is enabled, this field
	// is required and must be a valid workspace resource ID. When Azure Defender
	// is disabled, leave the field empty.
	LogAnalyticsWorkspaceResourceID *string `json:"logAnalyticsWorkspaceResourceId,omitempty"`
}

ManagedClusterSecurityProfileAzureDefender - Azure Defender settings for the security profile.

type ManagedClusterServicePrincipalProfile 

type ManagedClusterServicePrincipalProfile struct {
	// REQUIRED; The ID for the service principal.
	ClientID *string `json:"clientId,omitempty"`

	// The secret password associated with the service principal in plain text.
	Secret *string `json:"secret,omitempty"`
}

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

type ManagedClusterStorageProfile added in v0.5.0 

type ManagedClusterStorageProfile struct {
	// AzureDisk CSI Driver settings for the storage profile.
	DiskCSIDriver *ManagedClusterStorageProfileDiskCSIDriver `json:"diskCSIDriver,omitempty"`

	// AzureFile CSI Driver settings for the storage profile.
	FileCSIDriver *ManagedClusterStorageProfileFileCSIDriver `json:"fileCSIDriver,omitempty"`

	// Snapshot Controller settings for the storage profile.
	SnapshotController *ManagedClusterStorageProfileSnapshotController `json:"snapshotController,omitempty"`
}

ManagedClusterStorageProfile - Storage profile for the container service cluster.

type ManagedClusterStorageProfileDiskCSIDriver added in v0.5.0 

type ManagedClusterStorageProfileDiskCSIDriver struct {
	// Whether to enable AzureDisk CSI Driver. The default value is true.
	Enabled *bool `json:"enabled,omitempty"`
}

ManagedClusterStorageProfileDiskCSIDriver - AzureDisk CSI Driver settings for the storage profile.

type ManagedClusterStorageProfileFileCSIDriver added in v0.5.0 

type ManagedClusterStorageProfileFileCSIDriver struct {
	// Whether to enable AzureFile CSI Driver. The default value is true.
	Enabled *bool `json:"enabled,omitempty"`
}

ManagedClusterStorageProfileFileCSIDriver - AzureFile CSI Driver settings for the storage profile.

type ManagedClusterStorageProfileSnapshotController added in v0.5.0 

type ManagedClusterStorageProfileSnapshotController struct {
	// Whether to enable Snapshot Controller. The default value is true.
	Enabled *bool `json:"enabled,omitempty"`
}

ManagedClusterStorageProfileSnapshotController - Snapshot Controller settings for the storage profile.

type ManagedClusterUpgradeProfile 

type ManagedClusterUpgradeProfile struct {
	// REQUIRED; The properties of the upgrade profile.
	Properties *ManagedClusterUpgradeProfileProperties `json:"properties,omitempty"`

	// READ-ONLY; The ID of the upgrade profile.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the upgrade profile.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the upgrade profile.
	Type *string `json:"type,omitempty" azure:"ro"`
}

ManagedClusterUpgradeProfile - The list of available upgrades for compute pools.

type ManagedClusterUpgradeProfileProperties 

type ManagedClusterUpgradeProfileProperties struct {
	// REQUIRED; The list of available upgrade versions for agent pools.
	AgentPoolProfiles []*ManagedClusterPoolUpgradeProfile `json:"agentPoolProfiles,omitempty"`

	// REQUIRED; The list of available upgrade versions for the control plane.
	ControlPlaneProfile *ManagedClusterPoolUpgradeProfile `json:"controlPlaneProfile,omitempty"`
}

ManagedClusterUpgradeProfileProperties - Control plane and agent pool upgrade profiles.

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 `json:"adminUsername,omitempty"`

	// 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 `json:"adminPassword,omitempty"`

	// For more details on CSI proxy, see the CSI proxy GitHub repo [https://github.com/kubernetes-csi/csi-proxy].
	EnableCSIProxy *bool `json:"enableCSIProxy,omitempty"`

	// The Windows gMSA Profile in the Managed Cluster.
	GmsaProfile *WindowsGmsaProfile `json:"gmsaProfile,omitempty"`

	// 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 `json:"licenseType,omitempty"`
}

ManagedClusterWindowsProfile - Profile for Windows VMs in the managed cluster.

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. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersCreate_Snapshot.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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/subid1/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/subid1/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.ManagedClusterSKUNameBasic),
				Tier: to.Ptr(armcontainerservice.ManagedClusterSKUTierFree),
			},
		},
		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)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(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) BeginResetAADProfile 

func (client *ManagedClustersClient) BeginResetAADProfile(ctx context.Context, resourceGroupName string, resourceName string, parameters ManagedClusterAADProfile, options *ManagedClustersClientBeginResetAADProfileOptions) (*runtime.Poller[ManagedClustersClientResetAADProfileResponse], error)

BeginResetAADProfile - Reset the AAD Profile of a managed cluster. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersResetAADProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersResetServicePrincipalProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersRotateClusterCertificates.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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) 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/RunCommandRequest.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersStart.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersStop.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersUpdateTags.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginUpdateTags(ctx,
		"rg1",
		"clustername1",
		armcontainerservice.TagsObject{
			Tags: map[string]*string{
				"archv3": to.Ptr(""),
				"tier":   to.Ptr("testing"),
			},
		},
		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)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"clustername1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersGetAccessProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetAccessProfile(ctx,
		"rg1",
		"clustername1",
		"clusterUser",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/RunCommandResultFailed.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetCommandResult(ctx,
		"rg1",
		"clustername1",
		"def7b3ea71bd4f7e9d226ddbc0f00ad9",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*ManagedClustersClient) GetOSOptions 

func (client *ManagedClustersClient) GetOSOptions(ctx context.Context, location string, options *ManagedClustersClientGetOSOptionsOptions) (ManagedClustersClientGetOSOptionsResponse, error)

GetOSOptions - Gets supported OS options in the specified subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 location - The name of Azure region. options - ManagedClustersClientGetOSOptionsOptions contains the optional parameters for the ManagedClustersClient.GetOSOptions method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ContainerServiceGetOSOptions.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetOSOptions(ctx,
		"location1",
		&armcontainerservice.ManagedClustersClientGetOSOptionsOptions{ResourceType: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersGetUpgradeProfile.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.GetUpgradeProfile(ctx,
		"rg1",
		"clustername1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersListClusterCredentialResult.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.ListClusterAdminCredentials(ctx,
		"rg1",
		"clustername1",
		&armcontainerservice.ManagedClustersClientListClusterAdminCredentialsOptions{ServerFqdn: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersListClusterCredentialResult.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.ListClusterMonitoringUserCredentials(ctx,
		"rg1",
		"clustername1",
		&armcontainerservice.ManagedClustersClientListClusterMonitoringUserCredentialsOptions{ServerFqdn: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersListClusterCredentialResult.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.ListClusterUserCredentials(ctx,
		"rg1",
		"clustername1",
		&armcontainerservice.ManagedClustersClientListClusterUserCredentialsOptions{ServerFqdn: nil,
			Format: nil,
		})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*ManagedClustersClient) NewListByResourceGroupPager added in v0.5.0 

func (client *ManagedClustersClient) NewListByResourceGroupPager(resourceGroupName string, options *ManagedClustersClientListByResourceGroupOptions) *runtime.Pager[ManagedClustersClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists managed clusters in the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 resourceGroupName - The name of the resource group. The name is case insensitive. options - ManagedClustersClientListByResourceGroupOptions contains the optional parameters for the ManagedClustersClient.ListByResourceGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByResourceGroupPager("rg1",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

func (*ManagedClustersClient) NewListOutboundNetworkDependenciesEndpointsPager added in v0.5.0 

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. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-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.ListOutboundNetworkDependenciesEndpoints method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/OutboundNetworkDependenciesEndpointsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListOutboundNetworkDependenciesEndpointsPager("rg1",
		"clustername1",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

func (*ManagedClustersClient) NewListPager added in v0.5.0 

func (client *ManagedClustersClient) NewListPager(options *ManagedClustersClientListOptions) *runtime.Pager[ManagedClustersClientListResponse]

NewListPager - Gets a list of managed clusters in the specified subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 options - ManagedClustersClientListOptions contains the optional parameters for the ManagedClustersClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ManagedClustersList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewManagedClustersClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager(nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

type ManagedClustersClientBeginCreateOrUpdateOptions added in v0.3.0 

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

ManagedClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the ManagedClustersClient.BeginCreateOrUpdate method.

type ManagedClustersClientBeginDeleteOptions added in v0.3.0 

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

ManagedClustersClientBeginDeleteOptions contains the optional parameters for the ManagedClustersClient.BeginDelete method.

type ManagedClustersClientBeginResetAADProfileOptions added in v0.3.0 

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

ManagedClustersClientBeginResetAADProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetAADProfile method.

type ManagedClustersClientBeginResetServicePrincipalProfileOptions added in v0.3.0 

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

ManagedClustersClientBeginResetServicePrincipalProfileOptions contains the optional parameters for the ManagedClustersClient.BeginResetServicePrincipalProfile method.

type ManagedClustersClientBeginRotateClusterCertificatesOptions added in v0.3.0 

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

ManagedClustersClientBeginRotateClusterCertificatesOptions contains the optional parameters for the ManagedClustersClient.BeginRotateClusterCertificates method.

type ManagedClustersClientBeginRunCommandOptions added in v0.3.0 

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

ManagedClustersClientBeginRunCommandOptions contains the optional parameters for the ManagedClustersClient.BeginRunCommand method.

type ManagedClustersClientBeginStartOptions added in v0.3.0 

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

ManagedClustersClientBeginStartOptions contains the optional parameters for the ManagedClustersClient.BeginStart method.

type ManagedClustersClientBeginStopOptions added in v0.3.0 

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

ManagedClustersClientBeginStopOptions contains the optional parameters for the ManagedClustersClient.BeginStop method.

type ManagedClustersClientBeginUpdateTagsOptions added in v0.3.0 

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

ManagedClustersClientBeginUpdateTagsOptions contains the optional parameters for the ManagedClustersClient.BeginUpdateTags method.

type ManagedClustersClientCreateOrUpdateResponse added in v0.3.0 

type ManagedClustersClientCreateOrUpdateResponse struct {
	ManagedCluster
}

ManagedClustersClientCreateOrUpdateResponse contains the response from method ManagedClustersClient.CreateOrUpdate.

type ManagedClustersClientDeleteResponse added in v0.3.0 

type ManagedClustersClientDeleteResponse struct {
}

ManagedClustersClientDeleteResponse contains the response from method ManagedClustersClient.Delete.

type ManagedClustersClientGetAccessProfileOptions added in v0.3.0 

type ManagedClustersClientGetAccessProfileOptions struct {
}

ManagedClustersClientGetAccessProfileOptions contains the optional parameters for the ManagedClustersClient.GetAccessProfile method.

type ManagedClustersClientGetAccessProfileResponse added in v0.3.0 

type ManagedClustersClientGetAccessProfileResponse struct {
	ManagedClusterAccessProfile
}

ManagedClustersClientGetAccessProfileResponse contains the response from method ManagedClustersClient.GetAccessProfile.

type ManagedClustersClientGetCommandResultOptions added in v0.3.0 

type ManagedClustersClientGetCommandResultOptions struct {
}

ManagedClustersClientGetCommandResultOptions contains the optional parameters for the ManagedClustersClient.GetCommandResult method.

type ManagedClustersClientGetCommandResultResponse added in v0.3.0 

type ManagedClustersClientGetCommandResultResponse struct {
	RunCommandResult
}

ManagedClustersClientGetCommandResultResponse contains the response from method ManagedClustersClient.GetCommandResult.

type ManagedClustersClientGetOSOptionsOptions added in v0.3.0 

type ManagedClustersClientGetOSOptionsOptions struct {
	// The resource type for which the OS options needs to be returned
	ResourceType *string
}

ManagedClustersClientGetOSOptionsOptions contains the optional parameters for the ManagedClustersClient.GetOSOptions method.

type ManagedClustersClientGetOSOptionsResponse added in v0.3.0 

type ManagedClustersClientGetOSOptionsResponse struct {
	OSOptionProfile
}

ManagedClustersClientGetOSOptionsResponse contains the response from method ManagedClustersClient.GetOSOptions.

type ManagedClustersClientGetOptions added in v0.3.0 

type ManagedClustersClientGetOptions struct {
}

ManagedClustersClientGetOptions contains the optional parameters for the ManagedClustersClient.Get method.

type ManagedClustersClientGetResponse added in v0.3.0 

type ManagedClustersClientGetResponse struct {
	ManagedCluster
}

ManagedClustersClientGetResponse contains the response from method ManagedClustersClient.Get.

type ManagedClustersClientGetUpgradeProfileOptions added in v0.3.0 

type ManagedClustersClientGetUpgradeProfileOptions struct {
}

ManagedClustersClientGetUpgradeProfileOptions contains the optional parameters for the ManagedClustersClient.GetUpgradeProfile method.

type ManagedClustersClientGetUpgradeProfileResponse added in v0.3.0 

type ManagedClustersClientGetUpgradeProfileResponse struct {
	ManagedClusterUpgradeProfile
}

ManagedClustersClientGetUpgradeProfileResponse contains the response from method ManagedClustersClient.GetUpgradeProfile.

type ManagedClustersClientListByResourceGroupOptions added in v0.3.0 

type ManagedClustersClientListByResourceGroupOptions struct {
}

ManagedClustersClientListByResourceGroupOptions contains the optional parameters for the ManagedClustersClient.ListByResourceGroup method.

type ManagedClustersClientListByResourceGroupResponse added in v0.3.0 

type ManagedClustersClientListByResourceGroupResponse struct {
	ManagedClusterListResult
}

ManagedClustersClientListByResourceGroupResponse contains the response from method ManagedClustersClient.ListByResourceGroup.

type ManagedClustersClientListClusterAdminCredentialsOptions added in v0.3.0 

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 added in v0.3.0 

type ManagedClustersClientListClusterAdminCredentialsResponse struct {
	CredentialResults
}

ManagedClustersClientListClusterAdminCredentialsResponse contains the response from method ManagedClustersClient.ListClusterAdminCredentials.

type ManagedClustersClientListClusterMonitoringUserCredentialsOptions added in v0.3.0 

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 added in v0.3.0 

type ManagedClustersClientListClusterMonitoringUserCredentialsResponse struct {
	CredentialResults
}

ManagedClustersClientListClusterMonitoringUserCredentialsResponse contains the response from method ManagedClustersClient.ListClusterMonitoringUserCredentials.

type ManagedClustersClientListClusterUserCredentialsOptions added in v0.3.0 

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 added in v0.3.0 

type ManagedClustersClientListClusterUserCredentialsResponse struct {
	CredentialResults
}

ManagedClustersClientListClusterUserCredentialsResponse contains the response from method ManagedClustersClient.ListClusterUserCredentials.

type ManagedClustersClientListOptions added in v0.3.0 

type ManagedClustersClientListOptions struct {
}

ManagedClustersClientListOptions contains the optional parameters for the ManagedClustersClient.List method.

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions added in v0.3.0 

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions struct {
}

ManagedClustersClientListOutboundNetworkDependenciesEndpointsOptions contains the optional parameters for the ManagedClustersClient.ListOutboundNetworkDependenciesEndpoints method.

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse added in v0.3.0 

type ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse struct {
	OutboundEnvironmentEndpointCollection
}

ManagedClustersClientListOutboundNetworkDependenciesEndpointsResponse contains the response from method ManagedClustersClient.ListOutboundNetworkDependenciesEndpoints.

type ManagedClustersClientListResponse added in v0.3.0 

type ManagedClustersClientListResponse struct {
	ManagedClusterListResult
}

ManagedClustersClientListResponse contains the response from method ManagedClustersClient.List.

type ManagedClustersClientResetAADProfileResponse added in v0.3.0 

type ManagedClustersClientResetAADProfileResponse struct {
}

ManagedClustersClientResetAADProfileResponse contains the response from method ManagedClustersClient.ResetAADProfile.

type ManagedClustersClientResetServicePrincipalProfileResponse added in v0.3.0 

type ManagedClustersClientResetServicePrincipalProfileResponse struct {
}

ManagedClustersClientResetServicePrincipalProfileResponse contains the response from method ManagedClustersClient.ResetServicePrincipalProfile.

type ManagedClustersClientRotateClusterCertificatesResponse added in v0.3.0 

type ManagedClustersClientRotateClusterCertificatesResponse struct {
}

ManagedClustersClientRotateClusterCertificatesResponse contains the response from method ManagedClustersClient.RotateClusterCertificates.

type ManagedClustersClientRunCommandResponse added in v0.3.0 

type ManagedClustersClientRunCommandResponse struct {
	RunCommandResult
}

ManagedClustersClientRunCommandResponse contains the response from method ManagedClustersClient.RunCommand.

type ManagedClustersClientStartResponse added in v0.3.0 

type ManagedClustersClientStartResponse struct {
}

ManagedClustersClientStartResponse contains the response from method ManagedClustersClient.Start.

type ManagedClustersClientStopResponse added in v0.3.0 

type ManagedClustersClientStopResponse struct {
}

ManagedClustersClientStopResponse contains the response from method ManagedClustersClient.Stop.

type ManagedClustersClientUpdateTagsResponse added in v0.3.0 

type ManagedClustersClientUpdateTagsResponse struct {
	ManagedCluster
}

ManagedClustersClientUpdateTagsResponse contains the response from method ManagedClustersClient.UpdateTags.

type ManagedServiceIdentityUserAssignedIdentitiesValue 

type ManagedServiceIdentityUserAssignedIdentitiesValue struct {
	// READ-ONLY; The client id of user assigned identity.
	ClientID *string `json:"clientId,omitempty" azure:"ro"`

	// READ-ONLY; The principal id of user assigned identity.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`
}

type MasterProfile added in v0.3.0 

type MasterProfile struct {
	// REQUIRED; DNS prefix to be used to create the FQDN for the master pool.
	DNSPrefix *string `json:"dnsPrefix,omitempty"`

	// REQUIRED; Size of agent VMs.
	VMSize *ContainerServiceVMSizeTypes `json:"vmSize,omitempty"`

	// Number of masters (VMs) in the container service cluster. Allowed values are 1, 3, and 5. The default value is 1.
	Count *Count `json:"count,omitempty"`

	// FirstConsecutiveStaticIP used to specify the first static ip of masters.
	FirstConsecutiveStaticIP *string `json:"firstConsecutiveStaticIP,omitempty"`

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

	// Storage profile specifies what kind of storage used. Choose from StorageAccount and ManagedDisks. Leave it empty, we will
	// choose for you based on the orchestrator choice.
	StorageProfile *ContainerServiceStorageProfileTypes `json:"storageProfile,omitempty"`

	// VNet SubnetID specifies the VNet's subnet identifier.
	VnetSubnetID *string `json:"vnetSubnetID,omitempty"`

	// READ-ONLY; FQDN for the master pool.
	Fqdn *string `json:"fqdn,omitempty" azure:"ro"`
}

MasterProfile - Profile for the container service master.

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

func PossibleNetworkPluginValues 

func PossibleNetworkPluginValues() []NetworkPlugin

PossibleNetworkPluginValues returns the possible values for the NetworkPlugin 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"
)

func PossibleNetworkPolicyValues 

func PossibleNetworkPolicyValues() []NetworkPolicy

PossibleNetworkPolicyValues returns the possible values for the NetworkPolicy const type.

type NetworkProfile added in v0.3.0 

type NetworkProfile struct {
	// An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes service address range specified
	// in serviceCidr.
	DNSServiceIP *string `json:"dnsServiceIP,omitempty"`

	// A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes
	// service address range.
	DockerBridgeCidr *string `json:"dockerBridgeCidr,omitempty"`

	// 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 `json:"ipFamilies,omitempty"`

	// Profile of the cluster load balancer.
	LoadBalancerProfile *ManagedClusterLoadBalancerProfile `json:"loadBalancerProfile,omitempty"`

	// 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 `json:"loadBalancerSku,omitempty"`

	// Profile of the cluster NAT gateway.
	NatGatewayProfile *ManagedClusterNATGatewayProfile `json:"natGatewayProfile,omitempty"`

	// This cannot be specified if networkPlugin is anything other than 'azure'.
	NetworkMode *NetworkMode `json:"networkMode,omitempty"`

	// Network plugin used for building the Kubernetes network.
	NetworkPlugin *NetworkPlugin `json:"networkPlugin,omitempty"`

	// Network policy used for building the Kubernetes network.
	NetworkPolicy *NetworkPolicy `json:"networkPolicy,omitempty"`

	// 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 `json:"outboundType,omitempty"`

	// A CIDR notation IP range from which to assign pod IPs when kubenet is used.
	PodCidr *string `json:"podCidr,omitempty"`

	// 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 `json:"podCidrs,omitempty"`

	// A CIDR notation IP range from which to assign service cluster IPs. It must not overlap with any Subnet IP ranges.
	ServiceCidr *string `json:"serviceCidr,omitempty"`

	// 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 `json:"serviceCidrs,omitempty"`
}

NetworkProfile - Profile of network configuration.

func (NetworkProfile) MarshalJSON added in v0.3.0 

func (n NetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkProfile.

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 OSOptionProfile 

type OSOptionProfile struct {
	// REQUIRED; The list of OS options.
	Properties *OSOptionPropertyList `json:"properties,omitempty"`

	// READ-ONLY; The ID of the OS option resource.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the OS option resource.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the OS option resource.
	Type *string `json:"type,omitempty" azure:"ro"`
}

OSOptionProfile - The OS option profile.

type OSOptionProperty 

type OSOptionProperty struct {
	// REQUIRED; Whether the image is FIPS-enabled.
	EnableFipsImage *bool `json:"enable-fips-image,omitempty"`

	// REQUIRED; The OS type.
	OSType *string `json:"os-type,omitempty"`
}

OSOptionProperty - OS option property.

type OSOptionPropertyList 

type OSOptionPropertyList struct {
	// REQUIRED; The list of OS options.
	OSOptionPropertyList []*OSOptionProperty `json:"osOptionPropertyList,omitempty"`
}

OSOptionPropertyList - The list of OS option properties.

type OSSKU 

type OSSKU string

OSSKU - Specifies an OS SKU. This value must not be specified if OSType is Windows. 

const (
	OSSKUCBLMariner OSSKU = "CBLMariner"
	OSSKUUbuntu     OSSKU = "Ubuntu"
)

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 `json:"value,omitempty" azure:"ro"`
}

OperationListResult - The List Operation response.

type OperationValue 

type OperationValue struct {
	// Describes the properties of a Operation Value Display.
	Display *OperationValueDisplay `json:"display,omitempty"`

	// READ-ONLY; The name of the operation.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The origin of the operation.
	Origin *string `json:"origin,omitempty" azure:"ro"`
}

OperationValue - Describes the properties of a Operation value.

type OperationValueDisplay 

type OperationValueDisplay struct {
	// READ-ONLY; The description of the operation.
	Description *string `json:"description,omitempty" azure:"ro"`

	// READ-ONLY; The display name of the operation.
	Operation *string `json:"operation,omitempty" azure:"ro"`

	// READ-ONLY; The resource provider for the operation.
	Provider *string `json:"provider,omitempty" azure:"ro"`

	// READ-ONLY; The display name of the resource the operation applies to.
	Resource *string `json:"resource,omitempty" azure:"ro"`
}

OperationValueDisplay - Describes the properties of a Operation Value Display.

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 added in v0.5.0 

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - Gets a list of operations. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 options - OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/Operation_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewOperationsClient(cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager(nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

type OperationsClientListOptions added in v0.3.0 

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

type OperationsClientListResponse added in v0.3.0 

type OperationsClientListResponse struct {
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type OutboundEnvironmentEndpoint 

type OutboundEnvironmentEndpoint struct {
	// The category of endpoints accessed by the AKS agent node, e.g. azure-resource-management, apiserver, etc.
	Category *string `json:"category,omitempty"`

	// The endpoints that AKS agent nodes connect to
	Endpoints []*EndpointDependency `json:"endpoints,omitempty"`
}

OutboundEnvironmentEndpoint - Egress endpoints which AKS agent nodes connect to for common purpose.

type OutboundEnvironmentEndpointCollection 

type OutboundEnvironmentEndpointCollection struct {
	// REQUIRED; Collection of resources.
	Value []*OutboundEnvironmentEndpoint `json:"value,omitempty"`

	// READ-ONLY; Link to next page of resources.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

OutboundEnvironmentEndpointCollection - Collection of OutboundEnvironmentEndpoint

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 PowerState 

type PowerState struct {
	// Tells whether the cluster is Running or Stopped
	Code *Code `json:"code,omitempty"`
}

PowerState - Describes the Power State of the cluster

type PrivateEndpoint 

type PrivateEndpoint struct {
	// The resource ID of the private endpoint
	ID *string `json:"id,omitempty"`
}

PrivateEndpoint - Private endpoint which a connection belongs to.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// The properties of a private endpoint connection.
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`

	// READ-ONLY; The ID of the private endpoint connection.
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the private endpoint connection.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The resource type.
	Type *string `json:"type,omitempty" azure:"ro"`
}

PrivateEndpointConnection - A private endpoint connection

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// The collection value.
	Value []*PrivateEndpointConnection `json:"value,omitempty"`
}

PrivateEndpointConnectionListResult - A list of private endpoint connections

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`

	// The resource of private endpoint.
	PrivateEndpoint *PrivateEndpoint `json:"privateEndpoint,omitempty"`

	// READ-ONLY; The current provisioning state.
	ProvisioningState *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty" azure:"ro"`
}

PrivateEndpointConnectionProperties - Properties of a private endpoint connection.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

const (
	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. 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/PrivateEndpointConnectionsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewPrivateEndpointConnectionsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/PrivateEndpointConnectionsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewPrivateEndpointConnectionsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"clustername1",
		"privateendpointconnection1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/PrivateEndpointConnectionsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewPrivateEndpointConnectionsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.List(ctx,
		"rg1",
		"clustername1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/PrivateEndpointConnectionsUpdate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewPrivateEndpointConnectionsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.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)
	}
	// TODO: use response item
	_ = res
}

Output:

type PrivateEndpointConnectionsClientBeginDeleteOptions added in v0.3.0 

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

PrivateEndpointConnectionsClientBeginDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginDelete method.

type PrivateEndpointConnectionsClientDeleteResponse added in v0.3.0 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.Delete.

type PrivateEndpointConnectionsClientGetOptions added in v0.3.0 

type PrivateEndpointConnectionsClientGetOptions struct {
}

PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

type PrivateEndpointConnectionsClientGetResponse added in v0.3.0 

type PrivateEndpointConnectionsClientGetResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListOptions added in v0.3.0 

type PrivateEndpointConnectionsClientListOptions struct {
}

PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.List method.

type PrivateEndpointConnectionsClientListResponse added in v0.3.0 

type PrivateEndpointConnectionsClientListResponse struct {
	PrivateEndpointConnectionListResult
}

PrivateEndpointConnectionsClientListResponse contains the response from method PrivateEndpointConnectionsClient.List.

type PrivateEndpointConnectionsClientUpdateOptions added in v0.3.0 

type PrivateEndpointConnectionsClientUpdateOptions struct {
}

PrivateEndpointConnectionsClientUpdateOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Update method.

type PrivateEndpointConnectionsClientUpdateResponse added in v0.3.0 

type PrivateEndpointConnectionsClientUpdateResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientUpdateResponse contains the response from method PrivateEndpointConnectionsClient.Update.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// The group ID of the resource.
	GroupID *string `json:"groupId,omitempty"`

	// The ID of the private link resource.
	ID *string `json:"id,omitempty"`

	// The name of the private link resource.
	Name *string `json:"name,omitempty"`

	// The RequiredMembers of the resource
	RequiredMembers []*string `json:"requiredMembers,omitempty"`

	// The resource type.
	Type *string `json:"type,omitempty"`

	// READ-ONLY; The private link service ID of the resource, this field is exposed only to NRP internally.
	PrivateLinkServiceID *string `json:"privateLinkServiceID,omitempty" azure:"ro"`
}

PrivateLinkResource - A private link resource

func (PrivateLinkResource) MarshalJSON 

func (p PrivateLinkResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller 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. 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/PrivateLinkResourcesList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewPrivateLinkResourcesClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.List(ctx,
		"rg1",
		"clustername1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

type PrivateLinkResourcesClientListOptions added in v0.3.0 

type PrivateLinkResourcesClientListOptions struct {
}

PrivateLinkResourcesClientListOptions contains the optional parameters for the PrivateLinkResourcesClient.List method.

type PrivateLinkResourcesClientListResponse added in v0.3.0 

type PrivateLinkResourcesClientListResponse struct {
	PrivateLinkResourcesListResult
}

PrivateLinkResourcesClientListResponse contains the response from method PrivateLinkResourcesClient.List.

type PrivateLinkResourcesListResult 

type PrivateLinkResourcesListResult struct {
	// The collection value.
	Value []*PrivateLinkResource `json:"value,omitempty"`
}

PrivateLinkResourcesListResult - A list of private link resources

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// The private link service connection description.
	Description *string `json:"description,omitempty"`

	// The private link service connection status.
	Status *ConnectionStatus `json:"status,omitempty"`
}

PrivateLinkServiceConnectionState - The state of a private link service connection.

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 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. 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/ResolvePrivateLinkServiceId.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewResolvePrivateLinkServiceIDClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.POST(ctx,
		"rg1",
		"clustername1",
		armcontainerservice.PrivateLinkResource{
			Name: to.Ptr("management"),
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

type ResolvePrivateLinkServiceIDClientPOSTOptions added in v0.3.0 

type ResolvePrivateLinkServiceIDClientPOSTOptions struct {
}

ResolvePrivateLinkServiceIDClientPOSTOptions contains the optional parameters for the ResolvePrivateLinkServiceIDClient.POST method.

type ResolvePrivateLinkServiceIDClientPOSTResponse added in v0.3.0 

type ResolvePrivateLinkServiceIDClientPOSTResponse struct {
	PrivateLinkResource
}

ResolvePrivateLinkServiceIDClientPOSTResponse contains the response from method ResolvePrivateLinkServiceIDClient.POST.

type Resource 

type Resource struct {
	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

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 (
	// 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"
	// ResourceIdentityTypeNone - Do not use a managed identity for the Managed Cluster, service principal will be used instead.
	ResourceIdentityTypeNone ResourceIdentityType = "None"
)

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 `json:"id,omitempty"`
}

ResourceReference - A reference to an Azure resource.

type RunCommandRequest 

type RunCommandRequest struct {
	// REQUIRED; The command to run.
	Command *string `json:"command,omitempty"`

	// AuthToken issued for AKS AAD Server App.
	ClusterToken *string `json:"clusterToken,omitempty"`

	// A base64 encoded zip file containing the files required by the command.
	Context *string `json:"context,omitempty"`
}

RunCommandRequest - A run command request

type RunCommandResult 

type RunCommandResult struct {
	// Properties of command result.
	Properties *CommandResultProperties `json:"properties,omitempty"`

	// READ-ONLY; The command id.
	ID *string `json:"id,omitempty" azure:"ro"`
}

RunCommandResult - run command result.

type SSHConfiguration added in v0.3.0 

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 `json:"publicKeys,omitempty"`
}

SSHConfiguration - SSH configuration for Linux-based VMs running on Azure.

func (SSHConfiguration) MarshalJSON added in v0.3.0 

func (s SSHConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SSHConfiguration.

type SSHPublicKey added in v0.3.0 

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 `json:"keyData,omitempty"`
}

SSHPublicKey - Contains information about SSH certificate public key data.

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 Snapshot 

type Snapshot struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// Properties of a snapshot.
	Properties *SnapshotProperties `json:"properties,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

Snapshot - A node pool snapshot resource.

func (Snapshot) MarshalJSON 

func (s Snapshot) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Snapshot.

type SnapshotListResult 

type SnapshotListResult struct {
	// The list of snapshots.
	Value []*Snapshot `json:"value,omitempty"`

	// READ-ONLY; The URL to get the next set of snapshot results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

SnapshotListResult - The response from the List Snapshots operation.

type SnapshotProperties 

type SnapshotProperties struct {
	// CreationData to be used to specify the source agent pool resource ID to create this snapshot.
	CreationData *CreationData `json:"creationData,omitempty"`

	// The type of a snapshot. The default is NodePool.
	SnapshotType *SnapshotType `json:"snapshotType,omitempty"`

	// READ-ONLY; Whether to use a FIPS-enabled OS.
	EnableFIPS *bool `json:"enableFIPS,omitempty" azure:"ro"`

	// READ-ONLY; The version of Kubernetes.
	KubernetesVersion *string `json:"kubernetesVersion,omitempty" azure:"ro"`

	// READ-ONLY; The version of node image.
	NodeImageVersion *string `json:"nodeImageVersion,omitempty" azure:"ro"`

	// READ-ONLY; Specifies an OS SKU. This value must not be specified if OSType is Windows.
	OSSKU *OSSKU `json:"osSku,omitempty" azure:"ro"`

	// READ-ONLY; The operating system type. The default is Linux.
	OSType *OSType `json:"osType,omitempty" azure:"ro"`

	// READ-ONLY; The size of the VM.
	VMSize *string `json:"vmSize,omitempty" azure:"ro"`
}

SnapshotProperties - Properties used to configure a node pool snapshot.

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. 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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsCreate.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.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/subid1/resourcegroups/rg1/providers/Microsoft.ContainerService/managedClusters/cluster1/agentPools/pool0"),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"snapshot1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*SnapshotsClient) NewListByResourceGroupPager added in v0.5.0 

func (client *SnapshotsClient) NewListByResourceGroupPager(resourceGroupName string, options *SnapshotsClientListByResourceGroupOptions) *runtime.Pager[SnapshotsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists snapshots in the specified subscription and resource group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 resourceGroupName - The name of the resource group. The name is case insensitive. options - SnapshotsClientListByResourceGroupOptions contains the optional parameters for the SnapshotsClient.ListByResourceGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByResourceGroupPager("rg1",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

func (*SnapshotsClient) NewListPager added in v0.5.0 

func (client *SnapshotsClient) NewListPager(options *SnapshotsClientListOptions) *runtime.Pager[SnapshotsClientListResponse]

NewListPager - Gets a list of snapshots in the specified subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2022-04-01 options - SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager(nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

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 2022-04-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/tree/main/specification/containerservice/resource-manager/Microsoft.ContainerService/stable/2022-04-01/examples/SnapshotsUpdateTags.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armcontainerservice.NewSnapshotsClient("subid1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.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)
	}
	// TODO: use response item
	_ = res
}

Output:

type SnapshotsClientCreateOrUpdateOptions added in v0.3.0 

type SnapshotsClientCreateOrUpdateOptions struct {
}

SnapshotsClientCreateOrUpdateOptions contains the optional parameters for the SnapshotsClient.CreateOrUpdate method.

type SnapshotsClientCreateOrUpdateResponse added in v0.3.0 

type SnapshotsClientCreateOrUpdateResponse struct {
	Snapshot
}

SnapshotsClientCreateOrUpdateResponse contains the response from method SnapshotsClient.CreateOrUpdate.

type SnapshotsClientDeleteOptions added in v0.3.0 

type SnapshotsClientDeleteOptions struct {
}

SnapshotsClientDeleteOptions contains the optional parameters for the SnapshotsClient.Delete method.

type SnapshotsClientDeleteResponse added in v0.3.0 

type SnapshotsClientDeleteResponse struct {
}

SnapshotsClientDeleteResponse contains the response from method SnapshotsClient.Delete.

type SnapshotsClientGetOptions added in v0.3.0 

type SnapshotsClientGetOptions struct {
}

SnapshotsClientGetOptions contains the optional parameters for the SnapshotsClient.Get method.

type SnapshotsClientGetResponse added in v0.3.0 

type SnapshotsClientGetResponse struct {
	Snapshot
}

SnapshotsClientGetResponse contains the response from method SnapshotsClient.Get.

type SnapshotsClientListByResourceGroupOptions added in v0.3.0 

type SnapshotsClientListByResourceGroupOptions struct {
}

SnapshotsClientListByResourceGroupOptions contains the optional parameters for the SnapshotsClient.ListByResourceGroup method.

type SnapshotsClientListByResourceGroupResponse added in v0.3.0 

type SnapshotsClientListByResourceGroupResponse struct {
	SnapshotListResult
}

SnapshotsClientListByResourceGroupResponse contains the response from method SnapshotsClient.ListByResourceGroup.

type SnapshotsClientListOptions added in v0.3.0 

type SnapshotsClientListOptions struct {
}

SnapshotsClientListOptions contains the optional parameters for the SnapshotsClient.List method.

type SnapshotsClientListResponse added in v0.3.0 

type SnapshotsClientListResponse struct {
	SnapshotListResult
}

SnapshotsClientListResponse contains the response from method SnapshotsClient.List.

type SnapshotsClientUpdateTagsOptions added in v0.3.0 

type SnapshotsClientUpdateTagsOptions struct {
}

SnapshotsClientUpdateTagsOptions contains the optional parameters for the SnapshotsClient.UpdateTags method.

type SnapshotsClientUpdateTagsResponse added in v0.3.0 

type SnapshotsClientUpdateTagsResponse struct {
	Snapshot
}

SnapshotsClientUpdateTagsResponse contains the response from method SnapshotsClient.UpdateTags.

type SubResource 

type SubResource struct {
	// READ-ONLY; Resource ID.
	ID *string `json:"id,omitempty" azure:"ro"`

	// 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 `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Resource type
	Type *string `json:"type,omitempty" azure:"ro"`
}

SubResource - Reference to another subresource.

type SysctlConfig 

type SysctlConfig struct {
	// Sysctl setting fs.aio-max-nr.
	FsAioMaxNr *int32 `json:"fsAioMaxNr,omitempty"`

	// Sysctl setting fs.file-max.
	FsFileMax *int32 `json:"fsFileMax,omitempty"`

	// Sysctl setting fs.inotify.maxuserwatches.
	FsInotifyMaxUserWatches *int32 `json:"fsInotifyMaxUserWatches,omitempty"`

	// Sysctl setting fs.nr_open.
	FsNrOpen *int32 `json:"fsNrOpen,omitempty"`

	// Sysctl setting kernel.threads-max.
	KernelThreadsMax *int32 `json:"kernelThreadsMax,omitempty"`

	// Sysctl setting net.core.netdevmaxbacklog.
	NetCoreNetdevMaxBacklog *int32 `json:"netCoreNetdevMaxBacklog,omitempty"`

	// Sysctl setting net.core.optmem_max.
	NetCoreOptmemMax *int32 `json:"netCoreOptmemMax,omitempty"`

	// Sysctl setting net.core.rmem_default.
	NetCoreRmemDefault *int32 `json:"netCoreRmemDefault,omitempty"`

	// Sysctl setting net.core.rmem_max.
	NetCoreRmemMax *int32 `json:"netCoreRmemMax,omitempty"`

	// Sysctl setting net.core.somaxconn.
	NetCoreSomaxconn *int32 `json:"netCoreSomaxconn,omitempty"`

	// Sysctl setting net.core.wmem_default.
	NetCoreWmemDefault *int32 `json:"netCoreWmemDefault,omitempty"`

	// Sysctl setting net.core.wmem_max.
	NetCoreWmemMax *int32 `json:"netCoreWmemMax,omitempty"`

	// Sysctl setting net.ipv4.iplocalport_range.
	NetIPv4IPLocalPortRange *string `json:"netIpv4IpLocalPortRange,omitempty"`

	// Sysctl setting net.ipv4.neigh.default.gc_thresh1.
	NetIPv4NeighDefaultGcThresh1 *int32 `json:"netIpv4NeighDefaultGcThresh1,omitempty"`

	// Sysctl setting net.ipv4.neigh.default.gc_thresh2.
	NetIPv4NeighDefaultGcThresh2 *int32 `json:"netIpv4NeighDefaultGcThresh2,omitempty"`

	// Sysctl setting net.ipv4.neigh.default.gc_thresh3.
	NetIPv4NeighDefaultGcThresh3 *int32 `json:"netIpv4NeighDefaultGcThresh3,omitempty"`

	// Sysctl setting net.ipv4.tcpfintimeout.
	NetIPv4TCPFinTimeout *int32 `json:"netIpv4TcpFinTimeout,omitempty"`

	// Sysctl setting net.ipv4.tcpkeepaliveprobes.
	NetIPv4TCPKeepaliveProbes *int32 `json:"netIpv4TcpKeepaliveProbes,omitempty"`

	// Sysctl setting net.ipv4.tcpkeepalivetime.
	NetIPv4TCPKeepaliveTime *int32 `json:"netIpv4TcpKeepaliveTime,omitempty"`

	// Sysctl setting net.ipv4.tcpmaxsyn_backlog.
	NetIPv4TCPMaxSynBacklog *int32 `json:"netIpv4TcpMaxSynBacklog,omitempty"`

	// Sysctl setting net.ipv4.tcpmaxtw_buckets.
	NetIPv4TCPMaxTwBuckets *int32 `json:"netIpv4TcpMaxTwBuckets,omitempty"`

	// Sysctl setting net.ipv4.tcptwreuse.
	NetIPv4TCPTwReuse *bool `json:"netIpv4TcpTwReuse,omitempty"`

	// Sysctl setting net.ipv4.tcpkeepaliveintvl.
	NetIPv4TcpkeepaliveIntvl *int32 `json:"netIpv4TcpkeepaliveIntvl,omitempty"`

	// Sysctl setting net.netfilter.nfconntrackbuckets.
	NetNetfilterNfConntrackBuckets *int32 `json:"netNetfilterNfConntrackBuckets,omitempty"`

	// Sysctl setting net.netfilter.nfconntrackmax.
	NetNetfilterNfConntrackMax *int32 `json:"netNetfilterNfConntrackMax,omitempty"`

	// Sysctl setting vm.maxmapcount.
	VMMaxMapCount *int32 `json:"vmMaxMapCount,omitempty"`

	// Sysctl setting vm.swappiness.
	VMSwappiness *int32 `json:"vmSwappiness,omitempty"`

	// Sysctl setting vm.vfscachepressure.
	VMVfsCachePressure *int32 `json:"vmVfsCachePressure,omitempty"`
}

SysctlConfig - Sysctl settings for Linux agent nodes.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time `json:"createdAt,omitempty"`

	// The identity that created the resource.
	CreatedBy *string `json:"createdBy,omitempty"`

	// The type of identity that created the resource.
	CreatedByType *CreatedByType `json:"createdByType,omitempty"`

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time `json:"lastModifiedAt,omitempty"`

	// The identity that last modified the resource.
	LastModifiedBy *string `json:"lastModifiedBy,omitempty"`

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType `json:"lastModifiedByType,omitempty"`
}

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 `json:"tags,omitempty"`
}

TagsObject - Tags object for patch operations.

func (TagsObject) MarshalJSON 

func (t TagsObject) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TagsObject.

type TimeInWeek 

type TimeInWeek struct {
	// The day of the week.
	Day *WeekDay `json:"day,omitempty"`

	// 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 `json:"hourSlots,omitempty"`
}

TimeInWeek - Time in a week.

func (TimeInWeek) MarshalJSON 

func (t TimeInWeek) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TimeInWeek.

type TimeSpan 

type TimeSpan struct {
	// The end of a time span
	End *time.Time `json:"end,omitempty"`

	// The start of a time span
	Start *time.Time `json:"start,omitempty"`
}

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 TrackedResource added in v0.5.0 

type TrackedResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'

func (TrackedResource) MarshalJSON added in v0.5.0 

func (t TrackedResource) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

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. Microsoft provides patches
	// and new images for image nodes frequently (usually weekly), but your running nodes won't get the new images unless you
	// do a node image upgrade. Turning on the node-image channel will automatically update your node images whenever a new version
	// is available.
	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 UserAssignedIdentity 

type UserAssignedIdentity struct {
	// The client ID of the user assigned identity.
	ClientID *string `json:"clientId,omitempty"`

	// The object ID of the user assigned identity.
	ObjectID *string `json:"objectId,omitempty"`

	// The resource ID of the user assigned identity.
	ResourceID *string `json:"resourceId,omitempty"`
}

UserAssignedIdentity - Details about a user assigned identity.

type VMDiagnostics added in v0.3.0 

type VMDiagnostics struct {
	// REQUIRED; Whether the VM diagnostic agent is provisioned on the VM.
	Enabled *bool `json:"enabled,omitempty"`

	// READ-ONLY; The URI of the storage account where diagnostics are stored.
	StorageURI *string `json:"storageUri,omitempty" azure:"ro"`
}

VMDiagnostics - Profile for diagnostics on the container service VMs.

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 WindowsGmsaProfile added in v0.2.0 

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 `json:"dnsServer,omitempty"`

	// Specifies whether to enable Windows gMSA in the managed cluster.
	Enabled *bool `json:"enabled,omitempty"`

	// 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 `json:"rootDomainName,omitempty"`
}

WindowsGmsaProfile - Windows gMSA Profile in the managed cluster.

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

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.