armlargeinstance

package module
v0.1.0 Latest Latest
Warning

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

 Go to latest Published: Feb 27, 2024 License: MIT Imports: 14 Imported by: 0

README

Azure Largeinstance Module for Go

PkgGoDev

The armlargeinstance module provides operations for working with Azure Largeinstance.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Largeinstance module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Largeinstance. 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 Largeinstance 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 := armlargeinstance.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 := armlargeinstance.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.NewAzureLargeInstanceClient()

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 Largeinstance 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 ActionType 

type ActionType string

ActionType - Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs. 

const (
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AzureLargeInstance 

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

	// The resource-specific properties for this resource.
	Properties *AzureLargeInstanceProperties

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

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

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

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

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

AzureLargeInstance - Azure Large Instance info on Azure (ARM properties and AzureLargeInstance properties)

func (AzureLargeInstance) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeInstance.

func (*AzureLargeInstance) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeInstance.

type AzureLargeInstanceClient 

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

AzureLargeInstanceClient contains the methods for the AzureLargeInstance group. Don't use this type directly, use NewAzureLargeInstanceClient() instead.

func NewAzureLargeInstanceClient 

func NewAzureLargeInstanceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AzureLargeInstanceClient, error)

NewAzureLargeInstanceClient creates a new instance of AzureLargeInstanceClient with the specified values.

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

func (*AzureLargeInstanceClient) BeginRestart 

func (client *AzureLargeInstanceClient) BeginRestart(ctx context.Context, resourceGroupName string, azureLargeInstanceName string, options *AzureLargeInstanceClientBeginRestartOptions) (*runtime.Poller[AzureLargeInstanceClientRestartResponse], error)

