armextensiontypes

package module
v0.2.0 Latest Latest
Warning

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

 Go to latest Published: Mar 12, 2026 License: MIT Imports: 15 Imported by: 0

README

Azure Kubernetes Configuration Module for Go

The armextensiontypes 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/armextensiontypes

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 := armextensiontypes.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 := armextensiontypes.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 Kubernetes Configuration 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 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) ClusterGetVersion 

func (client *Client) ClusterGetVersion(ctx context.Context, resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionTypeName string, versionNumber string, options *ClientClusterGetVersionOptions) (ClientClusterGetVersionResponse, error)

ClusterGetVersion - Get details of a version for an Extension Type installable to the cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01-preview

  • 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.
  • extensionTypeName - Name of the Extension Type.
  • versionNumber - Version number of the Extension Type.
  • options - ClientClusterGetVersionOptions contains the optional parameters for the Client.ClusterGetVersion method.
Example

Generated from example definition: 2024-11-01-preview/GetExtensionTypeVersion.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().ClusterGetVersion(ctx, "rg1", "Microsoft.Kubernetes", "connectedClusters", "my-cluster", "my-extension-type", "v1.3.2", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armextensiontypes.ClientClusterGetVersionResponse{
	// 	ExtensionTypeVersionForReleaseTrain: &armextensiontypes.ExtensionTypeVersionForReleaseTrain{
	// 		Name: to.Ptr("bbbb"),
	// 		Type: to.Ptr("cccc"),
	// 		ID: to.Ptr("aaaa"),
	// 		Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
	// 			SupportedClusterTypes: []*string{
	// 				to.Ptr("connectedCluster"),
	// 			},
	// 			UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
	// 				Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 							to.Ptr("1.18..1.21"),
	// 						},
	// 					},
	// 				},
	// 				ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("GKE"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 							to.Ptr(">1.22"),
	// 						},
	// 					},
	// 				},
	// 				ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 				},
	// 				ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 				},
	// 			},
	// 			Version: to.Ptr("1.1.0"),
	// 		},
	// 	},
	// }
}

func (*Client) Get 

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

Get - Get an Extension Type installable to the cluster based region and type for the cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01-preview

  • 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.
  • extensionTypeName - Name of the Extension Type.
  • options - ClientGetOptions contains the optional parameters for the Client.Get method.
Example

Generated from example definition: 2024-11-01-preview/GetExtensionType.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.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", "my-cluster", "my-extension-type", 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 = armextensiontypes.ClientGetResponse{
	// 	ExtensionType: &armextensiontypes.ExtensionType{
	// 		Name: to.Ptr("bbbb"),
	// 		Type: to.Ptr("cccc"),
	// 		ID: to.Ptr("aaaa"),
	// 		Properties: &armextensiontypes.ExtensionTypeProperties{
	// 			Description: to.Ptr("My extension type!"),
	// 			IsManagedIdentityRequired: to.Ptr(true),
	// 			IsSystemExtension: to.Ptr(false),
	// 			PlanInfo: &armextensiontypes.ExtensionTypePropertiesPlanInfo{
	// 				OfferID: to.Ptr("3333333"),
	// 				PlanID: to.Ptr("222222"),
	// 				PublisherID: to.Ptr("111111"),
	// 			},
	// 			Publisher: to.Ptr("Microsoft"),
	// 			SupportedClusterTypes: []*string{
	// 				to.Ptr("connectedClusters"),
	// 			},
	// 			SupportedScopes: &armextensiontypes.ExtensionTypePropertiesSupportedScopes{
	// 				ClusterScopeSettings: &armextensiontypes.ClusterScopeSettings{
	// 					Name: to.Ptr("bbbbbbbbbbbbb"),
	// 					Type: to.Ptr("ccccccccccccccccccccccccc"),
	// 					ID: to.Ptr("aaaaaaaaaaaaaaaaaa"),
	// 					Properties: &armextensiontypes.ClusterScopeSettingsProperties{
	// 						AllowMultipleInstances: to.Ptr(true),
	// 						DefaultReleaseNamespace: to.Ptr("kube-system"),
	// 					},
	// 				},
	// 				DefaultScope: to.Ptr("cluster"),
	// 			},
	// 		},
	// 	},
	// }
}

