armextensions

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Apr 17, 2026 License: MIT Imports: 15 Imported by: 0

README

Azure Kubernetes Configuration Module for Go

The armextensions module provides operations for working with Azure Kubernetes Configuration.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Kubernetes Configuration module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions

Authorization

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

cred, err := azidentity.NewDefaultAzureCredential(nil)

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

Client Factory

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

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

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

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

Clients

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

client := clientFactory.NewClient()

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Kubernetesconfiguration 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 AKSIdentityType 

type AKSIdentityType string

AKSIdentityType - The identity type. 

const (
	// AKSIdentityTypeSystemAssigned - SystemAssigned identity
	AKSIdentityTypeSystemAssigned AKSIdentityType = "SystemAssigned"
	// AKSIdentityTypeUserAssigned - UserAssigned identity
	AKSIdentityTypeUserAssigned AKSIdentityType = "UserAssigned"
	// AKSIdentityTypeWorkload - Workload identity
	AKSIdentityTypeWorkload AKSIdentityType = "Workload"
)

func PossibleAKSIdentityTypeValues 

func PossibleAKSIdentityTypeValues() []AKSIdentityType

PossibleAKSIdentityTypeValues returns the possible values for the AKSIdentityType const type.

type AccessDetail added in v1.0.0 

type AccessDetail struct {
	// The list of allowed actions for the entity
	AllowedActions []*string

	// The description of the entity
	Description *string

	// The entity to which the access details apply
	Entity *string
}

AccessDetail - Metadata about the access details of the managing entity of the extension

func (AccessDetail) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AccessDetail.

func (*AccessDetail) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AccessDetail.

type AdditionalDetails added in v1.0.0 

type AdditionalDetails struct {
	// Documentation for the extension.
	Docs *string

	// Release Notes of the extension.
	ReleaseNotes *string

	// Troubleshooting guide for the extension.
	TroubleshootingGuide *string
}

AdditionalDetails - Additional details provided by the publisher of the extension.

func (AdditionalDetails) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AdditionalDetails.

func (*AdditionalDetails) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdditionalDetails.

type AutoUpgradeMode added in v1.0.0 

type AutoUpgradeMode string

AutoUpgradeMode - The upgrade mode for auto upgrade. The default is "compatible". 

const (
	// AutoUpgradeModeCompatible - The extension will be automatically upgraded to compatible versions as determined by the user.
	AutoUpgradeModeCompatible AutoUpgradeMode = "compatible"
	// AutoUpgradeModeNone - The extension will not be automatically upgraded.
	AutoUpgradeModeNone AutoUpgradeMode = "none"
	// AutoUpgradeModePatch - The extension will be automatically upgraded to the latest patch version within the minor version.
	AutoUpgradeModePatch AutoUpgradeMode = "patch"
)

func PossibleAutoUpgradeModeValues added in v1.0.0 

func PossibleAutoUpgradeModeValues() []AutoUpgradeMode

PossibleAutoUpgradeModeValues returns the possible values for the AutoUpgradeMode const type.

type Client 

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

Client contains the methods for the service. Don't use this type directly, use NewClient() instead.

func NewClient 

func NewClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*Client, error)

NewClient creates a new instance of Client with the specified values.

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

func (*Client) BeginCreate 

func (client *Client) BeginCreate(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionName string, extension Extension, options *ClientBeginCreateOptions) (*runtime.Poller[ClientCreateResponse], error)

BeginCreate - Create a new Kubernetes Cluster Extension. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • extensionName - Name of the Extension.
  • extension - Properties necessary to Create an Extension.
  • options - ClientBeginCreateOptions contains the optional parameters for the Client.BeginCreate method.
Example (CreateExtension)

Generated from example definition: 2025-03-01/CreateExtension.json 

package main