BeginRestart - The operation to restart an Azure Large Instance (only for compute instances) If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeInstanceName - Name of the AzureLargeInstance.
  • options - AzureLargeInstanceClientBeginRestartOptions contains the optional parameters for the AzureLargeInstanceClient.BeginRestart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_Restart.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAzureLargeInstanceClient().BeginRestart(ctx, "myResourceGroup", "myALInstance", &armlargeinstance.AzureLargeInstanceClientBeginRestartOptions{ForceParameter: 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.OperationStatusResult = armlargeinstance.OperationStatusResult{
	// 	Name: to.Ptr("00000000-0000-0000-0000-000000000001"),
	// 	Error: &armlargeinstance.ErrorDetail{
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 	},
	// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-04T21:17:24.905Z"); return t}()),
	// 	Status: to.Ptr("InProgress"),
	// }
}

Output:

func (*AzureLargeInstanceClient) BeginShutdown 

func (client *AzureLargeInstanceClient) BeginShutdown(ctx context.Context, resourceGroupName string, azureLargeInstanceName string, options *AzureLargeInstanceClientBeginShutdownOptions) (*runtime.Poller[AzureLargeInstanceClientShutdownResponse], error)

BeginShutdown - The operation to shutdown an Azure Large Instance (only for compute instances) If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeInstanceName - Name of the AzureLargeInstance.
  • options - AzureLargeInstanceClientBeginShutdownOptions contains the optional parameters for the AzureLargeInstanceClient.BeginShutdown method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_Shutdown.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAzureLargeInstanceClient().BeginShutdown(ctx, "myResourceGroup", "myALInstance", 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.OperationStatusResult = armlargeinstance.OperationStatusResult{
	// 	Name: to.Ptr("00000000-0000-0000-0000-000000000001"),
	// 	Error: &armlargeinstance.ErrorDetail{
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 	},
	// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-04T21:17:24.905Z"); return t}()),
	// 	Status: to.Ptr("InProgress"),
	// }
}

Output:

func (*AzureLargeInstanceClient) BeginStart 

func (client *AzureLargeInstanceClient) BeginStart(ctx context.Context, resourceGroupName string, azureLargeInstanceName string, options *AzureLargeInstanceClientBeginStartOptions) (*runtime.Poller[AzureLargeInstanceClientStartResponse], error)

BeginStart - The operation to start an Azure Large Instance (only for compute instances) If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeInstanceName - Name of the AzureLargeInstance.
  • options - AzureLargeInstanceClientBeginStartOptions contains the optional parameters for the AzureLargeInstanceClient.BeginStart method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_Start.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAzureLargeInstanceClient().BeginStart(ctx, "myResourceGroup", "myALInstance", 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.OperationStatusResult = armlargeinstance.OperationStatusResult{
	// 	Name: to.Ptr("00000000-0000-0000-0000-000000000001"),
	// 	Error: &armlargeinstance.ErrorDetail{
	// 		Code: to.Ptr(""),
	// 		Message: to.Ptr(""),
	// 	},
	// 	StartTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2023-08-04T21:17:24.905Z"); return t}()),
	// 	Status: to.Ptr("InProgress"),
	// }
}

Output:

func (*AzureLargeInstanceClient) Get 

func (client *AzureLargeInstanceClient) Get(ctx context.Context, resourceGroupName string, azureLargeInstanceName string, options *AzureLargeInstanceClientGetOptions) (AzureLargeInstanceClientGetResponse, error)

Get - Gets an Azure Large Instance for the specified subscription, resource group, and instance name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeInstanceName - Name of the AzureLargeInstance.
  • options - AzureLargeInstanceClientGetOptions contains the optional parameters for the AzureLargeInstanceClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeInstanceClient().Get(ctx, "myResourceGroup", "myAzureLargeInstance", 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.AzureLargeInstance = armlargeinstance.AzureLargeInstance{
	// 	Name: to.Ptr("myAzureLargeInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myAzureLargeInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeInstanceProperties{
	// 		AzureLargeInstanceID: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e1"),
	// 		HardwareProfile: &armlargeinstance.HardwareProfile{
	// 			AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
	// 		},
	// 		HwRevision: to.Ptr("Rev 4.2"),
	// 		NetworkProfile: &armlargeinstance.NetworkProfile{
	// 			CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuits/myCircuitId"),
	// 			NetworkInterfaces: []*armlargeinstance.IPAddress{
	// 				{
	// 					IPAddress: to.Ptr("123.123.123.123"),
	// 			}},
	// 		},
	// 		OSProfile: &armlargeinstance.OsProfile{
	// 			ComputerName: to.Ptr("myComputerName"),
	// 			OSType: to.Ptr("SLES 12 SP2"),
	// 			Version: to.Ptr("12 SP2"),
	// 		},
	// 		PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumRestarting),
	// 		ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
	// 		StorageProfile: &armlargeinstance.StorageProfile{
	// 			NfsIPAddress: to.Ptr("123.123.119.123"),
	// 		},
	// 	},
	// }
}

Output:

func (*AzureLargeInstanceClient) NewListByResourceGroupPager 

func (client *AzureLargeInstanceClient) NewListByResourceGroupPager(resourceGroupName string, options *AzureLargeInstanceClientListByResourceGroupOptions) *runtime.Pager[AzureLargeInstanceClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets a list of Azure Large Instances in the specified subscription and resource group. The operations returns various properties of each Azure Large Instance.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - AzureLargeInstanceClientListByResourceGroupOptions contains the optional parameters for the AzureLargeInstanceClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAzureLargeInstanceClient().NewListByResourceGroupPager("myResourceGroup", 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.AzureLargeInstanceListResult = armlargeinstance.AzureLargeInstanceListResult{
		// 	Value: []*armlargeinstance.AzureLargeInstance{
		// 		{
		// 			Name: to.Ptr("myAzureLargeMetalInstance1"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myAzureLargeMetalInstance1"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeInstanceProperties{
		// 				AzureLargeInstanceID: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e1"),
		// 				HardwareProfile: &armlargeinstance.HardwareProfile{
		// 					AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
		// 				},
		// 				HwRevision: to.Ptr("Rev 3"),
		// 				NetworkProfile: &armlargeinstance.NetworkProfile{
		// 					CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuit"),
		// 					NetworkInterfaces: []*armlargeinstance.IPAddress{
		// 						{
		// 							IPAddress: to.Ptr("100.100.100.100"),
		// 					}},
		// 				},
		// 				OSProfile: &armlargeinstance.OsProfile{
		// 					ComputerName: to.Ptr("myComputerName1"),
		// 					OSType: to.Ptr("SUSE"),
		// 					SSHPublicKey: to.Ptr("{ssh-rsa public key}"),
		// 					Version: to.Ptr("12 SP1"),
		// 				},
		// 				PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumStarted),
		// 				ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
		// 				ProximityPlacementGroup: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Compute/proximityPlacementGroups/myplacementgroup"),
		// 				StorageProfile: &armlargeinstance.StorageProfile{
		// 					NfsIPAddress: to.Ptr("200.200.200.200"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("myABMInstance2"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myABMInstance2"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-13T08:01:22.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeInstanceProperties{
		// 				AzureLargeInstanceID: to.Ptr("589bce49-9fe6-4dc8-82df-cf6ae25e0cb9"),
		// 				HardwareProfile: &armlargeinstance.HardwareProfile{
		// 					AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS384),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumHPE),
		// 				},
		// 				HwRevision: to.Ptr("Rev 3"),
		// 				NetworkProfile: &armlargeinstance.NetworkProfile{
		// 					CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuit"),
		// 					NetworkInterfaces: []*armlargeinstance.IPAddress{
		// 						{
		// 							IPAddress: to.Ptr("100.100.100.101"),
		// 					}},
		// 				},
		// 				OSProfile: &armlargeinstance.OsProfile{
		// 					ComputerName: to.Ptr("myComputerName2"),
		// 					OSType: to.Ptr("SUSE"),
		// 					SSHPublicKey: to.Ptr("{ssh-rsa public key}"),
		// 					Version: to.Ptr("12 SP1"),
		// 				},
		// 				PartnerNodeID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myAzureLargeMetalInstance1"),
		// 				PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumStarted),
		// 				ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
		// 				ProximityPlacementGroup: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Compute/proximityPlacementGroups/myplacementgroup"),
		// 				StorageProfile: &armlargeinstance.StorageProfile{
		// 					NfsIPAddress: to.Ptr("200.200.200.201"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AzureLargeInstanceClient) NewListBySubscriptionPager 

func (client *AzureLargeInstanceClient) NewListBySubscriptionPager(options *AzureLargeInstanceClientListBySubscriptionOptions) *runtime.Pager[AzureLargeInstanceClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets a list of Azure Large Instances in the specified subscription. The operations returns various properties of each Azure Large Instance.

Generated from API version 2023-07-20-preview

  • options - AzureLargeInstanceClientListBySubscriptionOptions contains the optional parameters for the AzureLargeInstanceClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAzureLargeInstanceClient().NewListBySubscriptionPager(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.AzureLargeInstanceListResult = armlargeinstance.AzureLargeInstanceListResult{
		// 	Value: []*armlargeinstance.AzureLargeInstance{
		// 		{
		// 			Name: to.Ptr("myAzureLargeInstance1"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
		// 			ID: to.Ptr("/subscriptions/57d3422f-467a-448e-b798-ebf490849542/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myAzureLargeInstance1"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-13T08:01:22.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeInstanceProperties{
		// 				AzureLargeInstanceID: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e1"),
		// 				HardwareProfile: &armlargeinstance.HardwareProfile{
		// 					AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
		// 				},
		// 				HwRevision: to.Ptr("Rev 4.2"),
		// 				NetworkProfile: &armlargeinstance.NetworkProfile{
		// 					CircuitID: to.Ptr("/subscriptions/57d3422f-467a-448e-b798-ebf490849542/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuits/myCircuitId"),
		// 					NetworkInterfaces: []*armlargeinstance.IPAddress{
		// 						{
		// 							IPAddress: to.Ptr("123.123.123.123"),
		// 					}},
		// 				},
		// 				OSProfile: &armlargeinstance.OsProfile{
		// 					ComputerName: to.Ptr("myComputerName"),
		// 					OSType: to.Ptr("SLES 12 SP2"),
		// 					Version: to.Ptr("12 SP2"),
		// 				},
		// 				PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumRestarting),
		// 				ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
		// 				StorageProfile: &armlargeinstance.StorageProfile{
		// 					NfsIPAddress: to.Ptr("123.123.119.123"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("myAzureLargeInstance2"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myAzureLargeInstance2"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-13T08:01:22.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeInstanceProperties{
		// 				AzureLargeInstanceID: to.Ptr("589bce49-9fe6-4dc8-82df-cf6ae25e0cb9"),
		// 				HardwareProfile: &armlargeinstance.HardwareProfile{
		// 					AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
		// 				},
		// 				HwRevision: to.Ptr("Rev 4.2"),
		// 				NetworkProfile: &armlargeinstance.NetworkProfile{
		// 					CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuits/myCircuitId"),
		// 					NetworkInterfaces: []*armlargeinstance.IPAddress{
		// 						{
		// 							IPAddress: to.Ptr("123.123.123.123"),
		// 					}},
		// 				},
		// 				OSProfile: &armlargeinstance.OsProfile{
		// 					ComputerName: to.Ptr("myComputerName2"),
		// 					OSType: to.Ptr("SLES 12 SP2"),
		// 					Version: to.Ptr("12 SP2"),
		// 				},
		// 				PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumRestarting),
		// 				ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
		// 				StorageProfile: &armlargeinstance.StorageProfile{
		// 					NfsIPAddress: to.Ptr("123.123.119.123"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AzureLargeInstanceClient) Update 

func (client *AzureLargeInstanceClient) Update(ctx context.Context, resourceGroupName string, azureLargeInstanceName string, properties AzureLargeInstanceTagsUpdate, options *AzureLargeInstanceClientUpdateOptions) (AzureLargeInstanceClientUpdateResponse, error)

Update - Patches the Tags field of an Azure Large Instance for the specified subscription, resource group, and instance name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeInstanceName - Name of the AzureLargeInstance.
  • properties - The resource properties to be updated.
  • options - AzureLargeInstanceClientUpdateOptions contains the optional parameters for the AzureLargeInstanceClient.Update method.
Example (AzureLargeInstanceDeleteTag)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_PatchTags_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeInstanceClient().Update(ctx, "myResourceGroup", "myALInstance", armlargeinstance.AzureLargeInstanceTagsUpdate{}, 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.AzureLargeInstance = armlargeinstance.AzureLargeInstance{
	// 	Name: to.Ptr("myALInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myALInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeInstanceProperties{
	// 		AzureLargeInstanceID: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e1"),
	// 		HardwareProfile: &armlargeinstance.HardwareProfile{
	// 			AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
	// 		},
	// 		HwRevision: to.Ptr("Rev 3"),
	// 		NetworkProfile: &armlargeinstance.NetworkProfile{
	// 			CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuit"),
	// 			NetworkInterfaces: []*armlargeinstance.IPAddress{
	// 				{
	// 					IPAddress: to.Ptr("100.100.100.100"),
	// 			}},
	// 		},
	// 		OSProfile: &armlargeinstance.OsProfile{
	// 			ComputerName: to.Ptr("myComputerName"),
	// 			OSType: to.Ptr("SUSE"),
	// 			SSHPublicKey: to.Ptr("{ssh-rsa public key}"),
	// 			Version: to.Ptr("12 SP1"),
	// 		},
	// 		PartnerNodeID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myALInstance2"),
	// 		PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumStarted),
	// 		ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
	// 		ProximityPlacementGroup: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Compute/proximityPlacementGroups/myplacementgroup"),
	// 		StorageProfile: &armlargeinstance.StorageProfile{
	// 			NfsIPAddress: to.Ptr("200.200.200.200"),
	// 		},
	// 	},
	// }
}

Output:
Example (AzureLargeInstanceUpdateTag)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstance_PatchTags.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeInstanceClient().Update(ctx, "myResourceGroup", "myALInstance", armlargeinstance.AzureLargeInstanceTagsUpdate{}, 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.AzureLargeInstance = armlargeinstance.AzureLargeInstance{
	// 	Name: to.Ptr("myALInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myALInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus"),
	// 	Tags: map[string]*string{
	// 		"testkey": to.Ptr("testvalue"),
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeInstanceProperties{
	// 		AzureLargeInstanceID: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e1"),
	// 		HardwareProfile: &armlargeinstance.HardwareProfile{
	// 			AzureLargeInstanceSize: to.Ptr(armlargeinstance.AzureLargeInstanceSizeNamesEnumS72),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS),
	// 		},
	// 		HwRevision: to.Ptr("Rev 3"),
	// 		NetworkProfile: &armlargeinstance.NetworkProfile{
	// 			CircuitID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Network/expressRouteCircuit"),
	// 			NetworkInterfaces: []*armlargeinstance.IPAddress{
	// 				{
	// 					IPAddress: to.Ptr("100.100.100.100"),
	// 			}},
	// 		},
	// 		OSProfile: &armlargeinstance.OsProfile{
	// 			ComputerName: to.Ptr("myComputerName"),
	// 			OSType: to.Ptr("SUSE"),
	// 			SSHPublicKey: to.Ptr("{ssh-rsa public key}"),
	// 			Version: to.Ptr("12 SP1"),
	// 		},
	// 		PartnerNodeID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeInstances/myALInstance2"),
	// 		PowerState: to.Ptr(armlargeinstance.AzureLargeInstancePowerStateEnumStarted),
	// 		ProvisioningState: to.Ptr(armlargeinstance.AzureLargeInstanceProvisioningStatesEnumSucceeded),
	// 		ProximityPlacementGroup: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.Compute/proximityPlacementGroups/myplacementgroup"),
	// 		StorageProfile: &armlargeinstance.StorageProfile{
	// 			NfsIPAddress: to.Ptr("200.200.200.200"),
	// 		},
	// 	},
	// }
}

Output:

type AzureLargeInstanceClientBeginRestartOptions 

type AzureLargeInstanceClientBeginRestartOptions struct {
	// When set to 'active', this parameter empowers the server with the ability to forcefully terminate and halt any existing
	// processes that may be running on the server
	ForceParameter *ForceState

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

AzureLargeInstanceClientBeginRestartOptions contains the optional parameters for the AzureLargeInstanceClient.BeginRestart method.

type AzureLargeInstanceClientBeginShutdownOptions 

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

AzureLargeInstanceClientBeginShutdownOptions contains the optional parameters for the AzureLargeInstanceClient.BeginShutdown method.

type AzureLargeInstanceClientBeginStartOptions 

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

AzureLargeInstanceClientBeginStartOptions contains the optional parameters for the AzureLargeInstanceClient.BeginStart method.

type AzureLargeInstanceClientGetOptions 

type AzureLargeInstanceClientGetOptions struct {
}

AzureLargeInstanceClientGetOptions contains the optional parameters for the AzureLargeInstanceClient.Get method.

type AzureLargeInstanceClientGetResponse 

type AzureLargeInstanceClientGetResponse struct {
	// Azure Large Instance info on Azure (ARM properties and AzureLargeInstance
	// properties)
	AzureLargeInstance
}

AzureLargeInstanceClientGetResponse contains the response from method AzureLargeInstanceClient.Get.

type AzureLargeInstanceClientListByResourceGroupOptions 

type AzureLargeInstanceClientListByResourceGroupOptions struct {
}

AzureLargeInstanceClientListByResourceGroupOptions contains the optional parameters for the AzureLargeInstanceClient.NewListByResourceGroupPager method.

type AzureLargeInstanceClientListByResourceGroupResponse 

type AzureLargeInstanceClientListByResourceGroupResponse struct {
	// The response of a AzureLargeInstance list operation.
	AzureLargeInstanceListResult
}

AzureLargeInstanceClientListByResourceGroupResponse contains the response from method AzureLargeInstanceClient.NewListByResourceGroupPager.

type AzureLargeInstanceClientListBySubscriptionOptions 

type AzureLargeInstanceClientListBySubscriptionOptions struct {
}

AzureLargeInstanceClientListBySubscriptionOptions contains the optional parameters for the AzureLargeInstanceClient.NewListBySubscriptionPager method.

type AzureLargeInstanceClientListBySubscriptionResponse 

type AzureLargeInstanceClientListBySubscriptionResponse struct {
	// The response of a AzureLargeInstance list operation.
	AzureLargeInstanceListResult
}

AzureLargeInstanceClientListBySubscriptionResponse contains the response from method AzureLargeInstanceClient.NewListBySubscriptionPager.

type AzureLargeInstanceClientRestartResponse 

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

AzureLargeInstanceClientRestartResponse contains the response from method AzureLargeInstanceClient.BeginRestart.

type AzureLargeInstanceClientShutdownResponse 

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

AzureLargeInstanceClientShutdownResponse contains the response from method AzureLargeInstanceClient.BeginShutdown.

type AzureLargeInstanceClientStartResponse 

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

AzureLargeInstanceClientStartResponse contains the response from method AzureLargeInstanceClient.BeginStart.

type AzureLargeInstanceClientUpdateOptions 

type AzureLargeInstanceClientUpdateOptions struct {
}

AzureLargeInstanceClientUpdateOptions contains the optional parameters for the AzureLargeInstanceClient.Update method.

type AzureLargeInstanceClientUpdateResponse 

type AzureLargeInstanceClientUpdateResponse struct {
	// Azure Large Instance info on Azure (ARM properties and AzureLargeInstance
	// properties)
	AzureLargeInstance
}

AzureLargeInstanceClientUpdateResponse contains the response from method AzureLargeInstanceClient.Update.

type AzureLargeInstanceForcePowerState 

type AzureLargeInstanceForcePowerState string

AzureLargeInstanceForcePowerState - Enum of two possible values to determine if the ALI instance restart operation should forcefully terminate and halt any existing processes that may be running on the server or not. 

const (
	// AzureLargeInstanceForcePowerStateActive - Active means that the restart operation will terminate and halt existing processes
	// that may be running on the server
	AzureLargeInstanceForcePowerStateActive AzureLargeInstanceForcePowerState = "active"
	// AzureLargeInstanceForcePowerStateInactive - Inactive means that the restart operation will not terminate and halt existing
	// processes that may be running on the server
	AzureLargeInstanceForcePowerStateInactive AzureLargeInstanceForcePowerState = "inactive"
)

func PossibleAzureLargeInstanceForcePowerStateValues 

func PossibleAzureLargeInstanceForcePowerStateValues() []AzureLargeInstanceForcePowerState

PossibleAzureLargeInstanceForcePowerStateValues returns the possible values for the AzureLargeInstanceForcePowerState const type.

type AzureLargeInstanceHardwareTypeNamesEnum 

type AzureLargeInstanceHardwareTypeNamesEnum string

AzureLargeInstanceHardwareTypeNamesEnum - Enum of the hardware options (vendor and/or their product name) for an Azure Large Instance 

const (
	// AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS - Hardware type of UCS from vendor Cisco
	AzureLargeInstanceHardwareTypeNamesEnumCiscoUCS AzureLargeInstanceHardwareTypeNamesEnum = "Cisco_UCS"
	// AzureLargeInstanceHardwareTypeNamesEnumHPE - Hardware type of HPE from vendor Hewlett Packard Enterprise
	AzureLargeInstanceHardwareTypeNamesEnumHPE AzureLargeInstanceHardwareTypeNamesEnum = "HPE"
	// AzureLargeInstanceHardwareTypeNamesEnumSDFLEX - Hardware type of SDFLEX
	AzureLargeInstanceHardwareTypeNamesEnumSDFLEX AzureLargeInstanceHardwareTypeNamesEnum = "SDFLEX"
)

func PossibleAzureLargeInstanceHardwareTypeNamesEnumValues 

func PossibleAzureLargeInstanceHardwareTypeNamesEnumValues() []AzureLargeInstanceHardwareTypeNamesEnum

PossibleAzureLargeInstanceHardwareTypeNamesEnumValues returns the possible values for the AzureLargeInstanceHardwareTypeNamesEnum const type.

type AzureLargeInstanceListResult 

type AzureLargeInstanceListResult struct {
	// REQUIRED; The AzureLargeInstance items on this page
	Value []*AzureLargeInstance

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

AzureLargeInstanceListResult - The response of a AzureLargeInstance list operation.

func (AzureLargeInstanceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeInstanceListResult.

func (*AzureLargeInstanceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeInstanceListResult.

type AzureLargeInstancePowerStateEnum 

type AzureLargeInstancePowerStateEnum string

AzureLargeInstancePowerStateEnum - Power states that an Azure Large Instance can be in 

const (
	// AzureLargeInstancePowerStateEnumRestarting - Restarting means that the Azure Large Instance resource is restarting.
	AzureLargeInstancePowerStateEnumRestarting AzureLargeInstancePowerStateEnum = "restarting"
	// AzureLargeInstancePowerStateEnumStarted - Started means that the Azure Large Instance resource has been powered on.
	AzureLargeInstancePowerStateEnumStarted AzureLargeInstancePowerStateEnum = "started"
	// AzureLargeInstancePowerStateEnumStarting - Starting means that the Azure Large Instance resource is turning on.
	AzureLargeInstancePowerStateEnumStarting AzureLargeInstancePowerStateEnum = "starting"
	// AzureLargeInstancePowerStateEnumStopped - Stopped means that the Azure Large Instance resource has shut down.
	AzureLargeInstancePowerStateEnumStopped AzureLargeInstancePowerStateEnum = "stopped"
	// AzureLargeInstancePowerStateEnumStopping - Stopping means that the Azure Large Instance resource is shutting down.
	AzureLargeInstancePowerStateEnumStopping AzureLargeInstancePowerStateEnum = "stopping"
	// AzureLargeInstancePowerStateEnumUnknown - Unknown means that the state of the Azure Large Instance is unknown.
	AzureLargeInstancePowerStateEnumUnknown AzureLargeInstancePowerStateEnum = "unknown"
)

func PossibleAzureLargeInstancePowerStateEnumValues 

func PossibleAzureLargeInstancePowerStateEnumValues() []AzureLargeInstancePowerStateEnum

PossibleAzureLargeInstancePowerStateEnumValues returns the possible values for the AzureLargeInstancePowerStateEnum const type.

type AzureLargeInstanceProperties 

type AzureLargeInstanceProperties struct {
	// Specifies the hardware settings for the Azure Large Instance.
	HardwareProfile *HardwareProfile

	// Specifies the network settings for the Azure Large Instance.
	NetworkProfile *NetworkProfile

	// Specifies the operating system settings for the Azure Large Instance.
	OSProfile *OsProfile

	// ARM ID of another AzureLargeInstance that will share a network with this AzureLargeInstance
	PartnerNodeID *string

	// Specifies the storage settings for the Azure Large Instance disks.
	StorageProfile *StorageProfile

	// READ-ONLY; Specifies the Azure Large Instance unique ID.
	AzureLargeInstanceID *string

	// READ-ONLY; Hardware revision of an Azure Large Instance
	HwRevision *string

	// READ-ONLY; Resource power state
	PowerState *AzureLargeInstancePowerStateEnum

	// READ-ONLY; State of provisioning of the AzureLargeInstance
	ProvisioningState *AzureLargeInstanceProvisioningStatesEnum

	// READ-ONLY; Resource proximity placement group
	ProximityPlacementGroup *string
}

AzureLargeInstanceProperties - Describes the properties of an Azure Large Instance.

func (AzureLargeInstanceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeInstanceProperties.

func (*AzureLargeInstanceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeInstanceProperties.

type AzureLargeInstanceProvisioningStatesEnum 

type AzureLargeInstanceProvisioningStatesEnum string

AzureLargeInstanceProvisioningStatesEnum - Provisioning states that an Azure Large Instance can be in 

const (
	// AzureLargeInstanceProvisioningStatesEnumAccepted - Accepted means Azure Large Instance resource provisioning has been accepted.
	AzureLargeInstanceProvisioningStatesEnumAccepted AzureLargeInstanceProvisioningStatesEnum = "Accepted"
	// AzureLargeInstanceProvisioningStatesEnumCanceled - Cancelled Azure Large Instance resource operation has been cancelled
	AzureLargeInstanceProvisioningStatesEnumCanceled AzureLargeInstanceProvisioningStatesEnum = "Canceled"
	// AzureLargeInstanceProvisioningStatesEnumCreating - Creating means Azure Large Instance resource is being created.
	AzureLargeInstanceProvisioningStatesEnumCreating AzureLargeInstanceProvisioningStatesEnum = "Creating"
	// AzureLargeInstanceProvisioningStatesEnumDeleting - Deleting means Azure Large Instance resource is in the process of being
	// deleted
	AzureLargeInstanceProvisioningStatesEnumDeleting AzureLargeInstanceProvisioningStatesEnum = "Deleting"
	// AzureLargeInstanceProvisioningStatesEnumFailed - Failed means Azure Large Instance resource is in failed state
	AzureLargeInstanceProvisioningStatesEnumFailed AzureLargeInstanceProvisioningStatesEnum = "Failed"
	// AzureLargeInstanceProvisioningStatesEnumMigrating - Migrating means Azure Large Instance resource is being migrated from
	// one subscription or resource group to another
	AzureLargeInstanceProvisioningStatesEnumMigrating AzureLargeInstanceProvisioningStatesEnum = "Migrating"
	// AzureLargeInstanceProvisioningStatesEnumSucceeded - Succeeded means Azure Large Instance resource creation succeeded during
	// last create/update
	AzureLargeInstanceProvisioningStatesEnumSucceeded AzureLargeInstanceProvisioningStatesEnum = "Succeeded"
	// AzureLargeInstanceProvisioningStatesEnumUpdating - Updating means an existing Azure Large Instance resource is being updated
	AzureLargeInstanceProvisioningStatesEnumUpdating AzureLargeInstanceProvisioningStatesEnum = "Updating"
)

func PossibleAzureLargeInstanceProvisioningStatesEnumValues 

func PossibleAzureLargeInstanceProvisioningStatesEnumValues() []AzureLargeInstanceProvisioningStatesEnum

PossibleAzureLargeInstanceProvisioningStatesEnumValues returns the possible values for the AzureLargeInstanceProvisioningStatesEnum const type.

type AzureLargeInstanceSizeNamesEnum 

type AzureLargeInstanceSizeNamesEnum string

AzureLargeInstanceSizeNamesEnum - Enum of available model types (each of which have their own storage / memory sizes) for an Azure Large Instance type. See https://docs.microsoft.com/azure/sap/large-instances/hana-available-skus 

const (
	// AzureLargeInstanceSizeNamesEnumS112 - No longer offered or used.
	AzureLargeInstanceSizeNamesEnumS112 AzureLargeInstanceSizeNamesEnum = "S112"
	// AzureLargeInstanceSizeNamesEnumS144 - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS144 AzureLargeInstanceSizeNamesEnum = "S144"
	// AzureLargeInstanceSizeNamesEnumS144M - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS144M AzureLargeInstanceSizeNamesEnum = "S144m"
	// AzureLargeInstanceSizeNamesEnumS192 - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS192 AzureLargeInstanceSizeNamesEnum = "S192"
	// AzureLargeInstanceSizeNamesEnumS192M - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS192M AzureLargeInstanceSizeNamesEnum = "S192m"
	// AzureLargeInstanceSizeNamesEnumS192Xm - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS192Xm AzureLargeInstanceSizeNamesEnum = "S192xm"
	// AzureLargeInstanceSizeNamesEnumS224 - 4 sockets, 224 CPU threads, 112 CPU cores, 3 TB total memory, 3 TB DRAM, 6.3 TB storage,
	// Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224 AzureLargeInstanceSizeNamesEnum = "S224"
	// AzureLargeInstanceSizeNamesEnumS224M - 4 sockets, 224 CPU threads, 112 CPU cores, 6 TB total memory, 6 TB DRAM, 10.5 TB
	// storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224M AzureLargeInstanceSizeNamesEnum = "S224m"
	// AzureLargeInstanceSizeNamesEnumS224Om - 4 sockets, 224 CPU threads, 112 CPU cores, 6 TB total memory, 3 TB DRAM, 3 TB memory
	// optane, 10.5 TB storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224Om AzureLargeInstanceSizeNamesEnum = "S224om"
	// AzureLargeInstanceSizeNamesEnumS224Oo - 4 sockets, 224 CPU threads, 112 CPU cores, 4.5 TB total memory, 1.5 TB DRAM, 3
	// TB memory optane, 8.4 TB storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224Oo AzureLargeInstanceSizeNamesEnum = "S224oo"
	// AzureLargeInstanceSizeNamesEnumS224Oom - 4 sockets, 224 CPU threads, 112 CPU cores, 9 TB total memory, 3 TB DRAM, 6 TB
	// memory optane, 14.8 TB storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224Oom AzureLargeInstanceSizeNamesEnum = "S224oom"
	// AzureLargeInstanceSizeNamesEnumS224Ooo - 4 sockets, 224 CPU threads, 112 CPU cores, 7.5TB total memory, 1.5 TB DRAM, 6
	// TB memory optane, 12.7 TB storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS224Ooo AzureLargeInstanceSizeNamesEnum = "S224ooo"
	// AzureLargeInstanceSizeNamesEnumS224Se - 4 sockets, 448 CPU threads, 6 TB total memory, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS224Se AzureLargeInstanceSizeNamesEnum = "S224se"
	// AzureLargeInstanceSizeNamesEnumS384 - 8 sockets, 384 CPU threads, 192 CPU cores, 4 TB total memory, 4 TB DRAM, 16 TB storage,
	// HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS384 AzureLargeInstanceSizeNamesEnum = "S384"
	// AzureLargeInstanceSizeNamesEnumS384M - 8 sockets, 384 CPU threads, 192 CPU cores, 6 TB total memory, 6 TB DRAM, 18 TB storage,
	// HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS384M AzureLargeInstanceSizeNamesEnum = "S384m"
	// AzureLargeInstanceSizeNamesEnumS384Xm - 8 sockets, 384 CPU threads, 192 CPU cores, 8 TB total memory, 8 TB DRAM, 22 TB
	// storage, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS384Xm AzureLargeInstanceSizeNamesEnum = "S384xm"
	// AzureLargeInstanceSizeNamesEnumS384Xxm - 8 sockets, 384 CPU threads, 12 TB total memory, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS384Xxm AzureLargeInstanceSizeNamesEnum = "S384xxm"
	// AzureLargeInstanceSizeNamesEnumS448 - 8 sockets, 448 CPU threads, 224 CPU cores, 6 TB total memory, 6 TB DRAM, 10.5 TB
	// storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448 AzureLargeInstanceSizeNamesEnum = "S448"
	// AzureLargeInstanceSizeNamesEnumS448M - 8 sockets, 448 CPU threads, 224 CPU cores, 12 TB total memory, 12 TB DRAM, 18.9
	// TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448M AzureLargeInstanceSizeNamesEnum = "S448m"
	// AzureLargeInstanceSizeNamesEnumS448Om - 8 sockets, 448 CPU threads, 224 CPU cores, 12 TB total memory, 6 TB DRAM, 6 TB
	// memory optane, 18.9 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448Om AzureLargeInstanceSizeNamesEnum = "S448om"
	// AzureLargeInstanceSizeNamesEnumS448Oo - 8 sockets, 448 CPU threads, 224 CPU cores, 9 TB total memory, 3 TB DRAM, 6 TB memory
	// optane, 14.8 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448Oo AzureLargeInstanceSizeNamesEnum = "S448oo"
	// AzureLargeInstanceSizeNamesEnumS448Oom - 8 sockets, 448 CPU threads, 224 CPU cores, 18 TB total memory, 6 TB DRAM, 12 memory
	// optane, 27.4 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448Oom AzureLargeInstanceSizeNamesEnum = "S448oom"
	// AzureLargeInstanceSizeNamesEnumS448Ooo - 8 sockets, 448 CPU threads, 224 CPU cores, 15 TB total memory, 3 TB DRAM, 12 memory
	// optane, 23.2 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448Ooo AzureLargeInstanceSizeNamesEnum = "S448ooo"
	// AzureLargeInstanceSizeNamesEnumS448Se - 8 sockets, 448 CPU threads, 12 TB total memory, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS448Se AzureLargeInstanceSizeNamesEnum = "S448se"
	// AzureLargeInstanceSizeNamesEnumS576M - 12 sockets, 576 CPU threads, 288 CPU cores, 12 TB total memory, 12 TB DRAM, 28 TB
	// storage, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS576M AzureLargeInstanceSizeNamesEnum = "S576m"
	// AzureLargeInstanceSizeNamesEnumS576Xm - 12 sockets, 576 CPU threads, 288 CPU cores, 18 TB total memory, HPEMc990x hardware
	// type
	AzureLargeInstanceSizeNamesEnumS576Xm AzureLargeInstanceSizeNamesEnum = "S576xm"
	// AzureLargeInstanceSizeNamesEnumS672 - 12 sockets, 672 CPU threads, 336 CPU cores, 9 TB total memory, 9 TB DRAM, 14.7 TB
	// storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672 AzureLargeInstanceSizeNamesEnum = "S672"
	// AzureLargeInstanceSizeNamesEnumS672M - 12 sockets, 672 CPU threads, 336 CPU cores, 18 TB total memory, 18 TB DRAM, 27.4
	// TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672M AzureLargeInstanceSizeNamesEnum = "S672m"
	// AzureLargeInstanceSizeNamesEnumS672Om - 12 sockets, 672 CPU threads, 336 CPU cores, 18 TB total memory, 9 TB DRAM, 9 TB
	// memory optane, 27.4 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672Om AzureLargeInstanceSizeNamesEnum = "S672om"
	// AzureLargeInstanceSizeNamesEnumS672Oo - 12 sockets, 672 CPU threads, 336 CPU cores, 13.5 TB total memory, 4.5 TB DRAM,
	// 9 TB memory optane, 21.1 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672Oo AzureLargeInstanceSizeNamesEnum = "S672oo"
	// AzureLargeInstanceSizeNamesEnumS672Oom - 12 sockets, 672 CPU threads, 336 CPU cores, 27 TB total memory, 9 TB DRAM, 18
	// TB memory optane, 40 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672Oom AzureLargeInstanceSizeNamesEnum = "S672oom"
	// AzureLargeInstanceSizeNamesEnumS672Ooo - 12 sockets, 672 CPU threads, 336 CPU cores, 22.5 TB total memory, 4.5 TB DRAM,
	// 18 TB memory optane, 33.7 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS672Ooo AzureLargeInstanceSizeNamesEnum = "S672ooo"
	// AzureLargeInstanceSizeNamesEnumS72 - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS72 AzureLargeInstanceSizeNamesEnum = "S72"
	// AzureLargeInstanceSizeNamesEnumS72M - Type I class SKU that can't be purchased anymore
	AzureLargeInstanceSizeNamesEnumS72M AzureLargeInstanceSizeNamesEnum = "S72m"
	// AzureLargeInstanceSizeNamesEnumS768 - No longer offered or used.
	AzureLargeInstanceSizeNamesEnumS768 AzureLargeInstanceSizeNamesEnum = "S768"
	// AzureLargeInstanceSizeNamesEnumS768M - 16 sockets, 768 CPU threads, 384 CPU cores, 16 TB total memory, 16 TB DRAM, 36 TB
	// storage, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS768M AzureLargeInstanceSizeNamesEnum = "S768m"
	// AzureLargeInstanceSizeNamesEnumS768Xm - 16 sockets, 768 CPU threads, 384 CPU cores, 24 TB total memory, 24 TB DRAM, 56
	// TB storage, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS768Xm AzureLargeInstanceSizeNamesEnum = "S768xm"
	// AzureLargeInstanceSizeNamesEnumS896 - 16 sockets, 896 CPU threads, 448 CPU cores, 12 TB total memory, 12 TB DRAM, 18.9
	// TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896 AzureLargeInstanceSizeNamesEnum = "S896"
	// AzureLargeInstanceSizeNamesEnumS896M - 16 sockets, 896 CPU threads, 448 CPU cores, 24 TB total memory, 24 TB DRAM, 35.8
	// TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896M AzureLargeInstanceSizeNamesEnum = "S896m"
	// AzureLargeInstanceSizeNamesEnumS896Om - 16 sockets, 896 CPU threads, 448 CPU cores, 24 TB total memory, 12 TB DRAM, 12
	// TB memory optane, 35.8 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896Om AzureLargeInstanceSizeNamesEnum = "S896om"
	// AzureLargeInstanceSizeNamesEnumS896Oo - 16 sockets, 896 CPU threads, 448 CPU cores, 18 TB total memory, 6 TB DRAM, 12 TB
	// memory optane, 27.4 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896Oo AzureLargeInstanceSizeNamesEnum = "S896oo"
	// AzureLargeInstanceSizeNamesEnumS896Oom - 16 sockets, 896 CPU threads, 448 CPU cores, 36 TB total memory, 12 TB DRAM, 24
	// TB memory optane, 52.7 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896Oom AzureLargeInstanceSizeNamesEnum = "S896oom"
	// AzureLargeInstanceSizeNamesEnumS896Ooo - 16 sockets, 896 CPU threads, 448 CPU cores, 30 TB total memory, 6 TB DRAM, 24
	// TB memory optane, 44.3 TB storage, SDFLEX hardware type
	AzureLargeInstanceSizeNamesEnumS896Ooo AzureLargeInstanceSizeNamesEnum = "S896ooo"
	// AzureLargeInstanceSizeNamesEnumS96 - 2 sockets, 96 CPU threads, 48 CPU cores, 768 GB total memory, 768 GB DRAM, 3.0 TB
	// storage, Cisco_UCS hardware type
	AzureLargeInstanceSizeNamesEnumS96 AzureLargeInstanceSizeNamesEnum = "S96"
	// AzureLargeInstanceSizeNamesEnumS960M - 20 sockets, 960 CPU threads, 480 CPU cores, 20 TB total memory, 20 TB DRAM, 46 TB
	// storage, HPEMc990x hardware type
	AzureLargeInstanceSizeNamesEnumS960M AzureLargeInstanceSizeNamesEnum = "S960m"
)

func PossibleAzureLargeInstanceSizeNamesEnumValues 

func PossibleAzureLargeInstanceSizeNamesEnumValues() []AzureLargeInstanceSizeNamesEnum

PossibleAzureLargeInstanceSizeNamesEnumValues returns the possible values for the AzureLargeInstanceSizeNamesEnum const type.

type AzureLargeInstanceTagsUpdate 

type AzureLargeInstanceTagsUpdate struct {
	// Resource tags.
	Tags map[string]*string
}

AzureLargeInstanceTagsUpdate - The type used for updating tags in AzureLargeInstance resources.

func (AzureLargeInstanceTagsUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeInstanceTagsUpdate.

func (*AzureLargeInstanceTagsUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeInstanceTagsUpdate.

type AzureLargeStorageInstance 

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

	// The resource-specific properties for this resource.
	Properties *AzureLargeStorageInstanceProperties

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

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

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

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

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

AzureLargeStorageInstance info on Azure (ARM properties and AzureLargeStorageInstance properties)

func (AzureLargeStorageInstance) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeStorageInstance.

func (*AzureLargeStorageInstance) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeStorageInstance.

type AzureLargeStorageInstanceClient 

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

AzureLargeStorageInstanceClient contains the methods for the AzureLargeStorageInstance group. Don't use this type directly, use NewAzureLargeStorageInstanceClient() instead.

func NewAzureLargeStorageInstanceClient 

func NewAzureLargeStorageInstanceClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AzureLargeStorageInstanceClient, error)

NewAzureLargeStorageInstanceClient creates a new instance of AzureLargeStorageInstanceClient with the specified values.

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

func (*AzureLargeStorageInstanceClient) Get 

func (client *AzureLargeStorageInstanceClient) Get(ctx context.Context, resourceGroupName string, azureLargeStorageInstanceName string, options *AzureLargeStorageInstanceClientGetOptions) (AzureLargeStorageInstanceClientGetResponse, error)

Get - Gets an Azure Large Storage instance for the specified subscription, resource group, and instance name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeStorageInstanceName - Name of the AzureLargeStorageInstance.
  • options - AzureLargeStorageInstanceClientGetOptions contains the optional parameters for the AzureLargeStorageInstanceClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeStorageInstance_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeStorageInstanceClient().Get(ctx, "myResourceGroup", "myAzureLargeStorageInstance", 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.AzureLargeStorageInstance = armlargeinstance.AzureLargeStorageInstance{
	// 	Name: to.Ptr("myAzureLargeStorageInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeStorageInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
	// 		AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e9"),
	// 		StorageProperties: &armlargeinstance.StorageProperties{
	// 			Generation: to.Ptr("Gen4"),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
	// 			OfferingType: to.Ptr("EPIC"),
	// 			ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
	// 			StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
	// 				BillingMode: to.Ptr("PAYG"),
	// 				SKU: to.Ptr(""),
	// 			},
	// 			StorageType: to.Ptr("FC"),
	// 			WorkloadType: to.Ptr("ODB"),
	// 		},
	// 	},
	// }
}

Output:

func (*AzureLargeStorageInstanceClient) NewListByResourceGroupPager 

func (client *AzureLargeStorageInstanceClient) NewListByResourceGroupPager(resourceGroupName string, options *AzureLargeStorageInstanceClientListByResourceGroupOptions) *runtime.Pager[AzureLargeStorageInstanceClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets a list of AzureLargeStorageInstances in the specified subscription and resource group. The operations returns various properties of each Azure LargeStorage instance.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • options - AzureLargeStorageInstanceClientListByResourceGroupOptions contains the optional parameters for the AzureLargeStorageInstanceClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeStorageInstance_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAzureLargeStorageInstanceClient().NewListByResourceGroupPager("myResourceGroup", 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.AzureLargeStorageInstanceListResult = armlargeinstance.AzureLargeStorageInstanceListResult{
		// 	Value: []*armlargeinstance.AzureLargeStorageInstance{
		// 		{
		// 			Name: to.Ptr("myAzureLargeStorageInstance1"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeStorageInstance1"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
		// 				AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e9"),
		// 				StorageProperties: &armlargeinstance.StorageProperties{
		// 					Generation: to.Ptr("Gen4"),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
		// 					OfferingType: to.Ptr("EPIC"),
		// 					ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
		// 					StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
		// 						BillingMode: to.Ptr("PAYG"),
		// 						SKU: to.Ptr(""),
		// 					},
		// 					StorageType: to.Ptr("FC"),
		// 					WorkloadType: to.Ptr("ODB"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("myAzureLargeStorageInstance2"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeStorageInstance2"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-13T08:01:22.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
		// 				AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24f7"),
		// 				StorageProperties: &armlargeinstance.StorageProperties{
		// 					Generation: to.Ptr("Gen4"),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
		// 					OfferingType: to.Ptr("EPIC"),
		// 					ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
		// 					StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
		// 						BillingMode: to.Ptr("RI"),
		// 						SKU: to.Ptr(""),
		// 					},
		// 					StorageType: to.Ptr("NFS"),
		// 					WorkloadType: to.Ptr("Cogito"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AzureLargeStorageInstanceClient) NewListBySubscriptionPager 

func (client *AzureLargeStorageInstanceClient) NewListBySubscriptionPager(options *AzureLargeStorageInstanceClientListBySubscriptionOptions) *runtime.Pager[AzureLargeStorageInstanceClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets a list of AzureLargeStorageInstances in the specified subscription. The operations returns various properties of each Azure LargeStorage instance.

Generated from API version 2023-07-20-preview

  • options - AzureLargeStorageInstanceClientListBySubscriptionOptions contains the optional parameters for the AzureLargeStorageInstanceClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeStorageInstance_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewAzureLargeStorageInstanceClient().NewListBySubscriptionPager(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.AzureLargeStorageInstanceListResult = armlargeinstance.AzureLargeStorageInstanceListResult{
		// 	Value: []*armlargeinstance.AzureLargeStorageInstance{
		// 		{
		// 			Name: to.Ptr("myAzureLargeInstance1"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeInstance1"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
		// 				AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e9"),
		// 				StorageProperties: &armlargeinstance.StorageProperties{
		// 					Generation: to.Ptr("Gen4"),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
		// 					OfferingType: to.Ptr("EPIC"),
		// 					ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
		// 					StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
		// 						BillingMode: to.Ptr("PAYG"),
		// 						SKU: to.Ptr(""),
		// 					},
		// 					StorageType: to.Ptr("FC"),
		// 					WorkloadType: to.Ptr("ODB"),
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("myAzureLargeInstance2"),
		// 			Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
		// 			ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeInstance2"),
		// 			SystemData: &armlargeinstance.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
		// 				CreatedBy: to.Ptr("user@microsoft.com"),
		// 				CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-08-13T08:01:22.123Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("user@microsoft.com"),
		// 				LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
		// 			},
		// 			Location: to.Ptr("westus2"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
		// 				AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24f7"),
		// 				StorageProperties: &armlargeinstance.StorageProperties{
		// 					Generation: to.Ptr("Gen4"),
		// 					HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
		// 					OfferingType: to.Ptr("EPIC"),
		// 					ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
		// 					StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
		// 						BillingMode: to.Ptr("RI"),
		// 						SKU: to.Ptr(""),
		// 					},
		// 					StorageType: to.Ptr("NFS"),
		// 					WorkloadType: to.Ptr("Cogito"),
		// 				},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*AzureLargeStorageInstanceClient) Update 

func (client *AzureLargeStorageInstanceClient) Update(ctx context.Context, resourceGroupName string, azureLargeStorageInstanceName string, properties AzureLargeStorageInstanceTagsUpdate, options *AzureLargeStorageInstanceClientUpdateOptions) (AzureLargeStorageInstanceClientUpdateResponse, error)

Update - Patches the Tags field of a Azure Large Storage Instance for the specified subscription, resource group, and instance name. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2023-07-20-preview

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • azureLargeStorageInstanceName - Name of the AzureLargeStorageInstance.
  • properties - The resource properties to be updated.
  • options - AzureLargeStorageInstanceClientUpdateOptions contains the optional parameters for the AzureLargeStorageInstanceClient.Update method.
Example (AzureLargeStorageInstanceDeleteTag)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeStorageInstance_PatchTags_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeStorageInstanceClient().Update(ctx, "myResourceGroup", "myALSInstance", armlargeinstance.AzureLargeStorageInstanceTagsUpdate{}, 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.AzureLargeStorageInstance = armlargeinstance.AzureLargeStorageInstance{
	// 	Name: to.Ptr("myAzureLargeStorageInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeStorageInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
	// 		AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e9"),
	// 		StorageProperties: &armlargeinstance.StorageProperties{
	// 			Generation: to.Ptr("Gen4"),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
	// 			OfferingType: to.Ptr("EPIC"),
	// 			ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
	// 			StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
	// 				BillingMode: to.Ptr("PAYG"),
	// 				SKU: to.Ptr(""),
	// 			},
	// 			StorageType: to.Ptr("FC"),
	// 			WorkloadType: to.Ptr("ODB"),
	// 		},
	// 	},
	// }
}

Output:
Example (AzureLargeStorageInstanceUpdateTag)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeStorageInstance_PatchTags.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewAzureLargeStorageInstanceClient().Update(ctx, "myResourceGroup", "myALSInstance", armlargeinstance.AzureLargeStorageInstanceTagsUpdate{}, 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.AzureLargeStorageInstance = armlargeinstance.AzureLargeStorageInstance{
	// 	Name: to.Ptr("myAzureLargeStorageInstance"),
	// 	Type: to.Ptr("Microsoft.AzureLargeInstance/AzureLargeStorageInstances"),
	// 	ID: to.Ptr("/subscriptions/f0f4887f-d13c-4943-a8ba-d7da28d2a3fd/resourceGroups/myResourceGroup/providers/Microsoft.AzureLargeInstance/AzureLargeStorageInstances/myAzureLargeStorageInstance"),
	// 	SystemData: &armlargeinstance.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-20T23:10:22.682Z"); return t}()),
	// 		CreatedBy: to.Ptr("user@microsoft.com"),
	// 		CreatedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-07-21T08:01:22.000Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("user@microsoft.com"),
	// 		LastModifiedByType: to.Ptr(armlargeinstance.CreatedByTypeUser),
	// 	},
	// 	Location: to.Ptr("westus2"),
	// 	Tags: map[string]*string{
	// 		"testkey": to.Ptr("testvalue"),
	// 	},
	// 	Properties: &armlargeinstance.AzureLargeStorageInstanceProperties{
	// 		AzureLargeStorageInstanceUniqueIdentifier: to.Ptr("23415635-4d7e-41dc-9598-8194f22c24e9"),
	// 		StorageProperties: &armlargeinstance.StorageProperties{
	// 			Generation: to.Ptr("Gen4"),
	// 			HardwareType: to.Ptr(armlargeinstance.AzureLargeInstanceHardwareTypeNamesEnum("NetApp")),
	// 			OfferingType: to.Ptr("EPIC"),
	// 			ProvisioningState: to.Ptr(armlargeinstance.ProvisioningStateSucceeded),
	// 			StorageBillingProperties: &armlargeinstance.StorageBillingProperties{
	// 				BillingMode: to.Ptr("PAYG"),
	// 				SKU: to.Ptr(""),
	// 			},
	// 			StorageType: to.Ptr("FC"),
	// 			WorkloadType: to.Ptr("ODB"),
	// 		},
	// 	},
	// }
}

Output:

type AzureLargeStorageInstanceClientGetOptions 

type AzureLargeStorageInstanceClientGetOptions struct {
}

AzureLargeStorageInstanceClientGetOptions contains the optional parameters for the AzureLargeStorageInstanceClient.Get method.

type AzureLargeStorageInstanceClientGetResponse 

type AzureLargeStorageInstanceClientGetResponse struct {
	// AzureLargeStorageInstance info on Azure (ARM properties and
	// AzureLargeStorageInstance properties)
	AzureLargeStorageInstance
}

AzureLargeStorageInstanceClientGetResponse contains the response from method AzureLargeStorageInstanceClient.Get.

type AzureLargeStorageInstanceClientListByResourceGroupOptions 

type AzureLargeStorageInstanceClientListByResourceGroupOptions struct {
}

AzureLargeStorageInstanceClientListByResourceGroupOptions contains the optional parameters for the AzureLargeStorageInstanceClient.NewListByResourceGroupPager method.

type AzureLargeStorageInstanceClientListByResourceGroupResponse 

type AzureLargeStorageInstanceClientListByResourceGroupResponse struct {
	// The response of a AzureLargeStorageInstance list operation.
	AzureLargeStorageInstanceListResult
}

AzureLargeStorageInstanceClientListByResourceGroupResponse contains the response from method AzureLargeStorageInstanceClient.NewListByResourceGroupPager.

type AzureLargeStorageInstanceClientListBySubscriptionOptions 

type AzureLargeStorageInstanceClientListBySubscriptionOptions struct {
}

AzureLargeStorageInstanceClientListBySubscriptionOptions contains the optional parameters for the AzureLargeStorageInstanceClient.NewListBySubscriptionPager method.

type AzureLargeStorageInstanceClientListBySubscriptionResponse 

type AzureLargeStorageInstanceClientListBySubscriptionResponse struct {
	// The response of a AzureLargeStorageInstance list operation.
	AzureLargeStorageInstanceListResult
}

AzureLargeStorageInstanceClientListBySubscriptionResponse contains the response from method AzureLargeStorageInstanceClient.NewListBySubscriptionPager.

type AzureLargeStorageInstanceClientUpdateOptions 

type AzureLargeStorageInstanceClientUpdateOptions struct {
}

AzureLargeStorageInstanceClientUpdateOptions contains the optional parameters for the AzureLargeStorageInstanceClient.Update method.

type AzureLargeStorageInstanceClientUpdateResponse 

type AzureLargeStorageInstanceClientUpdateResponse struct {
	// AzureLargeStorageInstance info on Azure (ARM properties and
	// AzureLargeStorageInstance properties)
	AzureLargeStorageInstance
}

AzureLargeStorageInstanceClientUpdateResponse contains the response from method AzureLargeStorageInstanceClient.Update.

type AzureLargeStorageInstanceListResult 

type AzureLargeStorageInstanceListResult struct {
	// REQUIRED; The AzureLargeStorageInstance items on this page
	Value []*AzureLargeStorageInstance

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

AzureLargeStorageInstanceListResult - The response of a AzureLargeStorageInstance list operation.

func (AzureLargeStorageInstanceListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeStorageInstanceListResult.

func (*AzureLargeStorageInstanceListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeStorageInstanceListResult.

type AzureLargeStorageInstanceProperties 

type AzureLargeStorageInstanceProperties struct {
	// Specifies the AzureLargeStorageInstance unique ID.
	AzureLargeStorageInstanceUniqueIdentifier *string

	// Specifies the storage properties for the AzureLargeStorage instance.
	StorageProperties *StorageProperties
}

AzureLargeStorageInstanceProperties - Describes the properties of an AzureLargeStorageInstance.

func (AzureLargeStorageInstanceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeStorageInstanceProperties.

func (*AzureLargeStorageInstanceProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeStorageInstanceProperties.

type AzureLargeStorageInstanceTagsUpdate 

type AzureLargeStorageInstanceTagsUpdate struct {
	// Resource tags.
	Tags map[string]*string
}

AzureLargeStorageInstanceTagsUpdate - The type used for updating tags in AzureLargeStorageInstance resources.

func (AzureLargeStorageInstanceTagsUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AzureLargeStorageInstanceTagsUpdate.

func (*AzureLargeStorageInstanceTagsUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AzureLargeStorageInstanceTagsUpdate.

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

func (c *ClientFactory) NewAzureLargeInstanceClient() *AzureLargeInstanceClient

NewAzureLargeInstanceClient creates a new instance of AzureLargeInstanceClient.

func (*ClientFactory) NewAzureLargeStorageInstanceClient 

func (c *ClientFactory) NewAzureLargeStorageInstanceClient() *AzureLargeStorageInstanceClient

NewAzureLargeStorageInstanceClient creates a new instance of AzureLargeStorageInstanceClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Disk 

type Disk struct {
	// Specifies the size of an empty data disk in gigabytes.
	DiskSizeGB *int32

	// The disk name.
	Name *string

	// READ-ONLY; Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM
	// and therefore must be unique for each data disk attached to a VM.
	Lun *int32
}

Disk - Specifies the disk information fo the Azure Large Instance

func (Disk) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Disk.

func (*Disk) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Disk.

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 ForceState 

type ForceState struct {
	// Whether to force restart by shutting all processes.
	ForceState *AzureLargeInstanceForcePowerState
}

ForceState - The active state empowers the server with the ability to forcefully terminate and halt any existing processes that may be running on the server

func (ForceState) MarshalJSON 

func (f ForceState) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ForceState.

func (*ForceState) UnmarshalJSON 

func (f *ForceState) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ForceState.

type HardwareProfile 

type HardwareProfile struct {
	// READ-ONLY; Specifies the Azure Large Instance SKU.
	AzureLargeInstanceSize *AzureLargeInstanceSizeNamesEnum

	// READ-ONLY; Name of the hardware type (vendor and/or their product name)
	HardwareType *AzureLargeInstanceHardwareTypeNamesEnum
}

HardwareProfile - Specifies the hardware settings for the Azure Large Instance.

func (HardwareProfile) MarshalJSON 

func (h HardwareProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type HardwareProfile.

func (*HardwareProfile) UnmarshalJSON 

func (h *HardwareProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type HardwareProfile.

type IPAddress 

type IPAddress struct {
	// Specifies the IP address of the network interface.
	IPAddress *string
}

IPAddress - Specifies the IP address of the network interface.

func (IPAddress) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type IPAddress.

func (*IPAddress) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type IPAddress.

type NetworkProfile 

type NetworkProfile struct {
	// Specifies the network interfaces for the Azure Large Instance.
	NetworkInterfaces []*IPAddress

	// READ-ONLY; Specifies the circuit id for connecting to express route.
	CircuitID *string
}

NetworkProfile - Specifies the network settings for the Azure Large Instance disks.

func (NetworkProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type NetworkProfile.

func (*NetworkProfile) UnmarshalJSON 

func (n *NetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkProfile.

type Operation 

type Operation struct {
	// Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for ARM/control-plane
	// operations.
	IsDataAction *bool

	// READ-ONLY; The name of the operation, as per Resource-Based Access Control (RBAC). Examples: "Microsoft.Compute/virtualMachines/write",
	// "Microsoft.Compute/virtualMachines/capture/action"
	Name *string

	// READ-ONLY; The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default
	// value is "user,system"
	Origin *Origin
}

Operation - Details of a REST API operation, returned from the Resource Provider Operations API

func (Operation) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationDisplay 

type OperationDisplay struct {
	// READ-ONLY; The short, localized friendly description of the operation; suitable for tool tips and detailed views.
	Description *string

	// READ-ONLY; The concise, localized friendly name for the operation; suitable for dropdowns. E.g. "Create or Update Virtual
	// Machine", "Restart Virtual Machine".
	Operation *string

	// READ-ONLY; The localized friendly form of the resource provider name, e.g. "Microsoft Monitoring Insights" or "Microsoft
	// Compute".
	Provider *string

	// READ-ONLY; The localized friendly name of the resource type related to this operation. E.g. "Virtual Machines" or "Job
	// Schedule Collections".
	Resource *string
}

OperationDisplay - Localized display information for this particular operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; URL to get the next set of operation list results (if there are any).
	NextLink *string

	// READ-ONLY; List of operations supported by the resource provider
	Value []*Operation
}

OperationListResult - A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationStatusResult 

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

	// The end time of the operation.
	EndTime *time.Time

	// If present, details of the operation error.
	Error *ErrorDetail

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

	// Name of the async operation.
	Name *string

	// The operations list.
	Operations []*OperationStatusResult

	// Percent of the operation that is complete.
	PercentComplete *float32

	// The start time of the operation.
	StartTime *time.Time

	// READ-ONLY; Fully qualified ID of the resource against which the original async operation was started.
	ResourceID *string
}

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 OperationsClient 

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

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient 

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*OperationsClient) NewListPager 

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

NewListPager - List the operations for the provider

Generated from API version 2023-07-20-preview

  • options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6051d2b126f5b1e4b623cde8edfa3e25cf730685/specification/azurelargeinstance/resource-manager/Microsoft.AzureLargeInstance/preview/2023-07-20-preview/examples/AzureLargeInstanceOperations_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/largeinstance/armlargeinstance"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armlargeinstance.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OperationListResult = armlargeinstance.OperationListResult{
		// 	Value: []*armlargeinstance.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.AzureLargeInstance/read"),
		// 			Display: &armlargeinstance.OperationDisplay{
		// 				Description: to.Ptr("Read any AzureLargeInstance"),
		// 				Operation: to.Ptr("Read AzureLargeInstance"),
		// 				Provider: to.Ptr("Microsoft Azure Large Instance"),
		// 				Resource: to.Ptr("AzureLargeInstance"),
		// 			},
		// 			IsDataAction: to.Ptr(false),
		// 		},
		// 		{
		// 			Name: to.Ptr("Microsoft.AzureLargeInstance"),
		// 			Display: &armlargeinstance.OperationDisplay{
		// 				Description: to.Ptr("Start any AzureLargeInstance"),
		// 				Operation: to.Ptr("Start AzureLargeInstance"),
		// 				Provider: to.Ptr("Microsoft Azure Large Instance"),
		// 				Resource: to.Ptr("AzureLargeInstance"),
		// 			},
		// 			IsDataAction: to.Ptr(true),
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type Origin 

type Origin string

Origin - The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is "user,system" 

const (
	OriginSystem     Origin = "system"
	OriginUser       Origin = "user"
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type OsProfile 

type OsProfile struct {
	// Specifies the host OS name of the Azure Large Instance.
	ComputerName *string

	// Specifies the SSH public key used to access the operating system.
	SSHPublicKey *string

	// READ-ONLY; This property allows you to specify the type of the OS.
	OSType *string

	// READ-ONLY; Specifies version of operating system.
	Version *string
}

OsProfile - Specifies the operating system settings for the Azure Large Instance.

func (OsProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OsProfile.

func (*OsProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OsProfile.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - An enum of possible operation states for an AzureLargeStorageInstances 

const (
	// ProvisioningStateAccepted - Accepted means ARM resource has been accepted.
	ProvisioningStateAccepted ProvisioningState = "Accepted"
	// ProvisioningStateCanceled - Cancelled means resource operation has been cancelled
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateCreating - Creating means ARM resource is being created.
	ProvisioningStateCreating ProvisioningState = "Creating"
	// ProvisioningStateDeleting - Deleting means resource is in the process of being deleted
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Failed means resource is in failed state
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateMigrating - Migrating means resource is being migrated from one subscription or resource group to another
	ProvisioningStateMigrating ProvisioningState = "Migrating"
	// ProvisioningStateSucceeded - Succeeded means resource creation succeeded during last create/update
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - Updating means an existing ARM resource is being updated
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type StorageBillingProperties 

type StorageBillingProperties struct {
	// the billing mode for the storage instance
	BillingMode *string

	// the SKU type that is provisioned
	SKU *string
}

StorageBillingProperties - Describes the billing related details of the AzureLargeStorageInstance.

func (StorageBillingProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageBillingProperties.

func (*StorageBillingProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageBillingProperties.

type StorageProfile 

type StorageProfile struct {
	// Specifies information about the operating system disk used by Azure Large Instance.
	OSDisks []*Disk

	// READ-ONLY; IP Address to connect to storage.
	NfsIPAddress *string
}

StorageProfile - Specifies the storage settings for the Azure Large Instance disks.

func (StorageProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageProfile.

func (*StorageProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageProfile.

type StorageProperties 

type StorageProperties struct {
	// the kind of storage instance
	Generation *string

	// the hardware type of the storage instance
	HardwareType *AzureLargeInstanceHardwareTypeNamesEnum

	// the offering type for which the resource is getting provisioned
	OfferingType *string

	// the billing related information for the resource
	StorageBillingProperties *StorageBillingProperties

	// the storage protocol for which the resource is getting provisioned
	StorageType *string

	// the workload for which the resource is getting provisioned
	WorkloadType *string

	// READ-ONLY; State of provisioning of the AzureLargeStorageInstance
	ProvisioningState *ProvisioningState
}

StorageProperties - described the storage properties of the azure large storage instance

func (StorageProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type StorageProperties.

func (*StorageProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type StorageProperties.

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.