func (*Client) GetVersion 

func (client *Client) GetVersion(ctx context.Context, location string, extensionTypeName string, versionNumber string, options *ClientGetVersionOptions) (ClientGetVersionResponse, error)

GetVersion - Get details of a version for an extension type and location If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01-preview

  • location - The location name.
  • extensionTypeName - Name of the Extension Type.
  • versionNumber - Version number of the Extension Type.
  • options - ClientGetVersionOptions contains the optional parameters for the Client.GetVersion method.
Example

Generated from example definition: 2024-11-01-preview/GetExtensionTypeVersionByLocation.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().GetVersion(ctx, "westus", "extensionType1", "1.20.0", 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 = armextensiontypes.ClientGetVersionResponse{
	// 	ExtensionTypeVersionForReleaseTrain: &armextensiontypes.ExtensionTypeVersionForReleaseTrain{
	// 		Name: to.Ptr("bbbb"),
	// 		Type: to.Ptr("cccc"),
	// 		ID: to.Ptr("aaaa"),
	// 		Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
	// 			SupportedClusterTypes: []*string{
	// 				to.Ptr("connectedCluster"),
	// 			},
	// 			UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
	// 				Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 							to.Ptr("1.18..1.21"),
	// 						},
	// 					},
	// 				},
	// 				ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("GKE"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 							to.Ptr(">1.22"),
	// 						},
	// 					},
	// 				},
	// 				ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 				},
	// 				ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
	// 					{
	// 						Distributions: []*string{
	// 							to.Ptr("AKS"),
	// 						},
	// 						UnsupportedVersions: []*string{
	// 						},
	// 					},
	// 				},
	// 			},
	// 			Version: to.Ptr("1.1.0"),
	// 		},
	// 	},
	// }
}

func (*Client) LocationGet 

func (client *Client) LocationGet(ctx context.Context, location string, extensionTypeName string, options *ClientLocationGetOptions) (ClientLocationGetResponse, error)

LocationGet - Get an extension type for the location. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01-preview

  • location - The location name.
  • extensionTypeName - Name of the Extension Type.
  • options - ClientLocationGetOptions contains the optional parameters for the Client.LocationGet method.
Example

Generated from example definition: 2024-11-01-preview/GetExtensionTypeByLocation.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewClient().LocationGet(ctx, "westus2", "extensionType1", 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 = armextensiontypes.ClientLocationGetResponse{
	// 	ExtensionType: &armextensiontypes.ExtensionType{
	// 		Name: to.Ptr("bbbb"),
	// 		Type: to.Ptr("cccc"),
	// 		ID: to.Ptr("aaaa"),
	// 		Properties: &armextensiontypes.ExtensionTypeProperties{
	// 			Description: to.Ptr("My extension type!"),
	// 			IsManagedIdentityRequired: to.Ptr(true),
	// 			IsSystemExtension: to.Ptr(false),
	// 			PlanInfo: &armextensiontypes.ExtensionTypePropertiesPlanInfo{
	// 				OfferID: to.Ptr("myOfferId"),
	// 				PlanID: to.Ptr("myPlanId"),
	// 				PublisherID: to.Ptr("myPublisherId"),
	// 			},
	// 			Publisher: to.Ptr("Microsoft"),
	// 			SupportedClusterTypes: []*string{
	// 				to.Ptr("connectedClusters"),
	// 			},
	// 			SupportedScopes: &armextensiontypes.ExtensionTypePropertiesSupportedScopes{
	// 				ClusterScopeSettings: &armextensiontypes.ClusterScopeSettings{
	// 					Name: to.Ptr("bbbbbbbbbbbbb"),
	// 					Type: to.Ptr("ccccccccccccccccccccccccc"),
	// 					ID: to.Ptr("aaaaaaaaaaaaaaaaaa"),
	// 					Properties: &armextensiontypes.ClusterScopeSettingsProperties{
	// 						AllowMultipleInstances: to.Ptr(true),
	// 						DefaultReleaseNamespace: to.Ptr("kube-system"),
	// 					},
	// 				},
	// 				DefaultScope: to.Ptr("cluster"),
	// 			},
	// 		},
	// 	},
	// }
}

func (*Client) NewClusterListVersionsPager 

func (client *Client) NewClusterListVersionsPager(resourceGroupName string, clusterRp string, clusterResourceName string, clusterName string, extensionTypeName string, options *ClientClusterListVersionsOptions) *runtime.Pager[ClientClusterListVersionsResponse]

NewClusterListVersionsPager - List the version for an Extension Type installable to the cluster.

Generated from API version 2024-11-01-preview

  • 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.
  • extensionTypeName - Name of the Extension Type.
  • options - ClientClusterListVersionsOptions contains the optional parameters for the Client.NewClusterListVersionsPager method.
Example

Generated from example definition: 2024-11-01-preview/ListExtensionTypeVersions.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/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewClusterListVersionsPager("rg1", "Microsoft.Kubernetes", "connectedClusters", "my-cluster", "my-extension-type", &armextensiontypes.ClientClusterListVersionsOptions{
		MajorVersion: to.Ptr("2"),
		ReleaseTrain: to.Ptr("stable"),
		ShowLatest:   to.Ptr(true)})
	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 = armextensiontypes.ClientClusterListVersionsResponse{
		// 	ExtensionTypeVersionsList: armextensiontypes.ExtensionTypeVersionsList{
		// 		Value: []*armextensiontypes.ExtensionTypeVersionForReleaseTrain{
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedCluster"),
		// 					},
		// 					UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
		// 						Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr("1.18..1.21"),
		// 								},
		// 							},
		// 						},
		// 						ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("GKE"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr(">1.22"),
		// 								},
		// 							},
		// 						},
		// 						ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 						ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 					},
		// 					Version: to.Ptr("1.1.0"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedCluster"),
		// 					},
		// 					UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
		// 						Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr("1.18..1.21"),
		// 								},
		// 							},
		// 						},
		// 						ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("GKE"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr(">1.22"),
		// 								},
		// 							},
		// 						},
		// 						ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 						ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 					},
		// 					Version: to.Ptr("1.2.0"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*Client) NewListPager 

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

NewListPager - List installable Extension Types for the cluster based region and type for the cluster.

Generated from API version 2024-11-01-preview

  • 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: 2024-11-01-preview/ListExtensionTypes.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/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewListPager("rg1", "Microsoft.Kubernetes", "connectedClusters", "my-cluster", &armextensiontypes.ClientListOptions{
		OfferID:      to.Ptr("myOfferId"),
		PlanID:       to.Ptr("myPlanId"),
		PublisherID:  to.Ptr("myPublisherId"),
		ReleaseTrain: to.Ptr("stable")})
	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 = armextensiontypes.ClientListResponse{
		// 	List: armextensiontypes.List{
		// 		Value: []*armextensiontypes.ExtensionType{
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeProperties{
		// 					Description: to.Ptr("My extension type!"),
		// 					IsManagedIdentityRequired: to.Ptr(true),
		// 					IsSystemExtension: to.Ptr(false),
		// 					PlanInfo: &armextensiontypes.ExtensionTypePropertiesPlanInfo{
		// 						OfferID: to.Ptr("myOfferId"),
		// 						PlanID: to.Ptr("myPlanId"),
		// 						PublisherID: to.Ptr("myPublisherId"),
		// 					},
		// 					Publisher: to.Ptr("Microsoft"),
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedClusters"),
		// 					},
		// 					SupportedScopes: &armextensiontypes.ExtensionTypePropertiesSupportedScopes{
		// 						ClusterScopeSettings: &armextensiontypes.ClusterScopeSettings{
		// 							Name: to.Ptr("bbbbbbbbbbbbb"),
		// 							Type: to.Ptr("ccccccccccccccccccccccccc"),
		// 							ID: to.Ptr("aaaaaaaaaaaaaaaaaa"),
		// 							Properties: &armextensiontypes.ClusterScopeSettingsProperties{
		// 								AllowMultipleInstances: to.Ptr(true),
		// 								DefaultReleaseNamespace: to.Ptr("kube-system"),
		// 							},
		// 						},
		// 						DefaultScope: to.Ptr("cluster"),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*Client) NewListVersionsPager 

func (client *Client) NewListVersionsPager(location string, extensionTypeName string, options *ClientListVersionsOptions) *runtime.Pager[ClientListVersionsResponse]

NewListVersionsPager - List the versions for an extension type and location.

Generated from API version 2024-11-01-preview

  • location - The location name.
  • extensionTypeName - Name of the Extension Type.
  • options - ClientListVersionsOptions contains the optional parameters for the Client.NewListVersionsPager method.
Example

Generated from example definition: 2024-11-01-preview/ListExtensionTypeVersionsByLocation.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/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewListVersionsPager("westus", "extensionType1", &armextensiontypes.ClientListVersionsOptions{
		ClusterType:  to.Ptr("connectedCluster"),
		MajorVersion: to.Ptr("2"),
		ReleaseTrain: to.Ptr("stable"),
		ShowLatest:   to.Ptr(true)})
	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 = armextensiontypes.ClientListVersionsResponse{
		// 	ExtensionTypeVersionsList: armextensiontypes.ExtensionTypeVersionsList{
		// 		Value: []*armextensiontypes.ExtensionTypeVersionForReleaseTrain{
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedCluster"),
		// 					},
		// 					UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
		// 						Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr("1.18..1.21"),
		// 								},
		// 							},
		// 						},
		// 						ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("GKE"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr(">1.22"),
		// 								},
		// 							},
		// 						},
		// 						ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 						ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 					},
		// 					Version: to.Ptr("1.1.0"),
		// 				},
		// 			},
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeVersionForReleaseTrainProperties{
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedCluster"),
		// 					},
		// 					UnsupportedKubernetesVersions: &armextensiontypes.ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions{
		// 						Appliances: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr("1.18..1.21"),
		// 								},
		// 							},
		// 						},
		// 						ConnectedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("GKE"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 									to.Ptr(">1.22"),
		// 								},
		// 							},
		// 						},
		// 						ManagedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 						ProvisionedCluster: []*armextensiontypes.ExtensionTypeVersionUnsupportedKubernetesMatrixItem{
		// 							{
		// 								Distributions: []*string{
		// 									to.Ptr("AKS"),
		// 								},
		// 								UnsupportedVersions: []*string{
		// 								},
		// 							},
		// 						},
		// 					},
		// 					Version: to.Ptr("1.2.0"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

func (*Client) NewLocationListPager 

func (client *Client) NewLocationListPager(location string, options *ClientLocationListOptions) *runtime.Pager[ClientLocationListResponse]

NewLocationListPager - List all Extension Types for the location.

Generated from API version 2024-11-01-preview

  • location - The location name.
  • options - ClientLocationListOptions contains the optional parameters for the Client.NewLocationListPager method.
Example

Generated from example definition: 2024-11-01-preview/ListExtensionTypesByLocation.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/kubernetesconfiguration/armextensiontypes"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armextensiontypes.NewClientFactory("subId1", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewClient().NewLocationListPager("westus2", &armextensiontypes.ClientLocationListOptions{
		ClusterType:  to.Ptr("connectedCluster"),
		OfferID:      to.Ptr("myOfferId"),
		PlanID:       to.Ptr("myPlanId"),
		PublisherID:  to.Ptr("myPublisherId"),
		ReleaseTrain: to.Ptr("stable")})
	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 = armextensiontypes.ClientLocationListResponse{
		// 	List: armextensiontypes.List{
		// 		Value: []*armextensiontypes.ExtensionType{
		// 			{
		// 				Name: to.Ptr("bbbb"),
		// 				Type: to.Ptr("cccc"),
		// 				ID: to.Ptr("aaaa"),
		// 				Properties: &armextensiontypes.ExtensionTypeProperties{
		// 					Description: to.Ptr("My extension type!"),
		// 					IsManagedIdentityRequired: to.Ptr(true),
		// 					IsSystemExtension: to.Ptr(false),
		// 					PlanInfo: &armextensiontypes.ExtensionTypePropertiesPlanInfo{
		// 						OfferID: to.Ptr("myOfferId"),
		// 						PlanID: to.Ptr("myPlanId"),
		// 						PublisherID: to.Ptr("myPublisherId"),
		// 					},
		// 					Publisher: to.Ptr("Microsoft"),
		// 					SupportedClusterTypes: []*string{
		// 						to.Ptr("connectedClusters"),
		// 					},
		// 					SupportedScopes: &armextensiontypes.ExtensionTypePropertiesSupportedScopes{
		// 						ClusterScopeSettings: &armextensiontypes.ClusterScopeSettings{
		// 							Name: to.Ptr("bbbbbbbbbbbbb"),
		// 							Type: to.Ptr("ccccccccccccccccccccccccc"),
		// 							ID: to.Ptr("aaaaaaaaaaaaaaaaaa"),
		// 							Properties: &armextensiontypes.ClusterScopeSettingsProperties{
		// 								AllowMultipleInstances: to.Ptr(true),
		// 								DefaultReleaseNamespace: to.Ptr("kube-system"),
		// 							},
		// 						},
		// 						DefaultScope: to.Ptr("cluster"),
		// 					},
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

type ClientClusterGetVersionOptions 

type ClientClusterGetVersionOptions struct {
}

ClientClusterGetVersionOptions contains the optional parameters for the Client.ClusterGetVersion method.

type ClientClusterGetVersionResponse 

type ClientClusterGetVersionResponse struct {
	// The Extension Type Version object.
	ExtensionTypeVersionForReleaseTrain
}

ClientClusterGetVersionResponse contains the response from method Client.ClusterGetVersion.

type ClientClusterListVersionsOptions 

type ClientClusterListVersionsOptions struct {
	// Filter results by the major version of an extension type
	MajorVersion *string

	// Filter results by release train (default value is stable)
	ReleaseTrain *string

	// Filter results by only the latest version (based on other query parameters)
	ShowLatest *bool
}

ClientClusterListVersionsOptions contains the optional parameters for the Client.NewClusterListVersionsPager method.

type ClientClusterListVersionsResponse 

type ClientClusterListVersionsResponse struct {
	// List Extension Type Versions. It contains a list of ExtensionTypeVersionForReleaseTrain objects.
	ExtensionTypeVersionsList
}

ClientClusterListVersionsResponse contains the response from method Client.NewClusterListVersionsPager.

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.

type ClientGetOptions 

type ClientGetOptions struct {
}

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

type ClientGetResponse 

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

ClientGetResponse contains the response from method Client.Get.

type ClientGetVersionOptions 

type ClientGetVersionOptions struct {
}

ClientGetVersionOptions contains the optional parameters for the Client.GetVersion method.

type ClientGetVersionResponse 

type ClientGetVersionResponse struct {
	// The Extension Type Version object.
	ExtensionTypeVersionForReleaseTrain
}

ClientGetVersionResponse contains the response from method Client.GetVersion.

type ClientListOptions 

type ClientListOptions struct {
	// Filter results by Offer or Product ID of a marketplace extension type
	OfferID *string

	// Filter results by Plan ID of a marketplace extension type
	PlanID *string

	// Filter results by Publisher ID of a marketplace extension type
	PublisherID *string

	// Filter results by release train (default value is stable)
	ReleaseTrain *string
}

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

type ClientListResponse 

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

ClientListResponse contains the response from method Client.NewListPager.

type ClientListVersionsOptions 

type ClientListVersionsOptions struct {
	// Filter results by the cluster type for extension types
	ClusterType *string

	// Filter results by the major version of an extension type
	MajorVersion *string

	// Filter results by release train (default value is stable)
	ReleaseTrain *string

	// Filter results by only the latest version (based on other query parameters)
	ShowLatest *bool
}

ClientListVersionsOptions contains the optional parameters for the Client.NewListVersionsPager method.

type ClientListVersionsResponse 

type ClientListVersionsResponse struct {
	// List Extension Type Versions. It contains a list of ExtensionTypeVersionForReleaseTrain objects.
	ExtensionTypeVersionsList
}

ClientListVersionsResponse contains the response from method Client.NewListVersionsPager.

type ClientLocationGetOptions 

type ClientLocationGetOptions struct {
}

ClientLocationGetOptions contains the optional parameters for the Client.LocationGet method.

type ClientLocationGetResponse 

type ClientLocationGetResponse struct {
	// The Extension Type object.
	ExtensionType
}

ClientLocationGetResponse contains the response from method Client.LocationGet.

type ClientLocationListOptions 

type ClientLocationListOptions struct {
	// Filter results by the cluster type for extension types
	ClusterType *string

	// Filter results by Offer or Product ID of a marketplace extension type
	OfferID *string

	// Filter results by Plan ID of a marketplace extension type
	PlanID *string

	// Filter results by Publisher ID of a marketplace extension type
	PublisherID *string

	// Filter results by release train (default value is stable)
	ReleaseTrain *string
}

ClientLocationListOptions contains the optional parameters for the Client.NewLocationListPager method.

type ClientLocationListResponse 

type ClientLocationListResponse struct {
	// List Extension Types. It contains a list of ExtensionType objects and a URL link to get the next set of results.
	List
}

ClientLocationListResponse contains the response from method Client.NewLocationListPager.

type ClusterScopeSettings 

type ClusterScopeSettings struct {
	// Extension scope settings
	Properties *ClusterScopeSettingsProperties

	// 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
}

ClusterScopeSettings - Extension scope settings

func (ClusterScopeSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ClusterScopeSettings.

func (*ClusterScopeSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterScopeSettings.

type ClusterScopeSettingsProperties 

type ClusterScopeSettingsProperties struct {
	// Describes if multiple instances of the extension are allowed
	AllowMultipleInstances *bool

	// Default extension release namespace
	DefaultReleaseNamespace *string
}

ClusterScopeSettingsProperties - Extension scope settings

func (ClusterScopeSettingsProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ClusterScopeSettingsProperties.

func (*ClusterScopeSettingsProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterScopeSettingsProperties.

type CreatedByType added in v0.2.0 

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

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type ExtensionType 

type ExtensionType struct {
	Properties *ExtensionTypeProperties

	// 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
}

ExtensionType - The Extension Type object.

func (ExtensionType) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionType.

func (*ExtensionType) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionType.

type ExtensionTypeProperties 

type ExtensionTypeProperties struct {
	// Description of the extension type
	Description *string

	// Should an identity for this cluster resource be created
	IsManagedIdentityRequired *bool

	// Is this Extension Type a system extension.
	IsSystemExtension *bool

	// Plan information only for the Marketplace Extension Type.
	PlanInfo *ExtensionTypePropertiesPlanInfo

	// Name of the publisher for the Extension Type
	Publisher *string

	// Cluster Types supported for this Extension Type.
	SupportedClusterTypes []*string

	// Supported Kubernetes Scopes for this Extension Type.
	SupportedScopes *ExtensionTypePropertiesSupportedScopes
}

func (ExtensionTypeProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeProperties.

func (*ExtensionTypeProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeProperties.

type ExtensionTypePropertiesPlanInfo 

type ExtensionTypePropertiesPlanInfo struct {
	// Offer or Product ID of the Marketplace Extension Type.
	OfferID *string

	// Plan ID of the Marketplace Extension Type.
	PlanID *string

	// Publisher ID of the Marketplace Extension Type.
	PublisherID *string
}

ExtensionTypePropertiesPlanInfo - Plan information only for the Marketplace Extension Type.

func (ExtensionTypePropertiesPlanInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypePropertiesPlanInfo.

func (*ExtensionTypePropertiesPlanInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypePropertiesPlanInfo.

type ExtensionTypePropertiesSupportedScopes 

type ExtensionTypePropertiesSupportedScopes struct {
	// Extension scope settings
	ClusterScopeSettings *ClusterScopeSettings

	// The default scope of the extension type. This scope will be used if the user does not provide a scope while creating an
	// extension.
	DefaultScope *string
}

ExtensionTypePropertiesSupportedScopes - Supported Kubernetes Scopes for this Extension Type.

func (ExtensionTypePropertiesSupportedScopes) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypePropertiesSupportedScopes.

func (*ExtensionTypePropertiesSupportedScopes) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypePropertiesSupportedScopes.

type ExtensionTypeVersionForReleaseTrain 

type ExtensionTypeVersionForReleaseTrain struct {
	Properties *ExtensionTypeVersionForReleaseTrainProperties

	// 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
}

ExtensionTypeVersionForReleaseTrain - The Extension Type Version object.

func (ExtensionTypeVersionForReleaseTrain) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeVersionForReleaseTrain.

func (*ExtensionTypeVersionForReleaseTrain) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeVersionForReleaseTrain.

type ExtensionTypeVersionForReleaseTrainProperties 

type ExtensionTypeVersionForReleaseTrainProperties struct {
	// A list of supported cluster types for this version of the Extension Type
	SupportedClusterTypes []*string

	// The list of supported Kubernetes cluster versions for this extension type
	UnsupportedKubernetesVersions *ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions

	// The version number for the extension type
	Version *string
}

func (ExtensionTypeVersionForReleaseTrainProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeVersionForReleaseTrainProperties.

func (*ExtensionTypeVersionForReleaseTrainProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeVersionForReleaseTrainProperties.

type ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions 

type ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions struct {
	Appliances         []*ExtensionTypeVersionUnsupportedKubernetesMatrixItem
	ConnectedCluster   []*ExtensionTypeVersionUnsupportedKubernetesMatrixItem
	ManagedCluster     []*ExtensionTypeVersionUnsupportedKubernetesMatrixItem
	ProvisionedCluster []*ExtensionTypeVersionUnsupportedKubernetesMatrixItem
}

ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions - The list of supported Kubernetes cluster versions for this extension type

func (ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions.

func (*ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeVersionForReleaseTrainPropertiesUnsupportedKubernetesVersions.

type ExtensionTypeVersionUnsupportedKubernetesMatrixItem 

type ExtensionTypeVersionUnsupportedKubernetesMatrixItem struct {
	// The list of Kubernetes Cluster Distribution Names not supported
	Distributions []*string

	// The list of Kubernetes Versions not supported by the list of Kubernetes Cluster Distribution names in this object
	UnsupportedVersions []*string
}

ExtensionTypeVersionUnsupportedKubernetesMatrixItem - The list of Kubernetes Distribution and Versions that are not supported by this version of this Extension Type

func (ExtensionTypeVersionUnsupportedKubernetesMatrixItem) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeVersionUnsupportedKubernetesMatrixItem.

func (*ExtensionTypeVersionUnsupportedKubernetesMatrixItem) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeVersionUnsupportedKubernetesMatrixItem.

type ExtensionTypeVersionsList 

type ExtensionTypeVersionsList struct {
	// READ-ONLY; The ExtensionTypeVersionForReleaseTrain items on this page
	Value []*ExtensionTypeVersionForReleaseTrain

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

ExtensionTypeVersionsList - List Extension Type Versions. It contains a list of ExtensionTypeVersionForReleaseTrain objects.

func (ExtensionTypeVersionsList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ExtensionTypeVersionsList.

func (*ExtensionTypeVersionsList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ExtensionTypeVersionsList.

type List 

type List struct {
	// READ-ONLY; The ExtensionType items on this page
	Value []*ExtensionType

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

List Extension Types. It contains a list of ExtensionType 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 SystemData added in v0.2.0 

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

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON added in v0.2.0 

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.