import (
	"context"
	"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/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginCreate(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", armextensions.Extension{
		Properties: &armextensions.ExtensionProperties{
			ExtensionType:           to.Ptr("azuremonitor-containers"),
			AutoUpgradeMode:         to.Ptr(armextensions.AutoUpgradeModeCompatible),
			AutoUpgradeMinorVersion: to.Ptr(true),
			ReleaseTrain:            to.Ptr("Preview"),
			Scope: &armextensions.Scope{
				Cluster: &armextensions.ScopeCluster{
					ReleaseNamespace: to.Ptr("kube-system"),
				},
			},
			ConfigurationSettings: map[string]*string{
				"omsagent.secret.wsid":     to.Ptr("fakeTokenPlaceholder"),
				"omsagent.env.clusterName": to.Ptr("clusterName1"),
			},
			ConfigurationProtectedSettings: map[string]*string{
				"omsagent.secret.key": to.Ptr("secretKeyValue01"),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientCreateResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("ClusterMonitor"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azuremonitor-containers"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 		},
	// 	},
	// }
}
Example (CreateExtensionWithPlan)

Generated from example definition: 2025-03-01/CreateExtensionWithPlan.json 

package main

import (
	"context"
	"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/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginCreate(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "azureVote", armextensions.Extension{
		Properties: &armextensions.ExtensionProperties{
			ExtensionType:           to.Ptr("azure-vote"),
			AutoUpgradeMode:         to.Ptr(armextensions.AutoUpgradeModeCompatible),
			AutoUpgradeMinorVersion: to.Ptr(true),
			ReleaseTrain:            to.Ptr("Preview"),
		},
		Plan: &armextensions.Plan{
			Name:      to.Ptr("azure-vote-standard"),
			Publisher: to.Ptr("Microsoft"),
			Product:   to.Ptr("azure-vote-standard-offer-id"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientCreateResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/azureVote"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("azureVote"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Plan: &armextensions.Plan{
	// 			Name: to.Ptr("azure-vote-standard"),
	// 			Publisher: to.Ptr("Microsoft"),
	// 			Product: to.Ptr("azure-vote-standard-offer-id"),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azure-vote"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateCreating),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			IsSystemExtension: to.Ptr(false),
	// 		},
	// 	},
	// }
}

func (*Client) BeginDelete 

func (client *Client) BeginDelete(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionName string, options *ClientBeginDeleteOptions) (*runtime.Poller[ClientDeleteResponse], error)

BeginDelete - Delete a Kubernetes Cluster Extension. This will cause the Agent to Uninstall the extension from the cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • extensionName - Name of the Extension.
  • options - ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.
Example

Generated from example definition: 2025-03-01/DeleteExtension.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginDelete(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientDeleteResponse{
	// }
}

func (*Client) BeginUpdate 

func (client *Client) BeginUpdate(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionName string, patchExtension PatchExtension, options *ClientBeginUpdateOptions) (*runtime.Poller[ClientUpdateResponse], error)

BeginUpdate - Patch an existing Kubernetes Cluster Extension. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • extensionName - Name of the Extension.
  • patchExtension - Properties to Patch in an existing Extension.
  • options - ClientBeginUpdateOptions contains the optional parameters for the Client.BeginUpdate method.
Example

Generated from example definition: 2025-03-01/PatchExtension.json 

package main

import (
	"context"
	"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/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewClient().BeginUpdate(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", armextensions.PatchExtension{
		Properties: &armextensions.PatchExtensionProperties{
			AutoUpgradeMode:         to.Ptr(armextensions.AutoUpgradeModeCompatible),
			AutoUpgradeMinorVersion: to.Ptr(true),
			ReleaseTrain:            to.Ptr("Preview"),
			ConfigurationSettings: map[string]*string{
				"omsagent.secret.wsid":     to.Ptr("fakeTokenPlaceholder"),
				"omsagent.env.clusterName": to.Ptr("clusterName1"),
			},
			ConfigurationProtectedSettings: map[string]*string{
				"omsagent.secret.key": to.Ptr("secretKeyValue01"),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientUpdateResponse{
	// 	Extension: &armextensions.Extension{
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azuremonitor-containers"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 		},
	// 	},
	// }
}

func (*Client) Get 

func (client *Client) Get(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionName string, options *ClientGetOptions) (ClientGetResponse, error)

Get - Gets Kubernetes Cluster Extension. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • extensionName - Name of the Extension.
  • options - ClientGetOptions contains the optional parameters for the Client.Get method.
Example (GetExtension)

Generated from example definition: 2025-03-01/GetExtension.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("ClusterMonitor"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azuremonitor-containers"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
	// 			AutoUpgradeMinorVersion: to.Ptr(false),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 		},
	// 	},
	// }
}
Example (GetExtensionWithAdditionalDetails)

Generated from example definition: 2025-03-01/GetExtensionWithAdditionalDetails.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("ClusterMonitor"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azuremonitor-containers"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 			AdditionalDetails: &armextensions.AdditionalDetails{
	// 				Docs: to.Ptr("https://foo.bar/docs"),
	// 				ReleaseNotes: to.Ptr("https://foo.bar/releasenotes"),
	// 				TroubleshootingGuide: to.Ptr("https://foo.bar/troubleshooting"),
	// 			},
	// 		},
	// 	},
	// }
}
Example (GetExtensionWithExtensionState)

Generated from example definition: 2025-03-01/GetExtensionWithExtensionState.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("ClusterMonitor"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azuremonitor-containers"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
	// 			AutoUpgradeMinorVersion: to.Ptr(false),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 			ExtensionState: to.Ptr("Ready"),
	// 		},
	// 	},
	// }
}
Example (GetExtensionWithManagedBy)

Generated from example definition: 2025-03-01/GetExtensionWithManagedBy.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.ContainerService", "managedClusters", "clusterName1", "azureVote", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.ContainerService/managedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/azureVote"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("azureVote"),
	// 		ManagedBy: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.ContainerService/managedClusters/clusterName1"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Plan: &armextensions.Plan{
	// 			Name: to.Ptr("azure-vote-standard"),
	// 			Publisher: to.Ptr("Microsoft"),
	// 			Product: to.Ptr("azure-vote-standard-offer-id"),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azure-vote"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 			ManagementDetails: &armextensions.ManagementDetails{
	// 				Category: to.Ptr("managed"),
	// 				AccessDetails: []*armextensions.AccessDetail{
	// 					{
	// 						Entity: to.Ptr("Microsoft.ContainerService"),
	// 						AllowedActions: []*string{
	// 							to.Ptr("Read"),
	// 							to.Ptr("Write"),
	// 						},
	// 						Description: to.Ptr(" Microsoft.ContainerService is only allowed to PUT/PATCH this extension instance."),
	// 					},
	// 					{
	// 						Entity: to.Ptr("Users"),
	// 						AllowedActions: []*string{
	// 							to.Ptr("Read"),
	// 						},
	// 						Description: to.Ptr("Users are allowed to only READ through Extensions RP."),
	// 					},
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}
Example (GetExtensionWithManagementDetails)

Generated from example definition: 2025-03-01/GetExtensionWithManagementDetails.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.ContainerService", "managedClusters", "clusterName1", "azureVote", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.ContainerService/managedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/azureVote"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("azureVote"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Plan: &armextensions.Plan{
	// 			Name: to.Ptr("azure-vote-standard"),
	// 			Publisher: to.Ptr("Microsoft"),
	// 			Product: to.Ptr("azure-vote-standard-offer-id"),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azure-vote"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeCompatible),
	// 			AutoUpgradeMinorVersion: to.Ptr(true),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 			ManagementDetails: &armextensions.ManagementDetails{
	// 				Category: to.Ptr("managed"),
	// 				AccessDetails: []*armextensions.AccessDetail{
	// 					{
	// 						Entity: to.Ptr("Microsoft.ContainerService"),
	// 						AllowedActions: []*string{
	// 							to.Ptr("Read"),
	// 							to.Ptr("Write"),
	// 						},
	// 						Description: to.Ptr(" Microsoft.ContainerService is only allowed to PUT/PATCH this extension instance."),
	// 					},
	// 					{
	// 						Entity: to.Ptr("Users"),
	// 						AllowedActions: []*string{
	// 							to.Ptr("Read"),
	// 						},
	// 						Description: to.Ptr("Users are allowed to only READ through Extensions RP."),
	// 					},
	// 				},
	// 			},
	// 		},
	// 	},
	// }
}
Example (GetExtensionWithPlan)

Generated from example definition: 2025-03-01/GetExtensionWithPlan.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().Get(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "azureVote", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.ClientGetResponse{
	// 	Extension: &armextensions.Extension{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/azureVote"),
	// 		Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
	// 		Name: to.Ptr("azureVote"),
	// 		SystemData: &armextensions.SystemData{
	// 			CreatedBy: to.Ptr("string"),
	// 			CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("string"),
	// 			LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
	// 		},
	// 		Plan: &armextensions.Plan{
	// 			Name: to.Ptr("azure-vote-standard"),
	// 			Publisher: to.Ptr("Microsoft"),
	// 			Product: to.Ptr("azure-vote-standard-offer-id"),
	// 		},
	// 		Properties: &armextensions.ExtensionProperties{
	// 			ExtensionType: to.Ptr("azure-vote"),
	// 			AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
	// 			AutoUpgradeMinorVersion: to.Ptr(false),
	// 			ReleaseTrain: to.Ptr("Preview"),
	// 			Version: to.Ptr("0.1.4"),
	// 			Scope: &armextensions.Scope{
	// 				Cluster: &armextensions.ScopeCluster{
	// 					ReleaseNamespace: to.Ptr("kube-system"),
	// 				},
	// 			},
	// 			ConfigurationSettings: map[string]*string{
	// 				"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
	// 				"omsagent.env.clusterName": to.Ptr("clusterName1"),
	// 			},
	// 			ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
	// 			CurrentVersion: to.Ptr("0.1.4"),
	// 			Statuses: []*armextensions.ExtensionStatus{
	// 			},
	// 			IsSystemExtension: to.Ptr(false),
	// 		},
	// 	},
	// }
}

func (*Client) NewListPager 

func (client *Client) NewListPager(resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, options *ClientListOptions) *runtime.Pager[ClientListResponse]

NewListPager - List all Extensions in the cluster.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • options - ClientListOptions contains the optional parameters for the Client.NewListPager method.
Example

Generated from example definition: 2025-03-01/ListExtensions.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewListPager("rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page = armextensions.ClientListResponse{
		// 	List: armextensions.List{
		// 		Value: []*armextensions.Extension{
		// 			{
		// 				ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor"),
		// 				Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
		// 				Name: to.Ptr("ClusterMonitor"),
		// 				SystemData: &armextensions.SystemData{
		// 					CreatedBy: to.Ptr("string"),
		// 					CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("string"),
		// 					LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
		// 				},
		// 				Properties: &armextensions.ExtensionProperties{
		// 					ExtensionType: to.Ptr("azuremonitor-containers"),
		// 					AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
		// 					AutoUpgradeMinorVersion: to.Ptr(false),
		// 					ReleaseTrain: to.Ptr("Preview"),
		// 					Version: to.Ptr("0.1.4"),
		// 					Scope: &armextensions.Scope{
		// 						Cluster: &armextensions.ScopeCluster{
		// 							ReleaseNamespace: to.Ptr("kube-system"),
		// 						},
		// 					},
		// 					ConfigurationSettings: map[string]*string{
		// 						"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
		// 						"omsagent.env.clusterName": to.Ptr("clusterName1"),
		// 					},
		// 					ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
		// 					CurrentVersion: to.Ptr("0.1.4"),
		// 					Statuses: []*armextensions.ExtensionStatus{
		// 					},
		// 					IsSystemExtension: to.Ptr(false),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/BackupVault01"),
		// 				Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
		// 				Name: to.Ptr("App1Monitor"),
		// 				SystemData: &armextensions.SystemData{
		// 					CreatedBy: to.Ptr("string"),
		// 					CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T04:09:23.011Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("string"),
		// 					LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T04:09:23.011Z"); return t}()),
		// 				},
		// 				Properties: &armextensions.ExtensionProperties{
		// 					ExtensionType: to.Ptr("Microsoft.RecoveryServices/recoveryVault"),
		// 					AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
		// 					AutoUpgradeMinorVersion: to.Ptr(false),
		// 					ReleaseTrain: to.Ptr("Stable"),
		// 					Version: nil,
		// 					Scope: &armextensions.Scope{
		// 						Cluster: &armextensions.ScopeCluster{
		// 							ReleaseNamespace: to.Ptr("myKVNamespace"),
		// 						},
		// 					},
		// 					ConfigurationSettings: map[string]*string{
		// 					},
		// 					ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
		// 					CurrentVersion: to.Ptr("1.0.1"),
		// 					Statuses: []*armextensions.ExtensionStatus{
		// 					},
		// 					IsSystemExtension: to.Ptr(false),
		// 				},
		// 			},
		// 			{
		// 				ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/azureVote"),
		// 				Type: to.Ptr("Microsoft.KubernetesConfiguration/extensions"),
		// 				Name: to.Ptr("azureVote"),
		// 				SystemData: &armextensions.SystemData{
		// 					CreatedBy: to.Ptr("string"),
		// 					CreatedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("string"),
		// 					LastModifiedByType: to.Ptr(armextensions.CreatedByTypeApplication),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-09-08T05:10:57.027Z"); return t}()),
		// 				},
		// 				Plan: &armextensions.Plan{
		// 					Name: to.Ptr("azure-vote-standard"),
		// 					Publisher: to.Ptr("Microsoft"),
		// 					Product: to.Ptr("azure-vote-standard-offer-id"),
		// 				},
		// 				Properties: &armextensions.ExtensionProperties{
		// 					ExtensionType: to.Ptr("azure-vote"),
		// 					AutoUpgradeMode: to.Ptr(armextensions.AutoUpgradeModeNone),
		// 					AutoUpgradeMinorVersion: to.Ptr(false),
		// 					ReleaseTrain: to.Ptr("Preview"),
		// 					Version: to.Ptr("0.1.4"),
		// 					Scope: &armextensions.Scope{
		// 						Cluster: &armextensions.ScopeCluster{
		// 							ReleaseNamespace: to.Ptr("kube-system"),
		// 						},
		// 					},
		// 					ConfigurationSettings: map[string]*string{
		// 						"omsagent.secret.wsid": to.Ptr("fakeTokenPlaceholder"),
		// 						"omsagent.env.clusterName": to.Ptr("clusterName1"),
		// 					},
		// 					ProvisioningState: to.Ptr(armextensions.ProvisioningStateSucceeded),
		// 					CurrentVersion: to.Ptr("0.1.4"),
		// 					Statuses: []*armextensions.ExtensionStatus{
		// 					},
		// 					IsSystemExtension: to.Ptr(false),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

type ClientBeginCreateOptions 

type ClientBeginCreateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClientBeginCreateOptions contains the optional parameters for the Client.BeginCreate method.

type ClientBeginDeleteOptions 

type ClientBeginDeleteOptions struct {
	// Delete the extension resource in Azure - not the normal asynchronous delete.
	ForceDelete *bool

	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.

type ClientBeginUpdateOptions 

type ClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

ClientBeginUpdateOptions contains the optional parameters for the Client.BeginUpdate method.

type ClientCreateResponse 

type ClientCreateResponse struct {
	// The Extension object.
	Extension
}

ClientCreateResponse contains the response from method Client.BeginCreate.

type ClientDeleteResponse 

type ClientDeleteResponse struct {
}

ClientDeleteResponse contains the response from method Client.BeginDelete.

type ClientFactory 

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

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

func NewClientFactory 

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

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

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

func (*ClientFactory) NewClient 

func (c *ClientFactory) NewClient() *Client

NewClient creates a new instance of Client.

func (*ClientFactory) NewOperationStatusClient 

func (c *ClientFactory) NewOperationStatusClient() *OperationStatusClient

NewOperationStatusClient creates a new instance of OperationStatusClient.

type ClientGetOptions 

type ClientGetOptions struct {
}

ClientGetOptions contains the optional parameters for the Client.Get method.

type ClientGetResponse 

type ClientGetResponse struct {
	// The Extension object.
	Extension
}

ClientGetResponse contains the response from method Client.Get.

type ClientListOptions 

type ClientListOptions struct {
}

ClientListOptions contains the optional parameters for the Client.NewListPager method.

type ClientListResponse 

type ClientListResponse struct {
	// Result of the request to list Extensions. It contains a list of Extension objects and a URL link to get the next set of
	// results.
	List
}

ClientListResponse contains the response from method Client.NewListPager.

type ClientUpdateResponse 

type ClientUpdateResponse struct {
	// The Extension object.
	Extension
}

ClientUpdateResponse contains the response from method Client.BeginUpdate.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

const (
	// CreatedByTypeApplication - The entity was created by an application.
	CreatedByTypeApplication CreatedByType = "Application"
	// CreatedByTypeKey - The entity was created by a key.
	CreatedByTypeKey CreatedByType = "Key"
	// CreatedByTypeManagedIdentity - The entity was created by a managed identity.
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	// CreatedByTypeUser - The entity was created by a user.
	CreatedByTypeUser CreatedByType = "User"
)

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info any

	// READ-ONLY; The additional info type.
	Type *string
}

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo

	// READ-ONLY; The error code.
	Code *string

	// READ-ONLY; The error details.
	Details []*ErrorDetail

	// READ-ONLY; The error message.
	Message *string

	// READ-ONLY; The error target.
	Target *string
}

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type Extension 

type Extension struct {
	// Identity of the Extension resource
	Identity *Identity

	// The fully qualified resource ID of the resource that manages this resource. Indicates if this resource is managed by another
	// Azure resource. If this is present, complete mode deployment will not delete the resource if it is removed from the template
	// since it is managed by another resource.
	ManagedBy *string

	// Details of the resource plan.
	Plan *Plan

	// Properties of an Extension resource
	Properties *ExtensionProperties

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

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

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

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

Extension - The Extension object.

func (Extension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Extension.

func (*Extension) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Extension.

type ExtensionProperties 

type ExtensionProperties struct {
	// Additional details provided by the publisher of the extension.
	AdditionalDetails *AdditionalDetails

	// Identity of the Extension resource in an AKS cluster
	AksAssignedIdentity *ExtensionPropertiesAksAssignedIdentity

	// Flag to note if this extension participates in auto upgrade of minor version, or not.
	AutoUpgradeMinorVersion *bool

	// The upgrade mode for auto upgrade.
	// The default is "compatible".
	AutoUpgradeMode *AutoUpgradeMode

	// Configuration settings that are sensitive, as name-value pairs for configuring this extension.
	ConfigurationProtectedSettings map[string]*string

	// Configuration settings, as name-value pairs for configuring this extension.
	ConfigurationSettings map[string]*string

	// Type of the Extension, of which this resource is an instance of. It must be one of the Extension Types registered with
	// Microsoft.KubernetesConfiguration by the Extension publisher.
	ExtensionType *string

	// Management details of the extension
	ManagementDetails *ManagementDetails

	// ReleaseTrain this extension participates in for auto-upgrade (e.g. Stable, Preview, etc.) - only if autoUpgradeMinorVersion
	// is 'true'.
	ReleaseTrain *string

	// Scope at which the extension is installed.
	Scope *Scope

	// Status from this extension.
	Statuses []*ExtensionStatus

	// User-specified version of the extension for this extension to 'pin'. To use 'version', autoUpgradeMinorVersion must be
	// 'false'.
	Version *string

	// READ-ONLY; Currently installed version of the extension.
	CurrentVersion *string

	// READ-ONLY; Custom Location settings properties.
	CustomLocationSettings map[string]*string

	// READ-ONLY; Error information from the Agent - e.g. errors during installation.
	ErrorInfo *ErrorDetail

	// READ-ONLY; State of the extension on the cluster.
	ExtensionState *string

	// READ-ONLY; Flag to note if this extension is a system extension
	IsSystemExtension *bool

	// READ-ONLY; Uri of the Helm package
	PackageURI *string

	// READ-ONLY; Status of installation of this extension.
	ProvisioningState *ProvisioningState
}

ExtensionProperties - Properties of an Extension resource

func (ExtensionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionProperties.

func (*ExtensionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionProperties.

type ExtensionPropertiesAksAssignedIdentity 

type ExtensionPropertiesAksAssignedIdentity struct {
	// The client ID of resource identity.
	ClientID *string

	// The object ID of resource identity.
	ObjectID *string

	// The ID of the resource identity.
	ResourceID *string

	// The identity type.
	Type *AKSIdentityType

	// READ-ONLY; The principal ID of resource identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of resource.
	TenantID *string
}

ExtensionPropertiesAksAssignedIdentity - Identity of the Extension resource in an AKS cluster

func (ExtensionPropertiesAksAssignedIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionPropertiesAksAssignedIdentity.

func (*ExtensionPropertiesAksAssignedIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionPropertiesAksAssignedIdentity.

type ExtensionStatus 

type ExtensionStatus struct {
	// Status code provided by the Extension
	Code *string

	// Short description of status of the extension.
	DisplayStatus *string

	// Level of the status.
	Level *LevelType

	// Detailed message of the status from the Extension.
	Message *string

	// DateLiteral (per ISO8601) noting the time of installation status.
	Time *string
}

ExtensionStatus - Status from the extension.

func (ExtensionStatus) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionStatus.

func (*ExtensionStatus) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionStatus.

type Identity 

type Identity struct {
	// FLAG; CONSTANT; The identity type.
	// Field has constant value "SystemAssigned", any specified value is ignored.
	Type *string

	// READ-ONLY; The principal ID of resource identity. The value must be an UUID.
	PrincipalID *string

	// READ-ONLY; The tenant ID of resource. The value must be an UUID.
	TenantID *string
}

Identity for the resource.

func (Identity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Identity.

func (*Identity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Identity.

type LevelType 

type LevelType string

LevelType - Level of the status. 

const (
	// LevelTypeError - Indicates an error status from the extension.
	LevelTypeError LevelType = "Error"
	// LevelTypeInformation - Indicates an informational status from the extension.
	LevelTypeInformation LevelType = "Information"
	// LevelTypeWarning - Indicates a warning status from the extension.
	LevelTypeWarning LevelType = "Warning"
)

func PossibleLevelTypeValues 

func PossibleLevelTypeValues() []LevelType

PossibleLevelTypeValues returns the possible values for the LevelType const type.

type List 

type List struct {
	// REQUIRED; The Extension items on this page
	Value []*Extension

	// The link to the next page of items
	NextLink *string
}

List - Result of the request to list Extensions. It contains a list of Extension objects and a URL link to get the next set of results.

func (List) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type List.

func (*List) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type List.

type ManagementDetails added in v1.0.0 

type ManagementDetails struct {
	// The list of access details of the managing entity
	AccessDetails []*AccessDetail

	// The category of the managing entity
	Category *string
}

ManagementDetails - Metadata about the managing entity of the extension and the permitted operations.

func (ManagementDetails) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type ManagementDetails.

func (*ManagementDetails) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagementDetails.

type OperationStatusClient 

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

OperationStatusClient contains the methods for the OperationStatus group. Don't use this type directly, use NewOperationStatusClient() instead.

func NewOperationStatusClient 

func NewOperationStatusClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationStatusClient, error)

NewOperationStatusClient creates a new instance of OperationStatusClient with the specified values.

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

func (*OperationStatusClient) Get 

func (client *OperationStatusClient) Get(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionName string, operationID string, options *OperationStatusClientGetOptions) (OperationStatusClientGetResponse, error)

Get - Get Async Operation status If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-03-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • clusterRp - The Kubernetes cluster RP - i.e. Microsoft.ContainerService, Microsoft.Kubernetes, Microsoft.HybridContainerService.
  • clusterResourceName - The Kubernetes cluster resource name - i.e. managedClusters, connectedClusters, provisionedClusters, appliances.
  • clusterName - The name of the kubernetes cluster.
  • extensionName - Name of the Extension.
  • options - OperationStatusClientGetOptions contains the optional parameters for the OperationStatusClient.Get method.
Example

Generated from example definition: 2025-03-01/GetExtensionAsyncOperationStatus.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensions"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensions.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOperationStatusClient().Get(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "clusterName1", "ClusterMonitor", "99999999-9999-9999-9999-999999999999", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensions.OperationStatusClientGetResponse{
	// 	OperationStatusResult: &armextensions.OperationStatusResult{
	// 		ID: to.Ptr("/subscriptions/subId1/resourceGroups/rg1/providers/Microsoft.Kubernetes/connectedClusters/clusterName1/providers/Microsoft.KubernetesConfiguration/extensions/ClusterMonitor/operations/99999999-9999-9999-9999-999999999999"),
	// 		Name: to.Ptr("99999999-9999-9999-9999-999999999999"),
	// 		Status: to.Ptr("Succeeded"),
	// 		Properties: map[string]*string{
	// 		},
	// 		Error: nil,
	// 	},
	// }
}

type OperationStatusClientGetOptions 

type OperationStatusClientGetOptions struct {
}

OperationStatusClientGetOptions contains the optional parameters for the OperationStatusClient.Get method.

type OperationStatusClientGetResponse 

type OperationStatusClientGetResponse struct {
	// The current status of an async operation.
	OperationStatusResult
}

OperationStatusClientGetResponse contains the response from method OperationStatusClient.Get.

type OperationStatusResult 

type OperationStatusResult struct {
	// REQUIRED; Operation status.
	Status *string

	// Fully qualified ID for the async operation.
	ID *string

	// Name of the async operation.
	Name *string

	// Additional information, if available.
	Properties map[string]*string

	// READ-ONLY; If present, details of the operation error.
	Error *ErrorDetail
}

OperationStatusResult - The current status of an async operation.

func (OperationStatusResult) MarshalJSON 

func (o OperationStatusResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationStatusResult.

func (*OperationStatusResult) UnmarshalJSON 

func (o *OperationStatusResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationStatusResult.

type PatchExtension 

type PatchExtension struct {
	// Updatable properties of an Extension Patch Request
	Properties *PatchExtensionProperties
}

PatchExtension - The Extension Patch Request object.

func (PatchExtension) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PatchExtension.

func (*PatchExtension) UnmarshalJSON 

func (p *PatchExtension) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PatchExtension.

type PatchExtensionProperties 

type PatchExtensionProperties struct {
	// Flag to note if this extension participates in auto upgrade of minor version, or not.
	AutoUpgradeMinorVersion *bool

	// The upgrade mode for auto upgrade.
	// The default is "compatible".
	AutoUpgradeMode *AutoUpgradeMode

	// Configuration settings that are sensitive, as name-value pairs for configuring this extension.
	ConfigurationProtectedSettings map[string]*string

	// Configuration settings, as name-value pairs for configuring this extension.
	ConfigurationSettings map[string]*string

	// ReleaseTrain this extension participates in for auto-upgrade (e.g. Stable, Preview, etc.) - only if autoUpgradeMinorVersion
	// is 'true'.
	ReleaseTrain *string

	// Version of the extension for this extension, if it is 'pinned' to a specific version. autoUpgradeMinorVersion must be 'false'.
	Version *string
}

PatchExtensionProperties - Updatable properties of an Extension Patch Request

func (PatchExtensionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PatchExtensionProperties.

func (*PatchExtensionProperties) UnmarshalJSON 

func (p *PatchExtensionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PatchExtensionProperties.

type Plan 

type Plan struct {
	// REQUIRED; A user defined name of the 3rd Party Artifact that is being procured.
	Name *string

	// REQUIRED; The 3rd Party artifact that is being procured. E.g. NewRelic. Product maps to the OfferID specified for the artifact
	// at the time of Data Market onboarding.
	Product *string

	// REQUIRED; The publisher of the 3rd Party Artifact that is being bought. E.g. NewRelic
	Publisher *string

	// A publisher provided promotion code as provisioned in Data Market for the said product/artifact.
	PromotionCode *string

	// The version of the desired product/artifact.
	Version *string
}

Plan for the resource.

func (Plan) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Plan.

func (*Plan) UnmarshalJSON 

func (p *Plan) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Plan.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The provisioning state of the resource. 

const (
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateCreating - Resource is being created.
	ProvisioningStateCreating ProvisioningState = "Creating"
	// ProvisioningStateDeleting - Resource is being deleted.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - Resource is being updated.
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type Scope 

type Scope struct {
	// Specifies that the scope of the extension is Cluster
	Cluster *ScopeCluster

	// Specifies that the scope of the extension is Namespace
	Namespace *ScopeNamespace
}

Scope of the extension. It can be either Cluster or Namespace; but not both.

func (Scope) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Scope.

func (*Scope) UnmarshalJSON 

func (s *Scope) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Scope.

type ScopeCluster 

type ScopeCluster struct {
	// Namespace where the extension Release must be placed, for a Cluster scoped extension. If this namespace does not exist,
	// it will be created
	ReleaseNamespace *string
}

ScopeCluster - Specifies that the scope of the extension is Cluster

func (ScopeCluster) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ScopeCluster.

func (*ScopeCluster) UnmarshalJSON 

func (s *ScopeCluster) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScopeCluster.

type ScopeNamespace 

type ScopeNamespace struct {
	// Namespace where the extension will be created for an Namespace scoped extension. If this namespace does not exist, it will
	// be created
	TargetNamespace *string
}

ScopeNamespace - Specifies that the scope of the extension is Namespace

func (ScopeNamespace) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ScopeNamespace.

func (*ScopeNamespace) UnmarshalJSON 

func (s *ScopeNamespace) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ScopeNamespace.

type SystemData 

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.