armcomputefleet

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Oct 22, 2024 License: MIT Imports: 14 Imported by: 1

README

Azure Computefleet Module for Go

PkgGoDev

The armcomputefleet module provides operations for working with Azure Computefleet.

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 Computefleet module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet

Authorization

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

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 Computefleet 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 APIEntityReference 

type APIEntityReference struct {
	// The ARM resource id in the form of
	// /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/...
	ID *string
}

APIEntityReference - The API entity reference.

func (APIEntityReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type APIEntityReference.

func (*APIEntityReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIEntityReference.

type APIError 

type APIError struct {
	// The error code.
	Code *string

	// The API error details
	Details []*APIErrorBase

	// The API inner error
	Innererror *InnerError

	// The error message.
	Message *string

	// The target of the particular error.
	Target *string
}

APIError - ApiError for Fleet

func (APIError) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type APIError.

func (*APIError) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIError.

type APIErrorBase 

type APIErrorBase struct {
	// The error code.
	Code *string

	// The error message.
	Message *string

	// The target of the particular error.
	Target *string
}

APIErrorBase - API error base.

func (APIErrorBase) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type APIErrorBase.

func (*APIErrorBase) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type APIErrorBase.

type AcceleratorManufacturer added in v1.0.0 

type AcceleratorManufacturer string

AcceleratorManufacturer - Accelerator manufacturers supported by Azure VMs. 

const (
	// AcceleratorManufacturerAMD - AMD GpuType
	AcceleratorManufacturerAMD AcceleratorManufacturer = "AMD"
	// AcceleratorManufacturerNvidia - Nvidia GpuType
	AcceleratorManufacturerNvidia AcceleratorManufacturer = "Nvidia"
	// AcceleratorManufacturerXilinx - Xilinx GpuType
	AcceleratorManufacturerXilinx AcceleratorManufacturer = "Xilinx"
)

func PossibleAcceleratorManufacturerValues added in v1.0.0 

func PossibleAcceleratorManufacturerValues() []AcceleratorManufacturer

PossibleAcceleratorManufacturerValues returns the possible values for the AcceleratorManufacturer const type.

type AcceleratorType added in v1.0.0 

type AcceleratorType string

AcceleratorType - Accelerator types supported by Azure VMs. 

const (
	// AcceleratorTypeFPGA - FPGA Accelerator
	AcceleratorTypeFPGA AcceleratorType = "FPGA"
	// AcceleratorTypeGPU - GPU Accelerator
	AcceleratorTypeGPU AcceleratorType = "GPU"
)

func PossibleAcceleratorTypeValues added in v1.0.0 

func PossibleAcceleratorTypeValues() []AcceleratorType

PossibleAcceleratorTypeValues returns the possible values for the AcceleratorType const type.

type ActionType 

type ActionType string

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

const (
	// ActionTypeInternal - Actions are for internal-only APIs.
	ActionTypeInternal ActionType = "Internal"
)

func PossibleActionTypeValues 

func PossibleActionTypeValues() []ActionType

PossibleActionTypeValues returns the possible values for the ActionType const type.

type AdditionalCapabilities added in v1.0.0 

type AdditionalCapabilities struct {
	// The flag that enables or disables hibernation capability on the VM.
	HibernationEnabled *bool

	// The flag that enables or disables a capability to have one or more managed data disks with UltraSSD_LRS storage account
	// type on the VM or VMSS.
	// Managed disks with storage account type UltraSSD_LRS can be added to a virtual machine or virtual machine scale set only
	// if this property is enabled.
	UltraSSDEnabled *bool
}

AdditionalCapabilities for VM.

func (AdditionalCapabilities) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AdditionalCapabilities.

func (*AdditionalCapabilities) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdditionalCapabilities.

type AdditionalLocationsProfile added in v1.0.0 

type AdditionalLocationsProfile struct {
	// REQUIRED; The list of location profiles.
	LocationProfiles []*LocationProfile
}

AdditionalLocationsProfile - Represents the configuration for additional locations where Fleet resources may be deployed.

func (AdditionalLocationsProfile) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type AdditionalLocationsProfile.

func (*AdditionalLocationsProfile) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdditionalLocationsProfile.

type AdditionalUnattendContent 

type AdditionalUnattendContent struct {
	// FLAG; CONSTANT; The component name. Currently, the only allowable value is
	// Microsoft-Windows-Shell-Setup.
	// Field has constant value "Microsoft-Windows-Shell-Setup", any specified value is ignored.
	ComponentName *string

	// Specifies the XML formatted content that is added to the unattend.xml file for
	// the specified path and component. The XML must be less than 4KB and must
	// include the root element for the setting or feature that is being inserted.
	Content *string

	// FLAG; CONSTANT; The pass name. Currently, the only allowable value is OobeSystem.
	// Field has constant value "OobeSystem", any specified value is ignored.
	PassName *string

	// Specifies the name of the setting to which the content applies. Possible values
	// are: FirstLogonCommands and AutoLogon.
	SettingName *SettingNames
}

AdditionalUnattendContent - Specifies additional XML formatted information that can be included in the Unattend.xml file, which is used by Windows Setup. Contents are defined by setting name, component name, and the pass in which the content is applied.

func (AdditionalUnattendContent) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AdditionalUnattendContent.

func (*AdditionalUnattendContent) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type AdditionalUnattendContent.

type ApplicationProfile 

type ApplicationProfile struct {
	// Specifies the gallery applications that should be made available to the VM/VMSS
	GalleryApplications []*VMGalleryApplication
}

ApplicationProfile - Contains the list of gallery applications that should be made available to the VM/VMSS

func (ApplicationProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ApplicationProfile.

func (*ApplicationProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ApplicationProfile.

type ArchitectureType added in v1.0.0 

type ArchitectureType string

ArchitectureType - Architecture types supported by Azure VMs. 

const (
	// ArchitectureTypeARM64 - ARM64 Architecture
	ArchitectureTypeARM64 ArchitectureType = "ARM64"
	// ArchitectureTypeX64 - X64 Architecture
	ArchitectureTypeX64 ArchitectureType = "X64"
)

func PossibleArchitectureTypeValues added in v1.0.0 

func PossibleArchitectureTypeValues() []ArchitectureType

PossibleArchitectureTypeValues returns the possible values for the ArchitectureType const type.

type BaseVirtualMachineProfile 

type BaseVirtualMachineProfile struct {
	// Specifies the gallery applications that should be made available to the VM/VMSS
	ApplicationProfile *ApplicationProfile

	// Specifies the capacity reservation related details of a scale set. Minimum
	// api-version: 2021-04-01.
	CapacityReservation *CapacityReservationProfile

	// Specifies the boot diagnostic settings state.
	DiagnosticsProfile *DiagnosticsProfile

	// Specifies a collection of settings for extensions installed on virtual machines
	// in the scale set.
	ExtensionProfile *VirtualMachineScaleSetExtensionProfile

	// Specifies the hardware profile related details of a scale set. Minimum
	// api-version: 2021-11-01.
	HardwareProfile *VirtualMachineScaleSetHardwareProfile

	// Specifies that the image or disk that is being used was licensed on-premises.
	// <br><br> Possible values for Windows Server operating system are: <br><br>
	// Windows_Client <br><br> Windows_Server <br><br> Possible values for Linux
	// Server operating system are: <br><br> RHEL_BYOS (for RHEL) <br><br> SLES_BYOS
	// (for SUSE) <br><br> For more information, see [Azure Hybrid Use Benefit for
	// Windows
	// Server](https://docs.microsoft.com/azure/virtual-machines/windows/hybrid-use-benefit-licensing)
	// <br><br> [Azure Hybrid Use Benefit for Linux
	// Server](https://docs.microsoft.com/azure/virtual-machines/linux/azure-hybrid-benefit-linux)
	// <br><br> Minimum api-version: 2015-06-15
	LicenseType *string

	// Specifies properties of the network interfaces of the virtual machines in the
	// scale set.
	NetworkProfile *VirtualMachineScaleSetNetworkProfile

	// Specifies the operating system settings for the virtual machines in the scale
	// set.
	OSProfile *VirtualMachineScaleSetOSProfile

	// Specifies Scheduled Event related configurations.
	ScheduledEventsProfile *ScheduledEventsProfile

	// Specifies the security posture to be used for all virtual machines in the scale
	// set. Minimum api-version: 2023-03-01
	SecurityPostureReference *SecurityPostureReference

	// Specifies the Security related profile settings for the virtual machines in the
	// scale set.
	SecurityProfile *SecurityProfile

	// Specifies the service artifact reference id used to set same image version for
	// all virtual machines in the scale set when using 'latest' image version.
	// Minimum api-version: 2022-11-01
	ServiceArtifactReference *ServiceArtifactReference

	// Specifies the storage settings for the virtual machine disks.
	StorageProfile *VirtualMachineScaleSetStorageProfile

	// UserData for the virtual machines in the scale set, which must be base-64
	// encoded. Customer should not pass any secrets in here. Minimum api-version:
	// 2021-03-01.
	UserData *string

	// READ-ONLY; Specifies the time in which this VM profile for the Virtual Machine Scale Set
	// was created. Minimum API version for this property is 2023-09-01. This value
	// will be added to VMSS Flex VM tags when creating/updating the VMSS VM Profile
	// with minimum api-version 2023-09-01. Examples: "2024-07-01T00:00:01.1234567+00:00"
	TimeCreated *time.Time
}

BaseVirtualMachineProfile - Describes the base virtual machine profile for fleet

func (BaseVirtualMachineProfile) MarshalJSON 

func (b BaseVirtualMachineProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BaseVirtualMachineProfile.

func (*BaseVirtualMachineProfile) UnmarshalJSON 

func (b *BaseVirtualMachineProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BaseVirtualMachineProfile.

type BootDiagnostics 

type BootDiagnostics struct {
	// Whether boot diagnostics should be enabled on the Virtual Machine.
	Enabled *bool

	// Uri of the storage account to use for placing the console output and
	// screenshot. If storageUri is not specified while enabling boot diagnostics,
	// managed storage will be used.
	StorageURI *string
}

BootDiagnostics - Boot Diagnostics is a debugging feature which allows you to view Console Output and Screenshot to diagnose VM status. You can easily view the output of your console log. Azure also enables you to see a screenshot of the VM from the hypervisor.

func (BootDiagnostics) MarshalJSON 

func (b BootDiagnostics) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type BootDiagnostics.

func (*BootDiagnostics) UnmarshalJSON 

func (b *BootDiagnostics) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type BootDiagnostics.

type CPUManufacturer added in v1.0.0 

type CPUManufacturer string

CPUManufacturer - Cpu Manufacturers supported by Azure VMs. 

const (
	// CPUManufacturerAMD - AMD CPU.
	CPUManufacturerAMD CPUManufacturer = "AMD"
	// CPUManufacturerAmpere - Ampere CPU.
	CPUManufacturerAmpere CPUManufacturer = "Ampere"
	// CPUManufacturerIntel - Intel CPU.
	CPUManufacturerIntel CPUManufacturer = "Intel"
	// CPUManufacturerMicrosoft - Microsoft CPU.
	CPUManufacturerMicrosoft CPUManufacturer = "Microsoft"
)

func PossibleCPUManufacturerValues added in v1.0.0 

func PossibleCPUManufacturerValues() []CPUManufacturer

PossibleCPUManufacturerValues returns the possible values for the CPUManufacturer const type.

type CachingTypes 

type CachingTypes string

CachingTypes - Specifies the caching requirements. 

const (
	// CachingTypesNone - 'None' is default for Standard Storage
	CachingTypesNone CachingTypes = "None"
	// CachingTypesReadOnly - 'ReadOnly' is default for Premium Storage
	CachingTypesReadOnly CachingTypes = "ReadOnly"
	// CachingTypesReadWrite - 'ReadWrite' is default for OS Disk
	CachingTypesReadWrite CachingTypes = "ReadWrite"
)

func PossibleCachingTypesValues 

func PossibleCachingTypesValues() []CachingTypes

PossibleCachingTypesValues returns the possible values for the CachingTypes const type.

type CapacityReservationProfile 

type CapacityReservationProfile struct {
	// Specifies the capacity reservation group resource id that should be used for
	// allocating the virtual machine or scaleset vm instances provided enough
	// capacity has been reserved. Please refer to https://aka.ms/CapacityReservation
	// for more details.
	CapacityReservationGroup *SubResource
}

CapacityReservationProfile - The parameters of a capacity reservation Profile.

func (CapacityReservationProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CapacityReservationProfile.

func (*CapacityReservationProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CapacityReservationProfile.

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

func (c *ClientFactory) NewFleetsClient() *FleetsClient

NewFleetsClient creates a new instance of FleetsClient.

func (*ClientFactory) NewOperationsClient 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

type ComputeProfile 

type ComputeProfile struct {
	// REQUIRED; Base Virtual Machine Profile Properties to be specified according to "specification/compute/resource-manager/Microsoft.Compute/ComputeRP/stable/{computeApiVersion}/virtualMachineScaleSet.json#/definitions/VirtualMachineScaleSetVMProfile"
	BaseVirtualMachineProfile *BaseVirtualMachineProfile

	// Specifies VMSS and VM API entity models support two additional capabilities as of today: ultraSSDEnabled and hibernationEnabled.
	// ultraSSDEnabled: Enables UltraSSD_LRS storage account type on the VMSS VMs.
	// hibernationEnabled: Enables the hibernation capability on the VMSS VMs.
	// Default value is null if not specified. This property cannot be updated once set.
	AdditionalVirtualMachineCapabilities *AdditionalCapabilities

	// Specifies the Microsoft.Compute API version to use when creating underlying Virtual Machine scale sets and Virtual Machines.
	// The default value will be the latest supported computeApiVersion by Compute Fleet.
	ComputeAPIVersion *string

	// Specifies the number of fault domains to use when creating the underlying VMSS.
	// A fault domain is a logical group of hardware within an Azure datacenter.
	// VMs in the same fault domain share a common power source and network switch.
	// If not specified, defaults to 1, which represents "Max Spreading" (using as many fault domains as possible).
	// This property cannot be updated.
	PlatformFaultDomainCount *int32
}

ComputeProfile - Compute Profile to use for running user's workloads.

func (ComputeProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ComputeProfile.

func (*ComputeProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ComputeProfile.

type CreatedByType 

type CreatedByType string

CreatedByType - The kind of entity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DeleteOptions 

type DeleteOptions string

DeleteOptions - Specify what happens to the network interface when the VM is deleted 

const (
	// DeleteOptionsDelete - Delete Option
	DeleteOptionsDelete DeleteOptions = "Delete"
	// DeleteOptionsDetach - Detach Option
	DeleteOptionsDetach DeleteOptions = "Detach"
)

func PossibleDeleteOptionsValues 

func PossibleDeleteOptionsValues() []DeleteOptions

PossibleDeleteOptionsValues returns the possible values for the DeleteOptions const type.

type DiagnosticsProfile 

type DiagnosticsProfile struct {
	// Boot Diagnostics is a debugging feature which allows you to view Console Output
	// and Screenshot to diagnose VM status. **NOTE**: If storageUri is being
	// specified then ensure that the storage account is in the same region and
	// subscription as the VM. You can easily view the output of your console log.
	// Azure also enables you to see a screenshot of the VM from the hypervisor.
	BootDiagnostics *BootDiagnostics
}

DiagnosticsProfile - Specifies the boot diagnostic settings state. Minimum api-version: 2015-06-15.

func (DiagnosticsProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiagnosticsProfile.

func (*DiagnosticsProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiagnosticsProfile.

type DiffDiskOptions 

type DiffDiskOptions string

DiffDiskOptions - Specifies the ephemeral disk option for operating system disk. 

const (
	// DiffDiskOptionsLocal - Local Option.
	DiffDiskOptionsLocal DiffDiskOptions = "Local"
)

func PossibleDiffDiskOptionsValues 

func PossibleDiffDiskOptionsValues() []DiffDiskOptions

PossibleDiffDiskOptionsValues returns the possible values for the DiffDiskOptions const type.

type DiffDiskPlacement 

type DiffDiskPlacement string

DiffDiskPlacement - Specifies the ephemeral disk placement for operating system disk. This property can be used by user in the request to choose the location i.e, cache disk or resource disk space for Ephemeral OS disk provisioning. For more information on Ephemeral OS disk size requirements, please refer Ephemeral OS disk size requirements for Windows VM at https://docs.microsoft.com/azure/virtual-machines/windows/ephemeral-os-disks#size-requirements and Linux VM at https://docs.microsoft.com/azure/virtual-machines/linux/ephemeral-os-disks#size-requirements Minimum api-version for NvmeDisk: 2024-03-01. 

const (
	// DiffDiskPlacementCacheDisk - CacheDisk option.
	DiffDiskPlacementCacheDisk DiffDiskPlacement = "CacheDisk"
	// DiffDiskPlacementNvmeDisk - NvmeDisk option.
	DiffDiskPlacementNvmeDisk DiffDiskPlacement = "NvmeDisk"
	// DiffDiskPlacementResourceDisk - Resource Disk option.
	DiffDiskPlacementResourceDisk DiffDiskPlacement = "ResourceDisk"
)

func PossibleDiffDiskPlacementValues 

func PossibleDiffDiskPlacementValues() []DiffDiskPlacement

PossibleDiffDiskPlacementValues returns the possible values for the DiffDiskPlacement const type.

type DiffDiskSettings 

type DiffDiskSettings struct {
	// Specifies the ephemeral disk settings for operating system disk.
	Option *DiffDiskOptions

	// Specifies the ephemeral disk placement for operating system disk. Possible
	// values are: **CacheDisk,** **ResourceDisk.** The defaulting behavior is:
	// **CacheDisk** if one is configured for the VM size otherwise **ResourceDisk**
	// is used. Refer to the VM size documentation for Windows VM at
	// https://docs.microsoft.com/azure/virtual-machines/windows/sizes and Linux VM at
	// https://docs.microsoft.com/azure/virtual-machines/linux/sizes to check which VM
	// sizes exposes a cache disk.
	Placement *DiffDiskPlacement
}

DiffDiskSettings - Describes the parameters of ephemeral disk settings that can be specified for operating system disk. **Note:** The ephemeral disk settings can only be specified for managed disk.

func (DiffDiskSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiffDiskSettings.

func (*DiffDiskSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiffDiskSettings.

type DiskControllerTypes 

type DiskControllerTypes string

DiskControllerTypes - Specifies the disk controller type configured for the VM and VirtualMachineScaleSet. This property is only supported for virtual machines whose operating system disk and VM sku supports Generation 2 (https://docs.microsoft.com/en-us/azure/virtual-machines/generation-2), please check the HyperVGenerations capability returned as part of VM sku capabilities in the response of Microsoft.Compute SKUs api for the region contains V2 (https://docs.microsoft.com/rest/api/compute/resourceskus/list). For more information about Disk Controller Types supported please refer to https://aka.ms/azure-diskcontrollertypes. 

const (
	// DiskControllerTypesNVMe - NVMe disk type
	DiskControllerTypesNVMe DiskControllerTypes = "NVMe"
	// DiskControllerTypesSCSI - SCSI disk type
	DiskControllerTypesSCSI DiskControllerTypes = "SCSI"
)

func PossibleDiskControllerTypesValues 

func PossibleDiskControllerTypesValues() []DiskControllerTypes

PossibleDiskControllerTypesValues returns the possible values for the DiskControllerTypes const type.

type DiskCreateOptionTypes 

type DiskCreateOptionTypes string

DiskCreateOptionTypes - Specifies how the virtual machine should be created. 

const (
	// DiskCreateOptionTypesAttach - This value is used when you are using a specialized disk to create the virtual machine.
	DiskCreateOptionTypesAttach DiskCreateOptionTypes = "Attach"
	// DiskCreateOptionTypesCopy - This value is used to create a data disk from a snapshot or another disk.
	DiskCreateOptionTypesCopy DiskCreateOptionTypes = "Copy"
	// DiskCreateOptionTypesEmpty - This value is used when creating an empty data disk.
	DiskCreateOptionTypesEmpty DiskCreateOptionTypes = "Empty"
	// DiskCreateOptionTypesFromImage - This value is used when you are using an image to create the virtual machine.
	// If you are using a platform image, you also use the imageReference element
	// described above. If you are using a marketplace image, you also use the
	// plan element previously described.
	DiskCreateOptionTypesFromImage DiskCreateOptionTypes = "FromImage"
	// DiskCreateOptionTypesRestore - This value is used to create a data disk from a disk restore point.
	DiskCreateOptionTypesRestore DiskCreateOptionTypes = "Restore"
)

func PossibleDiskCreateOptionTypesValues 

func PossibleDiskCreateOptionTypesValues() []DiskCreateOptionTypes

PossibleDiskCreateOptionTypesValues returns the possible values for the DiskCreateOptionTypes const type.

type DiskDeleteOptionTypes 

type DiskDeleteOptionTypes string

DiskDeleteOptionTypes - Specifies the behavior of the managed disk when the VM gets deleted, for example whether the managed disk is deleted or detached. Supported values are: **Delete.** If this value is used, the managed disk is deleted when VM gets deleted. **Detach.** If this value is used, the managed disk is retained after VM gets deleted. Minimum api-version: 2021-03-01. 

const (
	// DiskDeleteOptionTypesDelete - If this value is used, the managed disk is deleted when VM gets deleted.
	DiskDeleteOptionTypesDelete DiskDeleteOptionTypes = "Delete"
	// DiskDeleteOptionTypesDetach - If this value is used, the managed disk is retained after VM gets deleted.
	DiskDeleteOptionTypesDetach DiskDeleteOptionTypes = "Detach"
)

func PossibleDiskDeleteOptionTypesValues 

func PossibleDiskDeleteOptionTypesValues() []DiskDeleteOptionTypes

PossibleDiskDeleteOptionTypesValues returns the possible values for the DiskDeleteOptionTypes const type.

type DiskEncryptionSetParameters 

type DiskEncryptionSetParameters struct {
	// Resource Id
	ID *string
}

DiskEncryptionSetParameters - Describes the parameter of customer managed disk encryption set resource id that can be specified for disk. **Note:** The disk encryption set resource id can only be specified for managed disk. Please refer https://aka.ms/mdssewithcmkoverview for more details.

func (DiskEncryptionSetParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type DiskEncryptionSetParameters.

func (*DiskEncryptionSetParameters) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type DiskEncryptionSetParameters.

type DomainNameLabelScopeTypes 

type DomainNameLabelScopeTypes string

DomainNameLabelScopeTypes - The Domain name label scope.The concatenation of the hashed domain name label that generated according to the policy from domain name label scope and vm index will be the domain name labels of the PublicIPAddress resources that will be created 

const (
	// DomainNameLabelScopeTypesNoReuse - NoReuse type
	DomainNameLabelScopeTypesNoReuse DomainNameLabelScopeTypes = "NoReuse"
	// DomainNameLabelScopeTypesResourceGroupReuse - ResourceGroupReuse type
	DomainNameLabelScopeTypesResourceGroupReuse DomainNameLabelScopeTypes = "ResourceGroupReuse"
	// DomainNameLabelScopeTypesSubscriptionReuse - SubscriptionReuse type
	DomainNameLabelScopeTypesSubscriptionReuse DomainNameLabelScopeTypes = "SubscriptionReuse"
	// DomainNameLabelScopeTypesTenantReuse - TenantReuse type
	DomainNameLabelScopeTypesTenantReuse DomainNameLabelScopeTypes = "TenantReuse"
)

func PossibleDomainNameLabelScopeTypesValues 

func PossibleDomainNameLabelScopeTypesValues() []DomainNameLabelScopeTypes

PossibleDomainNameLabelScopeTypesValues returns the possible values for the DomainNameLabelScopeTypes const type.

type EncryptionIdentity 

type EncryptionIdentity struct {
	// Specifies ARM Resource ID of one of the user identities associated with the VM.
	UserAssignedIdentityResourceID *string
}

EncryptionIdentity - Specifies the Managed Identity used by ADE to get access token for keyvault operations.

func (EncryptionIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionIdentity.

func (*EncryptionIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionIdentity.

type EvictionPolicy 

type EvictionPolicy string

EvictionPolicy - Different kind of eviction policies 

const (
	// EvictionPolicyDeallocate - When evicted, the Spot VM will be deallocated/stopped
	EvictionPolicyDeallocate EvictionPolicy = "Deallocate"
	// EvictionPolicyDelete - When evicted, the Spot VM will be deleted and the corresponding capacity will be updated to reflect
	// this.
	EvictionPolicyDelete EvictionPolicy = "Delete"
)

func PossibleEvictionPolicyValues 

func PossibleEvictionPolicyValues() []EvictionPolicy

PossibleEvictionPolicyValues returns the possible values for the EvictionPolicy const type.

type Fleet 

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

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

	// The managed service identities assigned to this resource.
	Identity *ManagedServiceIdentity

	// Details of the resource plan.
	Plan *Plan

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

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

	// Zones in which the Compute Fleet is available
	Zones []*string

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *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
}

Fleet - An Compute Fleet resource

func (Fleet) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Fleet.

func (*Fleet) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Fleet.

type FleetListResult 

type FleetListResult struct {
	// REQUIRED; The Fleet items on this page
	Value []*Fleet

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

FleetListResult - The response of a Fleet list operation.

func (FleetListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FleetListResult.

func (*FleetListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FleetListResult.

type FleetProperties 

type FleetProperties struct {
	// REQUIRED; Compute Profile to use for running user's workloads.
	ComputeProfile *ComputeProfile

	// REQUIRED; List of VM sizes supported for Compute Fleet
	VMSizesProfile []*VMSizeProfile

	// Represents the configuration for additional locations where Fleet resources may be deployed.
	AdditionalLocationsProfile *AdditionalLocationsProfile

	// Configuration Options for Regular instances in Compute Fleet.
	RegularPriorityProfile *RegularPriorityProfile

	// Configuration Options for Spot instances in Compute Fleet.
	SpotPriorityProfile *SpotPriorityProfile

	// Attribute based Fleet.
	VMAttributes *VMAttributes

	// READ-ONLY; The status of the last operation.
	ProvisioningState *ProvisioningState

	// READ-ONLY; Specifies the time at which the Compute Fleet is created.
	TimeCreated *time.Time

	// READ-ONLY; Specifies the ID which uniquely identifies a Compute Fleet.
	UniqueID *string
}

FleetProperties - Details of the Compute Fleet.

func (FleetProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FleetProperties.

func (*FleetProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FleetProperties.

type FleetUpdate 

type FleetUpdate struct {
	// Updatable managed service identity
	Identity *ManagedServiceIdentityUpdate

	// Updatable resource plan
	Plan *ResourcePlanUpdate

	// RP-specific updatable properties
	Properties *FleetProperties

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

FleetUpdate - Fleet Update Model

func (FleetUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type FleetUpdate.

func (*FleetUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type FleetUpdate.

type FleetsClient 

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

FleetsClient contains the methods for the Fleets group. Don't use this type directly, use NewFleetsClient() instead.

func NewFleetsClient 

func NewFleetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FleetsClient, error)

NewFleetsClient creates a new instance of FleetsClient 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 (*FleetsClient) BeginCreateOrUpdate 

func (client *FleetsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, fleetName string, resource Fleet, options *FleetsClientBeginCreateOrUpdateOptions) (*runtime.Poller[FleetsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Create a Fleet If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • fleetName - The name of the Compute Fleet
  • resource - Resource create parameters.
  • options - FleetsClientBeginCreateOrUpdateOptions contains the optional parameters for the FleetsClient.BeginCreateOrUpdate method.
Example (FleetsCreateOrUpdate)

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_CreateOrUpdate.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewFleetsClient().BeginCreateOrUpdate(ctx, "rgazurefleet", "testFleet", armcomputefleet.Fleet{
		Properties: &armcomputefleet.FleetProperties{
			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
				Capacity:           to.Ptr[int32](20),
				MinCapacity:        to.Ptr[int32](10),
				MaxPricePerVM:      to.Ptr[float32](0.00865),
				EvictionPolicy:     to.Ptr(armcomputefleet.EvictionPolicyDelete),
				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
				Maintain:           to.Ptr(true),
			},
			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
				Capacity:           to.Ptr[int32](20),
				MinCapacity:        to.Ptr[int32](10),
				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
			},
			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
				{
					Name: to.Ptr("Standard_d1_v2"),
					Rank: to.Ptr[int32](19225),
				},
			},
			ComputeProfile: &armcomputefleet.ComputeProfile{
				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
						ComputerNamePrefix: to.Ptr("o"),
						AdminUsername:      to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
						AdminPassword:      to.Ptr("adfbrdxpv"),
						CustomData:         to.Ptr("xjjib"),
						WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
							ProvisionVMAgent:       to.Ptr(true),
							EnableAutomaticUpdates: to.Ptr(true),
							TimeZone:               to.Ptr("hlyjiqcfksgrpjrct"),
							AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
								{
									PassName:      to.Ptr("OobeSystem"),
									ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
									SettingName:   to.Ptr(armcomputefleet.SettingNamesAutoLogon),
									Content:       to.Ptr("bubmqbxjkj"),
								},
							},
							PatchSettings: &armcomputefleet.PatchSettings{
								PatchMode:         to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
								EnableHotpatching: to.Ptr(true),
								AssessmentMode:    to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
								AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
									RebootSetting:                            to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
								},
							},
							WinRM: &armcomputefleet.WinRMConfiguration{
								Listeners: []*armcomputefleet.WinRMListener{
									{
										Protocol:       to.Ptr(armcomputefleet.ProtocolTypesHTTPS),
										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
									},
								},
							},
							EnableVMAgentPlatformUpdates: to.Ptr(true),
						},
						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
							DisablePasswordAuthentication: to.Ptr(true),
							SSH: &armcomputefleet.SSHConfiguration{
								PublicKeys: []*armcomputefleet.SSHPublicKey{
									{
										Path:    to.Ptr("kmqz"),
										KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
									},
								},
							},
							ProvisionVMAgent: to.Ptr(true),
							PatchSettings: &armcomputefleet.LinuxPatchSettings{
								PatchMode:      to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
								AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
								AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
									RebootSetting:                            to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
								},
							},
							EnableVMAgentPlatformUpdates: to.Ptr(true),
						},
						Secrets: []*armcomputefleet.VaultSecretGroup{
							{
								SourceVault: &armcomputefleet.SubResource{
									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
								},
								VaultCertificates: []*armcomputefleet.VaultCertificate{
									{
										CertificateURL:   to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
										CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
									},
								},
							},
						},
						AllowExtensionOperations:    to.Ptr(true),
						RequireGuestProvisionSignal: to.Ptr(true),
					},
					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
						ImageReference: &armcomputefleet.ImageReference{
							Publisher:               to.Ptr("mqxgwbiyjzmxavhbkd"),
							Offer:                   to.Ptr("isxgumkarlkomp"),
							SKU:                     to.Ptr("eojmppqcrnpmxirtp"),
							Version:                 to.Ptr("wvpcqefgtmqdgltiuz"),
							SharedGalleryImageID:    to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
							CommunityGalleryImageID: to.Ptr("vlqe"),
							ID:                      to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
						},
						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
							Name:                    to.Ptr("wfttw"),
							Caching:                 to.Ptr(armcomputefleet.CachingTypesNone),
							WriteAcceleratorEnabled: to.Ptr(true),
							CreateOption:            to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
							DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
								Option:    to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
								Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
							},
							DiskSizeGB: to.Ptr[int32](14),
							OSType:     to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
							Image: &armcomputefleet.VirtualHardDisk{
								URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
							},
							VhdContainers: []*string{
								to.Ptr("tkzcwddtinkfpnfklatw"),
							},
							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
								DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
								},
								SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
									SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
									},
								},
							},
							DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
						},
						DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
							{
								Name:                    to.Ptr("eogiykmdmeikswxmigjws"),
								Lun:                     to.Ptr[int32](14),
								Caching:                 to.Ptr(armcomputefleet.CachingTypesNone),
								WriteAcceleratorEnabled: to.Ptr(true),
								CreateOption:            to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
								DiskSizeGB:              to.Ptr[int32](6),
								ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
									StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
									},
									SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
										SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
										},
									},
								},
								DiskIOPSReadWrite: to.Ptr[int64](27),
								DiskMBpsReadWrite: to.Ptr[int64](2),
								DeleteOption:      to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
							},
						},
					},
					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
						HealthProbe: &armcomputefleet.APIEntityReference{
							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
						},
						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
							{
								Name: to.Ptr("i"),
								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
									Primary:                     to.Ptr(true),
									EnableAcceleratedNetworking: to.Ptr(true),
									DisableTCPStateTracking:     to.Ptr(true),
									EnableFpga:                  to.Ptr(true),
									NetworkSecurityGroup: &armcomputefleet.SubResource{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
									},
									DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
										DNSServers: []*string{
											to.Ptr("nxmmfolhclsesu"),
										},
									},
									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
										{
											Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
												Subnet: &armcomputefleet.APIEntityReference{
													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
												},
												Primary: to.Ptr(true),
												PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
													Name: to.Ptr("fvpqf"),
													Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
														IdleTimeoutInMinutes: to.Ptr[int32](9),
														DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
															DomainNameLabel:      to.Ptr("ukrddzvmorpmfsczjwtbvp"),
															DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
														},
														IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
															{
																IPTagType: to.Ptr("sddgsoemnzgqizale"),
																Tag:       to.Ptr("wufmhrjsakbiaetyara"),
															},
														},
														PublicIPPrefix: &armcomputefleet.SubResource{
															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
														},
														PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
														DeleteOption:           to.Ptr(armcomputefleet.DeleteOptionsDelete),
													},
													SKU: &armcomputefleet.PublicIPAddressSKU{
														Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
														Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
													},
												},
												PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
												ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
													},
												},
												ApplicationSecurityGroups: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
													},
												},
												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
													},
												},
												LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
													},
												},
											},
										},
									},
									EnableIPForwarding: to.Ptr(true),
									DeleteOption:       to.Ptr(armcomputefleet.DeleteOptionsDelete),
									AuxiliaryMode:      to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
									AuxiliarySKU:       to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
								},
							},
						},
						NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
					},
					SecurityProfile: &armcomputefleet.SecurityProfile{
						UefiSettings: &armcomputefleet.UefiSettings{
							SecureBootEnabled: to.Ptr(true),
							VTpmEnabled:       to.Ptr(true),
						},
						EncryptionAtHost: to.Ptr(true),
						SecurityType:     to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
						EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
							UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
						},
						ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
							Enabled:          to.Ptr(true),
							Mode:             to.Ptr(armcomputefleet.ModeAudit),
							KeyIncarnationID: to.Ptr[int32](20),
						},
					},
					DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
						BootDiagnostics: &armcomputefleet.BootDiagnostics{
							Enabled:    to.Ptr(true),
							StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
						},
					},
					ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
						Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
							{
								Name: to.Ptr("bndxuxx"),
								Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
									ForceUpdateTag:          to.Ptr("yhgxw"),
									Publisher:               to.Ptr("kpxtirxjfprhs"),
									Type:                    to.Ptr("pgjilctjjwaa"),
									TypeHandlerVersion:      to.Ptr("zevivcoilxmbwlrihhhibq"),
									AutoUpgradeMinorVersion: to.Ptr(true),
									EnableAutomaticUpgrade:  to.Ptr(true),
									Settings:                map[string]any{},
									ProtectedSettings:       map[string]any{},
									ProvisionAfterExtensions: []*string{
										to.Ptr("nftzosroolbcwmpupujzqwqe"),
									},
									SuppressFailures: to.Ptr(true),
									ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
										SecretURL: to.Ptr("https://myvaultName.vault.azure.net/secrets/secret/mySecretName"),
										SourceVault: &armcomputefleet.SubResource{
											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
										},
									},
								},
							},
						},
						ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
					},
					LicenseType: to.Ptr("v"),
					ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
						TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
							NotBeforeTimeout: to.Ptr("iljppmmw"),
							Enable:           to.Ptr(true),
						},
						OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
							NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
							Enable:           to.Ptr(true),
						},
					},
					UserData: to.Ptr("s"),
					CapacityReservation: &armcomputefleet.CapacityReservationProfile{
						CapacityReservationGroup: &armcomputefleet.SubResource{
							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
						},
					},
					ApplicationProfile: &armcomputefleet.ApplicationProfile{
						GalleryApplications: []*armcomputefleet.VMGalleryApplication{
							{
								Tags:                            to.Ptr("eyrqjbib"),
								Order:                           to.Ptr[int32](5),
								PackageReferenceID:              to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
								ConfigurationReference:          to.Ptr("ulztmiavpojpbpbddgnuuiimxcpau"),
								TreatFailureAsDeploymentFailure: to.Ptr(true),
								EnableAutomaticUpgrade:          to.Ptr(true),
							},
						},
					},
					HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
						VMSizeProperties: &armcomputefleet.VMSizeProperties{
							VCPUsAvailable: to.Ptr[int32](16),
							VCPUsPerCore:   to.Ptr[int32](23),
						},
					},
					ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
						ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
					},
					SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
						ID: to.Ptr("/CommunityGalleries/{communityGalleryName}/securityPostures/{securityPostureName}/versions/{major.minor.patch}|{major.*}|latest"),
						ExcludeExtensions: []*string{
							to.Ptr("{securityPostureVMExtensionName}"),
						},
						IsOverridable: to.Ptr(true),
					},
				},
				ComputeAPIVersion:        to.Ptr("2023-07-01"),
				PlatformFaultDomainCount: to.Ptr[int32](1),
			},
		},
		Zones: []*string{
			to.Ptr("zone1"),
			to.Ptr("zone2"),
		},
		Identity: &armcomputefleet.ManagedServiceIdentity{
			Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
				"key9851": {},
			},
		},
		Tags: map[string]*string{
			"key3518": to.Ptr("luvrnuvsgdpbuofdskkcoqhfh"),
		},
		Location: to.Ptr("westus"),
		Plan: &armcomputefleet.Plan{
			Name:          to.Ptr("jwgrcrnrtfoxn"),
			Publisher:     to.Ptr("iozjbiqqckqm"),
			Product:       to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
			PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
			Version:       to.Ptr("wa"),
		},
	}, 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 = armcomputefleet.FleetsClientCreateOrUpdateResponse{
	// 	Fleet: &armcomputefleet.Fleet{
	// 		Properties: &armcomputefleet.FleetProperties{
	// 			ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateSucceeded),
	// 			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
	// 				Capacity: to.Ptr[int32](10),
	// 				MinCapacity: to.Ptr[int32](20),
	// 				MaxPricePerVM: to.Ptr[float32](0.00865),
	// 				EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
	// 				Maintain: to.Ptr(true),
	// 			},
	// 			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
	// 				Capacity: to.Ptr[int32](10),
	// 				MinCapacity: to.Ptr[int32](10),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
	// 			},
	// 			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
	// 				{
	// 					Name: to.Ptr("Standard_d1_v2"),
	// 					Rank: to.Ptr[int32](19225),
	// 				},
	// 			},
	// 			ComputeProfile: &armcomputefleet.ComputeProfile{
	// 				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
	// 					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
	// 						ComputerNamePrefix: to.Ptr("o"),
	// 						AdminUsername: to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
	// 						WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							EnableAutomaticUpdates: to.Ptr(true),
	// 							TimeZone: to.Ptr("hlyjiqcfksgrpjrct"),
	// 							AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
	// 								{
	// 									PassName: to.Ptr("OobeSystem"),
	// 									ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
	// 									SettingName: to.Ptr(armcomputefleet.SettingNamesAutoLogon),
	// 								},
	// 							},
	// 							PatchSettings: &armcomputefleet.PatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
	// 								EnableHotpatching: to.Ptr(true),
	// 								AssessmentMode: to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							WinRM: &armcomputefleet.WinRMConfiguration{
	// 								Listeners: []*armcomputefleet.WinRMListener{
	// 									{
	// 										Protocol: to.Ptr(armcomputefleet.ProtocolTypesHTTPS),
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 									},
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
	// 							DisablePasswordAuthentication: to.Ptr(true),
	// 							SSH: &armcomputefleet.SSHConfiguration{
	// 								PublicKeys: []*armcomputefleet.SSHPublicKey{
	// 									{
	// 										Path: to.Ptr("kmqz"),
	// 										KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
	// 									},
	// 								},
	// 							},
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							PatchSettings: &armcomputefleet.LinuxPatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
	// 								AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						Secrets: []*armcomputefleet.VaultSecretGroup{
	// 							{
	// 								SourceVault: &armcomputefleet.SubResource{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 								},
	// 								VaultCertificates: []*armcomputefleet.VaultCertificate{
	// 									{
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 										CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
	// 									},
	// 								},
	// 							},
	// 						},
	// 						AllowExtensionOperations: to.Ptr(true),
	// 						RequireGuestProvisionSignal: to.Ptr(true),
	// 					},
	// 					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
	// 						ImageReference: &armcomputefleet.ImageReference{
	// 							Publisher: to.Ptr("mqxgwbiyjzmxavhbkd"),
	// 							Offer: to.Ptr("isxgumkarlkomp"),
	// 							SKU: to.Ptr("eojmppqcrnpmxirtp"),
	// 							Version: to.Ptr("wvpcqefgtmqdgltiuz"),
	// 							ExactVersion: to.Ptr("zjbntmiskjexlr"),
	// 							SharedGalleryImageID: to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
	// 							CommunityGalleryImageID: to.Ptr("vlqe"),
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
	// 						},
	// 						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
	// 							Name: to.Ptr("wfttw"),
	// 							Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 							WriteAcceleratorEnabled: to.Ptr(true),
	// 							CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 							DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
	// 								Option: to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
	// 								Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
	// 							},
	// 							DiskSizeGB: to.Ptr[int32](14),
	// 							OSType: to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
	// 							Image: &armcomputefleet.VirtualHardDisk{
	// 								URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
	// 							},
	// 							VhdContainers: []*string{
	// 								to.Ptr("tkzcwddtinkfpnfklatw"),
	// 							},
	// 							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 								DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 								},
	// 								SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 									SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 								},
	// 							},
	// 							DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 						},
	// 						DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
	// 							{
	// 								Name: to.Ptr("eogiykmdmeikswxmigjws"),
	// 								Lun: to.Ptr[int32](14),
	// 								Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 								WriteAcceleratorEnabled: to.Ptr(true),
	// 								CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 								DiskSizeGB: to.Ptr[int32](6),
	// 								ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 									StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 									SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 										SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 										},
	// 									},
	// 								},
	// 								DiskIOPSReadWrite: to.Ptr[int64](27),
	// 								DiskMBpsReadWrite: to.Ptr[int64](2),
	// 								DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 							},
	// 						},
	// 					},
	// 					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
	// 						HealthProbe: &armcomputefleet.APIEntityReference{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
	// 						},
	// 						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
	// 							{
	// 								Name: to.Ptr("i"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
	// 									Primary: to.Ptr(true),
	// 									EnableAcceleratedNetworking: to.Ptr(true),
	// 									DisableTCPStateTracking: to.Ptr(true),
	// 									EnableFpga: to.Ptr(true),
	// 									NetworkSecurityGroup: &armcomputefleet.SubResource{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
	// 									},
	// 									DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
	// 										DNSServers: []*string{
	// 											to.Ptr("nxmmfolhclsesu"),
	// 										},
	// 									},
	// 									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
	// 										{
	// 											Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
	// 											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
	// 												Subnet: &armcomputefleet.APIEntityReference{
	// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
	// 												},
	// 												Primary: to.Ptr(true),
	// 												PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
	// 													Name: to.Ptr("fvpqf"),
	// 													Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
	// 														IdleTimeoutInMinutes: to.Ptr[int32](9),
	// 														DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
	// 															DomainNameLabel: to.Ptr("ukrddzvmorpmfsczjwtbvp"),
	// 															DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
	// 														},
	// 														IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
	// 															{
	// 																IPTagType: to.Ptr("sddgsoemnzgqizale"),
	// 																Tag: to.Ptr("wufmhrjsakbiaetyara"),
	// 															},
	// 														},
	// 														PublicIPPrefix: &armcomputefleet.SubResource{
	// 															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
	// 														},
	// 														PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 														DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 													},
	// 													SKU: &armcomputefleet.PublicIPAddressSKU{
	// 														Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
	// 														Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
	// 													},
	// 												},
	// 												PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 												ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												ApplicationSecurityGroups: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
	// 													},
	// 												},
	// 												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
	// 													},
	// 												},
	// 											},
	// 										},
	// 									},
	// 									EnableIPForwarding: to.Ptr(true),
	// 									DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 									AuxiliaryMode: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
	// 									AuxiliarySKU: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
	// 								},
	// 							},
	// 						},
	// 						NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
	// 					},
	// 					SecurityProfile: &armcomputefleet.SecurityProfile{
	// 						UefiSettings: &armcomputefleet.UefiSettings{
	// 							SecureBootEnabled: to.Ptr(true),
	// 							VTpmEnabled: to.Ptr(true),
	// 						},
	// 						EncryptionAtHost: to.Ptr(true),
	// 						SecurityType: to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
	// 						EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
	// 							UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
	// 						},
	// 						ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
	// 							Enabled: to.Ptr(true),
	// 							Mode: to.Ptr(armcomputefleet.ModeAudit),
	// 							KeyIncarnationID: to.Ptr[int32](20),
	// 						},
	// 					},
	// 					DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
	// 						BootDiagnostics: &armcomputefleet.BootDiagnostics{
	// 							Enabled: to.Ptr(true),
	// 							StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
	// 						},
	// 					},
	// 					ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
	// 						Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
	// 							{
	// 								Name: to.Ptr("bndxuxx"),
	// 								Type: to.Ptr("cmeam"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
	// 									ForceUpdateTag: to.Ptr("yhgxw"),
	// 									Publisher: to.Ptr("kpxtirxjfprhs"),
	// 									Type: to.Ptr("pgjilctjjwaa"),
	// 									TypeHandlerVersion: to.Ptr("zevivcoilxmbwlrihhhibq"),
	// 									AutoUpgradeMinorVersion: to.Ptr(true),
	// 									EnableAutomaticUpgrade: to.Ptr(true),
	// 									Settings: map[string]any{
	// 									},
	// 									ProvisioningState: to.Ptr("Succeeded"),
	// 									ProvisionAfterExtensions: []*string{
	// 										to.Ptr("nftzosroolbcwmpupujzqwqe"),
	// 									},
	// 									SuppressFailures: to.Ptr(true),
	// 									ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
	// 										SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
	// 										SourceVault: &armcomputefleet.SubResource{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 										},
	// 									},
	// 								},
	// 								ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{extensionName}"),
	// 							},
	// 						},
	// 						ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
	// 					},
	// 					LicenseType: to.Ptr("v"),
	// 					ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
	// 						TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("iljppmmw"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 						OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 					},
	// 					UserData: to.Ptr("s"),
	// 					CapacityReservation: &armcomputefleet.CapacityReservationProfile{
	// 						CapacityReservationGroup: &armcomputefleet.SubResource{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
	// 						},
	// 					},
	// 					ApplicationProfile: &armcomputefleet.ApplicationProfile{
	// 						GalleryApplications: []*armcomputefleet.VMGalleryApplication{
	// 							{
	// 								Tags: to.Ptr("eyrqjbib"),
	// 								Order: to.Ptr[int32](5),
	// 								PackageReferenceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
	// 								TreatFailureAsDeploymentFailure: to.Ptr(true),
	// 								EnableAutomaticUpgrade: to.Ptr(true),
	// 							},
	// 						},
	// 					},
	// 					HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
	// 						VMSizeProperties: &armcomputefleet.VMSizeProperties{
	// 							VCPUsAvailable: to.Ptr[int32](16),
	// 							VCPUsPerCore: to.Ptr[int32](23),
	// 						},
	// 					},
	// 					ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
	// 						ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
	// 					},
	// 					SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
	// 						ID: to.Ptr("/CommunityGalleries/{communityGalleryName}/securityPostures/{securityPostureName}/versions/{major.minor.patch}|{major.*}|latest"),
	// 						ExcludeExtensions: []*string{
	// 							to.Ptr("{securityPostureVMExtensionName}"),
	// 						},
	// 						IsOverridable: to.Ptr(true),
	// 					},
	// 					TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 				},
	// 				ComputeAPIVersion: to.Ptr("2023-07-01"),
	// 				PlatformFaultDomainCount: to.Ptr[int32](1),
	// 			},
	// 			TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
	// 			UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
	// 		},
	// 		Zones: []*string{
	// 			to.Ptr("zone1"),
	// 			to.Ptr("zone2"),
	// 		},
	// 		Identity: &armcomputefleet.ManagedServiceIdentity{
	// 			PrincipalID: to.Ptr("4d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 			TenantID: to.Ptr("5d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 			Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
	// 			UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
	// 				"key9851": &armcomputefleet.UserAssignedIdentity{
	// 					PrincipalID: to.Ptr("6d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 					ClientID: to.Ptr("7d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 				},
	// 			},
	// 		},
	// 		Plan: &armcomputefleet.Plan{
	// 			Name: to.Ptr("jwgrcrnrtfoxn"),
	// 			Publisher: to.Ptr("iozjbiqqckqm"),
	// 			Product: to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
	// 			PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
	// 			Version: to.Ptr("wa"),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key3518": to.Ptr("luvrnuvsgdpbuofdskkcoqhfh"),
	// 		},
	// 		Location: to.Ptr("westus"),
	// 		ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
	// 		Name: to.Ptr("testFleet"),
	// 		Type: to.Ptr("Microsoft.AzureFleet/fleets"),
	// 		SystemData: &armcomputefleet.SystemData{
	// 			CreatedBy: to.Ptr("rowegentrpoajsv"),
	// 			CreatedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("edwuayhhaoepxzisfaqjhmrxjq"),
	// 			LastModifiedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:
Example (FleetsCreateOrUpdateMinimumSet)

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_CreateOrUpdate_MinimumSet.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewFleetsClient().BeginCreateOrUpdate(ctx, "rgazurefleet", "testFleet", armcomputefleet.Fleet{
		Properties: &armcomputefleet.FleetProperties{
			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
				Capacity:           to.Ptr[int32](2),
				MinCapacity:        to.Ptr[int32](1),
				EvictionPolicy:     to.Ptr(armcomputefleet.EvictionPolicyDelete),
				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
				Maintain:           to.Ptr(true),
			},
			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
				Capacity:           to.Ptr[int32](2),
				MinCapacity:        to.Ptr[int32](1),
				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
			},
			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
				{
					Name: to.Ptr("Standard_D2s_v3"),
				},
				{
					Name: to.Ptr("Standard_D4s_v3"),
				},
				{
					Name: to.Ptr("Standard_E2s_v3"),
				},
			},
			ComputeProfile: &armcomputefleet.ComputeProfile{
				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
						ImageReference: &armcomputefleet.ImageReference{
							Publisher: to.Ptr("canonical"),
							Offer:     to.Ptr("0001-com-ubuntu-server-focal"),
							SKU:       to.Ptr("20_04-lts-gen2"),
							Version:   to.Ptr("latest"),
						},
						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
							Caching:      to.Ptr(armcomputefleet.CachingTypesReadWrite),
							CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
							OSType:       to.Ptr(armcomputefleet.OperatingSystemTypesLinux),
							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
							},
						},
					},
					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
						ComputerNamePrefix: to.Ptr("prefix"),
						AdminUsername:      to.Ptr("azureuser"),
						AdminPassword:      to.Ptr("TestPassword$0"),
						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
							DisablePasswordAuthentication: to.Ptr(false),
						},
					},
					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
							{
								Name: to.Ptr("vmNameTest"),
								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
									Primary:                     to.Ptr(true),
									EnableAcceleratedNetworking: to.Ptr(false),
									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
										{
											Name: to.Ptr("vmNameTest"),
											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
												Subnet: &armcomputefleet.APIEntityReference{
													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
												},
												Primary: to.Ptr(true),
												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
													},
												},
											},
										},
									},
									EnableIPForwarding: to.Ptr(true),
								},
							},
						},
					},
				},
				ComputeAPIVersion:        to.Ptr("2023-09-01"),
				PlatformFaultDomainCount: to.Ptr[int32](1),
			},
		},
		Tags: map[string]*string{
			"key": to.Ptr("fleets-test"),
		},
		Location: to.Ptr("eastus2euap"),
	}, 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 = armcomputefleet.FleetsClientCreateOrUpdateResponse{
	// 	Fleet: &armcomputefleet.Fleet{
	// 		Properties: &armcomputefleet.FleetProperties{
	// 			ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateSucceeded),
	// 			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
	// 				Capacity: to.Ptr[int32](2),
	// 				MinCapacity: to.Ptr[int32](1),
	// 				EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
	// 				Maintain: to.Ptr(true),
	// 			},
	// 			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
	// 				Capacity: to.Ptr[int32](2),
	// 				MinCapacity: to.Ptr[int32](1),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
	// 			},
	// 			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
	// 				{
	// 					Name: to.Ptr("Standard_D2s_v3"),
	// 				},
	// 				{
	// 					Name: to.Ptr("Standard_D4s_v3"),
	// 				},
	// 				{
	// 					Name: to.Ptr("Standard_E2s_v3"),
	// 				},
	// 			},
	// 			ComputeProfile: &armcomputefleet.ComputeProfile{
	// 				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
	// 					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
	// 						ImageReference: &armcomputefleet.ImageReference{
	// 							Publisher: to.Ptr("canonical"),
	// 							Offer: to.Ptr("0001-com-ubuntu-server-focal"),
	// 							SKU: to.Ptr("20_04-lts-gen2"),
	// 							Version: to.Ptr("latest"),
	// 						},
	// 						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
	// 							Caching: to.Ptr(armcomputefleet.CachingTypesReadWrite),
	// 							CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 							OSType: to.Ptr(armcomputefleet.OperatingSystemTypesLinux),
	// 							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 							},
	// 						},
	// 					},
	// 					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
	// 						ComputerNamePrefix: to.Ptr("prefix"),
	// 						AdminUsername: to.Ptr("azureuser"),
	// 						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
	// 							DisablePasswordAuthentication: to.Ptr(false),
	// 						},
	// 					},
	// 					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
	// 						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
	// 							{
	// 								Name: to.Ptr("vmNameTest"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
	// 									Primary: to.Ptr(true),
	// 									EnableAcceleratedNetworking: to.Ptr(false),
	// 									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
	// 										{
	// 											Name: to.Ptr("vmNameTest"),
	// 											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
	// 												Subnet: &armcomputefleet.APIEntityReference{
	// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
	// 												},
	// 												Primary: to.Ptr(true),
	// 												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 											},
	// 										},
	// 									},
	// 									EnableIPForwarding: to.Ptr(true),
	// 								},
	// 							},
	// 						},
	// 					},
	// 				},
	// 				ComputeAPIVersion: to.Ptr("2023-09-01"),
	// 				PlatformFaultDomainCount: to.Ptr[int32](1),
	// 			},
	// 			TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
	// 			UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key": to.Ptr("fleets-test"),
	// 		},
	// 		Location: to.Ptr("eastus2euap"),
	// 		ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
	// 		Name: to.Ptr("testFleet"),
	// 		Type: to.Ptr("Microsoft.AzureFleet/fleets"),
	// 	},
	// }
}

Output:

func (*FleetsClient) BeginDelete 

func (client *FleetsClient) BeginDelete(ctx context.Context, resourceGroupName string, fleetName string, options *FleetsClientBeginDeleteOptions) (*runtime.Poller[FleetsClientDeleteResponse], error)

BeginDelete - Delete a Fleet If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • fleetName - The name of the Compute Fleet
  • options - FleetsClientBeginDeleteOptions contains the optional parameters for the FleetsClient.BeginDelete method.
Example

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_Delete.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewFleetsClient().BeginDelete(ctx, "rgazurefleet", "testFleet", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*FleetsClient) BeginUpdate 

func (client *FleetsClient) BeginUpdate(ctx context.Context, resourceGroupName string, fleetName string, properties FleetUpdate, options *FleetsClientBeginUpdateOptions) (*runtime.Poller[FleetsClientUpdateResponse], error)

BeginUpdate - Update a Fleet If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • fleetName - The name of the Compute Fleet
  • properties - The resource properties to be updated.
  • options - FleetsClientBeginUpdateOptions contains the optional parameters for the FleetsClient.BeginUpdate method.
Example

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_Update.json 

package main

import (
	"context"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet"
	"log"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewFleetsClient().BeginUpdate(ctx, "rgazurefleet", "testFleet", armcomputefleet.FleetUpdate{
		Identity: &armcomputefleet.ManagedServiceIdentityUpdate{
			Type:                   to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{},
		},
		Tags: map[string]*string{},
		Properties: &armcomputefleet.FleetProperties{
			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
				Capacity:           to.Ptr[int32](20),
				MinCapacity:        to.Ptr[int32](10),
				MaxPricePerVM:      to.Ptr[float32](0.00865),
				EvictionPolicy:     to.Ptr(armcomputefleet.EvictionPolicyDelete),
				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
				Maintain:           to.Ptr(true),
			},
			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
				Capacity:           to.Ptr[int32](20),
				MinCapacity:        to.Ptr[int32](10),
				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
			},
			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
				{
					Name: to.Ptr("Standard_d1_v2"),
					Rank: to.Ptr[int32](19225),
				},
			},
			ComputeProfile: &armcomputefleet.ComputeProfile{
				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
						ComputerNamePrefix: to.Ptr("o"),
						AdminUsername:      to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
						AdminPassword:      to.Ptr("adfbrdxpv"),
						CustomData:         to.Ptr("xjjib"),
						WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
							ProvisionVMAgent:       to.Ptr(true),
							EnableAutomaticUpdates: to.Ptr(true),
							TimeZone:               to.Ptr("hlyjiqcfksgrpjrct"),
							AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
								{
									PassName:      to.Ptr("OobeSystem"),
									ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
									SettingName:   to.Ptr(armcomputefleet.SettingNamesAutoLogon),
									Content:       to.Ptr("bubmqbxjkj"),
								},
							},
							PatchSettings: &armcomputefleet.PatchSettings{
								PatchMode:         to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
								EnableHotpatching: to.Ptr(true),
								AssessmentMode:    to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
								AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
									RebootSetting:                            to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
								},
							},
							WinRM: &armcomputefleet.WinRMConfiguration{
								Listeners: []*armcomputefleet.WinRMListener{
									{
										Protocol:       to.Ptr(armcomputefleet.ProtocolTypesHTTP),
										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
									},
								},
							},
							EnableVMAgentPlatformUpdates: to.Ptr(true),
						},
						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
							DisablePasswordAuthentication: to.Ptr(true),
							SSH: &armcomputefleet.SSHConfiguration{
								PublicKeys: []*armcomputefleet.SSHPublicKey{
									{
										Path:    to.Ptr("kmqz"),
										KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
									},
								},
							},
							ProvisionVMAgent: to.Ptr(true),
							PatchSettings: &armcomputefleet.LinuxPatchSettings{
								PatchMode:      to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
								AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
								AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
									RebootSetting:                            to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
								},
							},
							EnableVMAgentPlatformUpdates: to.Ptr(true),
						},
						Secrets: []*armcomputefleet.VaultSecretGroup{
							{
								SourceVault: &armcomputefleet.SubResource{
									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
								},
								VaultCertificates: []*armcomputefleet.VaultCertificate{
									{
										CertificateURL:   to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
										CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
									},
								},
							},
						},
						AllowExtensionOperations:    to.Ptr(true),
						RequireGuestProvisionSignal: to.Ptr(true),
					},
					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
						ImageReference: &armcomputefleet.ImageReference{
							Publisher:               to.Ptr("mqxgwbiyjzmxavhbkd"),
							Offer:                   to.Ptr("isxgumkarlkomp"),
							SKU:                     to.Ptr("eojmppqcrnpmxirtp"),
							Version:                 to.Ptr("wvpcqefgtmqdgltiuz"),
							SharedGalleryImageID:    to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
							CommunityGalleryImageID: to.Ptr("vlqe"),
							ID:                      to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
						},
						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
							Name:                    to.Ptr("wfttw"),
							Caching:                 to.Ptr(armcomputefleet.CachingTypesNone),
							WriteAcceleratorEnabled: to.Ptr(true),
							CreateOption:            to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
							DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
								Option:    to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
								Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
							},
							DiskSizeGB: to.Ptr[int32](14),
							OSType:     to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
							Image: &armcomputefleet.VirtualHardDisk{
								URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
							},
							VhdContainers: []*string{
								to.Ptr("tkzcwddtinkfpnfklatw"),
							},
							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
								DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
								},
								SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
									SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
									},
								},
							},
							DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
						},
						DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
							{
								Name:                    to.Ptr("eogiykmdmeikswxmigjws"),
								Lun:                     to.Ptr[int32](14),
								Caching:                 to.Ptr(armcomputefleet.CachingTypesNone),
								WriteAcceleratorEnabled: to.Ptr(true),
								CreateOption:            to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
								DiskSizeGB:              to.Ptr[int32](6),
								ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
									StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
									},
									SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
										SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
										},
									},
								},
								DiskIOPSReadWrite: to.Ptr[int64](27),
								DiskMBpsReadWrite: to.Ptr[int64](2),
								DeleteOption:      to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
							},
						},
					},
					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
						HealthProbe: &armcomputefleet.APIEntityReference{
							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
						},
						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
							{
								Name: to.Ptr("i"),
								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
									Primary:                     to.Ptr(true),
									EnableAcceleratedNetworking: to.Ptr(true),
									DisableTCPStateTracking:     to.Ptr(true),
									EnableFpga:                  to.Ptr(true),
									NetworkSecurityGroup: &armcomputefleet.SubResource{
										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
									},
									DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
										DNSServers: []*string{
											to.Ptr("nxmmfolhclsesu"),
										},
									},
									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
										{
											Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
												Subnet: &armcomputefleet.APIEntityReference{
													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
												},
												Primary: to.Ptr(true),
												PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
													Name: to.Ptr("fvpqf"),
													Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
														IdleTimeoutInMinutes: to.Ptr[int32](9),
														DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
															DomainNameLabel:      to.Ptr("ukrddzvmorpmfsczjwtbvp"),
															DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
														},
														IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
															{
																IPTagType: to.Ptr("sddgsoemnzgqizale"),
																Tag:       to.Ptr("wufmhrjsakbiaetyara"),
															},
														},
														PublicIPPrefix: &armcomputefleet.SubResource{
															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
														},
														PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
														DeleteOption:           to.Ptr(armcomputefleet.DeleteOptionsDelete),
													},
													SKU: &armcomputefleet.PublicIPAddressSKU{
														Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
														Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
													},
												},
												PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
												ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
													},
												},
												ApplicationSecurityGroups: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
													},
												},
												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
													},
												},
												LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
													{
														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
													},
												},
											},
										},
									},
									EnableIPForwarding: to.Ptr(true),
									DeleteOption:       to.Ptr(armcomputefleet.DeleteOptionsDelete),
									AuxiliaryMode:      to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
									AuxiliarySKU:       to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
								},
							},
						},
						NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
					},
					SecurityProfile: &armcomputefleet.SecurityProfile{
						UefiSettings: &armcomputefleet.UefiSettings{
							SecureBootEnabled: to.Ptr(true),
							VTpmEnabled:       to.Ptr(true),
						},
						EncryptionAtHost: to.Ptr(true),
						SecurityType:     to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
						EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
							UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
						},
						ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
							Enabled:          to.Ptr(true),
							Mode:             to.Ptr(armcomputefleet.ModeAudit),
							KeyIncarnationID: to.Ptr[int32](20),
						},
					},
					DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
						BootDiagnostics: &armcomputefleet.BootDiagnostics{
							Enabled:    to.Ptr(true),
							StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
						},
					},
					ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
						Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
							{
								Name: to.Ptr("bndxuxx"),
								Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
									ForceUpdateTag:          to.Ptr("yhgxw"),
									Publisher:               to.Ptr("kpxtirxjfprhs"),
									Type:                    to.Ptr("pgjilctjjwaa"),
									TypeHandlerVersion:      to.Ptr("zevivcoilxmbwlrihhhibq"),
									AutoUpgradeMinorVersion: to.Ptr(true),
									EnableAutomaticUpgrade:  to.Ptr(true),
									Settings:                map[string]any{},
									ProtectedSettings:       map[string]any{},
									ProvisionAfterExtensions: []*string{
										to.Ptr("nftzosroolbcwmpupujzqwqe"),
									},
									SuppressFailures: to.Ptr(true),
									ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
										SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
										SourceVault: &armcomputefleet.SubResource{
											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
										},
									},
								},
							},
						},
						ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
					},
					LicenseType: to.Ptr("v"),
					ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
						TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
							NotBeforeTimeout: to.Ptr("iljppmmw"),
							Enable:           to.Ptr(true),
						},
						OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
							NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
							Enable:           to.Ptr(true),
						},
					},
					UserData: to.Ptr("s"),
					CapacityReservation: &armcomputefleet.CapacityReservationProfile{
						CapacityReservationGroup: &armcomputefleet.SubResource{
							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
						},
					},
					ApplicationProfile: &armcomputefleet.ApplicationProfile{
						GalleryApplications: []*armcomputefleet.VMGalleryApplication{
							{
								Tags:                            to.Ptr("eyrqjbib"),
								Order:                           to.Ptr[int32](5),
								PackageReferenceID:              to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
								ConfigurationReference:          to.Ptr("ulztmiavpojpbpbddgnuuiimxcpau"),
								TreatFailureAsDeploymentFailure: to.Ptr(true),
								EnableAutomaticUpgrade:          to.Ptr(true),
							},
						},
					},
					HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
						VMSizeProperties: &armcomputefleet.VMSizeProperties{
							VCPUsAvailable: to.Ptr[int32](16),
							VCPUsPerCore:   to.Ptr[int32](23),
						},
					},
					ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
						ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
					},
					SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
						ID: to.Ptr("/CommunityGalleries/{communityGalleryName}/securityPostures/{securityPostureName}/versions/{major.minor.patch}|{major.*}|latest"),
						ExcludeExtensions: []*string{
							to.Ptr("{securityPostureVMExtensionName}"),
						},
						IsOverridable: to.Ptr(true),
					},
				},
				ComputeAPIVersion:        to.Ptr("2023-07-01"),
				PlatformFaultDomainCount: to.Ptr[int32](1),
			},
		},
		Plan: &armcomputefleet.ResourcePlanUpdate{
			Name:          to.Ptr("jwgrcrnrtfoxn"),
			Publisher:     to.Ptr("iozjbiqqckqm"),
			Product:       to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
			PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
			Version:       to.Ptr("wa"),
		},
	}, 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 = armcomputefleet.FleetsClientUpdateResponse{
	// 	Fleet: &armcomputefleet.Fleet{
	// 		Properties: &armcomputefleet.FleetProperties{
	// 			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
	// 				Capacity: to.Ptr[int32](20),
	// 				MinCapacity: to.Ptr[int32](10),
	// 				MaxPricePerVM: to.Ptr[float32](0.00865),
	// 				EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
	// 				Maintain: to.Ptr(true),
	// 			},
	// 			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
	// 				Capacity: to.Ptr[int32](20),
	// 				MinCapacity: to.Ptr[int32](10),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
	// 			},
	// 			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
	// 				{
	// 					Name: to.Ptr("Standard_d1_v2"),
	// 					Rank: to.Ptr[int32](19225),
	// 				},
	// 			},
	// 			ComputeProfile: &armcomputefleet.ComputeProfile{
	// 				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
	// 					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
	// 						ComputerNamePrefix: to.Ptr("o"),
	// 						AdminUsername: to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
	// 						WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							EnableAutomaticUpdates: to.Ptr(true),
	// 							TimeZone: to.Ptr("hlyjiqcfksgrpjrct"),
	// 							AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
	// 								{
	// 									PassName: to.Ptr("OobeSystem"),
	// 									ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
	// 									SettingName: to.Ptr(armcomputefleet.SettingNamesAutoLogon),
	// 								},
	// 							},
	// 							PatchSettings: &armcomputefleet.PatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
	// 								EnableHotpatching: to.Ptr(true),
	// 								AssessmentMode: to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							WinRM: &armcomputefleet.WinRMConfiguration{
	// 								Listeners: []*armcomputefleet.WinRMListener{
	// 									{
	// 										Protocol: to.Ptr(armcomputefleet.ProtocolTypesHTTP),
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 									},
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
	// 							DisablePasswordAuthentication: to.Ptr(true),
	// 							SSH: &armcomputefleet.SSHConfiguration{
	// 								PublicKeys: []*armcomputefleet.SSHPublicKey{
	// 									{
	// 										Path: to.Ptr("kmqz"),
	// 										KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
	// 									},
	// 								},
	// 							},
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							PatchSettings: &armcomputefleet.LinuxPatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
	// 								AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						Secrets: []*armcomputefleet.VaultSecretGroup{
	// 							{
	// 								SourceVault: &armcomputefleet.SubResource{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 								},
	// 								VaultCertificates: []*armcomputefleet.VaultCertificate{
	// 									{
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 										CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
	// 									},
	// 								},
	// 							},
	// 						},
	// 						AllowExtensionOperations: to.Ptr(true),
	// 						RequireGuestProvisionSignal: to.Ptr(true),
	// 					},
	// 					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
	// 						ImageReference: &armcomputefleet.ImageReference{
	// 							Publisher: to.Ptr("mqxgwbiyjzmxavhbkd"),
	// 							Offer: to.Ptr("isxgumkarlkomp"),
	// 							SKU: to.Ptr("eojmppqcrnpmxirtp"),
	// 							Version: to.Ptr("wvpcqefgtmqdgltiuz"),
	// 							SharedGalleryImageID: to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
	// 							CommunityGalleryImageID: to.Ptr("vlqe"),
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
	// 							ExactVersion: to.Ptr("zjbntmiskjexlr"),
	// 						},
	// 						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
	// 							Name: to.Ptr("wfttw"),
	// 							Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 							WriteAcceleratorEnabled: to.Ptr(true),
	// 							CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 							DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
	// 								Option: to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
	// 								Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
	// 							},
	// 							DiskSizeGB: to.Ptr[int32](14),
	// 							OSType: to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
	// 							Image: &armcomputefleet.VirtualHardDisk{
	// 								URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
	// 							},
	// 							VhdContainers: []*string{
	// 								to.Ptr("tkzcwddtinkfpnfklatw"),
	// 							},
	// 							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 								DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 								},
	// 								SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 									SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 								},
	// 							},
	// 							DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 						},
	// 						DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
	// 							{
	// 								Name: to.Ptr("eogiykmdmeikswxmigjws"),
	// 								Lun: to.Ptr[int32](14),
	// 								Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 								WriteAcceleratorEnabled: to.Ptr(true),
	// 								CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 								DiskSizeGB: to.Ptr[int32](6),
	// 								ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 									StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 									SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 										SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 										},
	// 									},
	// 								},
	// 								DiskIOPSReadWrite: to.Ptr[int64](27),
	// 								DiskMBpsReadWrite: to.Ptr[int64](2),
	// 								DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 							},
	// 						},
	// 					},
	// 					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
	// 						HealthProbe: &armcomputefleet.APIEntityReference{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
	// 						},
	// 						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
	// 							{
	// 								Name: to.Ptr("i"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
	// 									Primary: to.Ptr(true),
	// 									EnableAcceleratedNetworking: to.Ptr(true),
	// 									DisableTCPStateTracking: to.Ptr(true),
	// 									EnableFpga: to.Ptr(true),
	// 									NetworkSecurityGroup: &armcomputefleet.SubResource{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
	// 									},
	// 									DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
	// 										DNSServers: []*string{
	// 											to.Ptr("nxmmfolhclsesu"),
	// 										},
	// 									},
	// 									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
	// 										{
	// 											Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
	// 											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
	// 												Subnet: &armcomputefleet.APIEntityReference{
	// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
	// 												},
	// 												Primary: to.Ptr(true),
	// 												PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
	// 													Name: to.Ptr("fvpqf"),
	// 													Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
	// 														IdleTimeoutInMinutes: to.Ptr[int32](9),
	// 														DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
	// 															DomainNameLabel: to.Ptr("ukrddzvmorpmfsczjwtbvp"),
	// 															DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
	// 														},
	// 														IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
	// 															{
	// 																IPTagType: to.Ptr("sddgsoemnzgqizale"),
	// 																Tag: to.Ptr("wufmhrjsakbiaetyara"),
	// 															},
	// 														},
	// 														PublicIPPrefix: &armcomputefleet.SubResource{
	// 															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
	// 														},
	// 														PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 														DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 													},
	// 													SKU: &armcomputefleet.PublicIPAddressSKU{
	// 														Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
	// 														Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
	// 													},
	// 												},
	// 												PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 												ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												ApplicationSecurityGroups: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
	// 													},
	// 												},
	// 												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
	// 													},
	// 												},
	// 											},
	// 										},
	// 									},
	// 									EnableIPForwarding: to.Ptr(true),
	// 									DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 									AuxiliaryMode: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
	// 									AuxiliarySKU: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
	// 								},
	// 							},
	// 						},
	// 						NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
	// 					},
	// 					SecurityProfile: &armcomputefleet.SecurityProfile{
	// 						UefiSettings: &armcomputefleet.UefiSettings{
	// 							SecureBootEnabled: to.Ptr(true),
	// 							VTpmEnabled: to.Ptr(true),
	// 						},
	// 						EncryptionAtHost: to.Ptr(true),
	// 						SecurityType: to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
	// 						EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
	// 							UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
	// 						},
	// 						ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
	// 							Enabled: to.Ptr(true),
	// 							Mode: to.Ptr(armcomputefleet.ModeAudit),
	// 							KeyIncarnationID: to.Ptr[int32](20),
	// 						},
	// 					},
	// 					DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
	// 						BootDiagnostics: &armcomputefleet.BootDiagnostics{
	// 							Enabled: to.Ptr(true),
	// 							StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
	// 						},
	// 					},
	// 					ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
	// 						Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
	// 							{
	// 								Name: to.Ptr("bndxuxx"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
	// 									ForceUpdateTag: to.Ptr("yhgxw"),
	// 									Publisher: to.Ptr("kpxtirxjfprhs"),
	// 									Type: to.Ptr("pgjilctjjwaa"),
	// 									TypeHandlerVersion: to.Ptr("zevivcoilxmbwlrihhhibq"),
	// 									AutoUpgradeMinorVersion: to.Ptr(true),
	// 									EnableAutomaticUpgrade: to.Ptr(true),
	// 									ProvisionAfterExtensions: []*string{
	// 										to.Ptr("nftzosroolbcwmpupujzqwqe"),
	// 									},
	// 									SuppressFailures: to.Ptr(true),
	// 									ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
	// 										SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
	// 										SourceVault: &armcomputefleet.SubResource{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 										},
	// 									},
	// 									Settings: map[string]any{
	// 									},
	// 									ProvisioningState: to.Ptr("Succeeded"),
	// 								},
	// 								Type: to.Ptr("cmeam"),
	// 								ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{extensionName}"),
	// 							},
	// 						},
	// 						ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
	// 					},
	// 					LicenseType: to.Ptr("v"),
	// 					ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
	// 						TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("iljppmmw"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 						OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 					},
	// 					UserData: to.Ptr("s"),
	// 					CapacityReservation: &armcomputefleet.CapacityReservationProfile{
	// 						CapacityReservationGroup: &armcomputefleet.SubResource{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
	// 						},
	// 					},
	// 					ApplicationProfile: &armcomputefleet.ApplicationProfile{
	// 						GalleryApplications: []*armcomputefleet.VMGalleryApplication{
	// 							{
	// 								Tags: to.Ptr("eyrqjbib"),
	// 								Order: to.Ptr[int32](5),
	// 								PackageReferenceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
	// 								TreatFailureAsDeploymentFailure: to.Ptr(true),
	// 								EnableAutomaticUpgrade: to.Ptr(true),
	// 							},
	// 						},
	// 					},
	// 					HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
	// 						VMSizeProperties: &armcomputefleet.VMSizeProperties{
	// 							VCPUsAvailable: to.Ptr[int32](16),
	// 							VCPUsPerCore: to.Ptr[int32](23),
	// 						},
	// 					},
	// 					ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
	// 						ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
	// 					},
	// 					SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
	// 						ID: to.Ptr("/CommunityGalleries/{communityGalleryName}/securityPostures/{securityPostureName}/versions/{major.minor.patch}|{major.*}|latest"),
	// 						ExcludeExtensions: []*string{
	// 							to.Ptr("{securityPostureVMExtensionName}"),
	// 						},
	// 						IsOverridable: to.Ptr(true),
	// 					},
	// 					TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 				},
	// 				ComputeAPIVersion: to.Ptr("2023-07-01"),
	// 				PlatformFaultDomainCount: to.Ptr[int32](1),
	// 			},
	// 			ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateCreating),
	// 			TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
	// 			UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
	// 		},
	// 		Zones: []*string{
	// 			to.Ptr("zone1"),
	// 			to.Ptr("zone2"),
	// 		},
	// 		Identity: &armcomputefleet.ManagedServiceIdentity{
	// 			Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
	// 			UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
	// 			},
	// 			PrincipalID: to.Ptr("4d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 			TenantID: to.Ptr("5d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 		Location: to.Ptr("westus"),
	// 		Plan: &armcomputefleet.Plan{
	// 			Name: to.Ptr("uapfngmdekvpgjhomthtpxjfdmmll"),
	// 			Publisher: to.Ptr("aqhles"),
	// 			Product: to.Ptr("bfzbkdnbexmedxdc"),
	// 			PromotionCode: to.Ptr("gspehogwfjxirz"),
	// 			Version: to.Ptr("yza"),
	// 		},
	// 		ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
	// 		Name: to.Ptr("testFleet"),
	// 		Type: to.Ptr("Microsoft.AzureFleet/fleets"),
	// 		SystemData: &armcomputefleet.SystemData{
	// 			CreatedBy: to.Ptr("rowegentrpoajsv"),
	// 			CreatedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("edwuayhhaoepxzisfaqjhmrxjq"),
	// 			LastModifiedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*FleetsClient) Get 

func (client *FleetsClient) Get(ctx context.Context, resourceGroupName string, fleetName string, options *FleetsClientGetOptions) (FleetsClientGetResponse, error)

Get - Get a Fleet If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • fleetName - The name of the Compute Fleet
  • options - FleetsClientGetOptions contains the optional parameters for the FleetsClient.Get method.
Example

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_Get.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewFleetsClient().Get(ctx, "rgazurefleet", "testFleet", 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 = armcomputefleet.FleetsClientGetResponse{
	// 	Fleet: &armcomputefleet.Fleet{
	// 		Properties: &armcomputefleet.FleetProperties{
	// 			ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateCreating),
	// 			SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
	// 				Capacity: to.Ptr[int32](20),
	// 				MinCapacity: to.Ptr[int32](10),
	// 				MaxPricePerVM: to.Ptr[float32](0.00865),
	// 				EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
	// 				Maintain: to.Ptr(true),
	// 			},
	// 			RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
	// 				Capacity: to.Ptr[int32](20),
	// 				MinCapacity: to.Ptr[int32](10),
	// 				AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
	// 			},
	// 			VMSizesProfile: []*armcomputefleet.VMSizeProfile{
	// 				{
	// 					Name: to.Ptr("Standard_d1_v2"),
	// 					Rank: to.Ptr[int32](19225),
	// 				},
	// 			},
	// 			ComputeProfile: &armcomputefleet.ComputeProfile{
	// 				BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
	// 					OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
	// 						ComputerNamePrefix: to.Ptr("o"),
	// 						AdminUsername: to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
	// 						WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							EnableAutomaticUpdates: to.Ptr(true),
	// 							TimeZone: to.Ptr("hlyjiqcfksgrpjrct"),
	// 							AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
	// 								{
	// 									PassName: to.Ptr("OobeSystem"),
	// 									ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
	// 									SettingName: to.Ptr(armcomputefleet.SettingNamesAutoLogon),
	// 								},
	// 							},
	// 							PatchSettings: &armcomputefleet.PatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
	// 								EnableHotpatching: to.Ptr(true),
	// 								AssessmentMode: to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							WinRM: &armcomputefleet.WinRMConfiguration{
	// 								Listeners: []*armcomputefleet.WinRMListener{
	// 									{
	// 										Protocol: to.Ptr(armcomputefleet.ProtocolTypesHTTP),
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 									},
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
	// 							DisablePasswordAuthentication: to.Ptr(true),
	// 							SSH: &armcomputefleet.SSHConfiguration{
	// 								PublicKeys: []*armcomputefleet.SSHPublicKey{
	// 									{
	// 										Path: to.Ptr("kmqz"),
	// 										KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
	// 									},
	// 								},
	// 							},
	// 							ProvisionVMAgent: to.Ptr(true),
	// 							PatchSettings: &armcomputefleet.LinuxPatchSettings{
	// 								PatchMode: to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
	// 								AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
	// 								AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
	// 									RebootSetting: to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
	// 									BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
	// 								},
	// 							},
	// 							EnableVMAgentPlatformUpdates: to.Ptr(true),
	// 						},
	// 						Secrets: []*armcomputefleet.VaultSecretGroup{
	// 							{
	// 								SourceVault: &armcomputefleet.SubResource{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 								},
	// 								VaultCertificates: []*armcomputefleet.VaultCertificate{
	// 									{
	// 										CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
	// 										CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
	// 									},
	// 								},
	// 							},
	// 						},
	// 						AllowExtensionOperations: to.Ptr(true),
	// 						RequireGuestProvisionSignal: to.Ptr(true),
	// 					},
	// 					StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
	// 						ImageReference: &armcomputefleet.ImageReference{
	// 							Publisher: to.Ptr("mqxgwbiyjzmxavhbkd"),
	// 							Offer: to.Ptr("isxgumkarlkomp"),
	// 							SKU: to.Ptr("eojmppqcrnpmxirtp"),
	// 							Version: to.Ptr("wvpcqefgtmqdgltiuz"),
	// 							ExactVersion: to.Ptr("zjbntmiskjexlr"),
	// 							SharedGalleryImageID: to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
	// 							CommunityGalleryImageID: to.Ptr("vlqe"),
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
	// 						},
	// 						OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
	// 							Name: to.Ptr("wfttw"),
	// 							Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 							WriteAcceleratorEnabled: to.Ptr(true),
	// 							CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 							DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
	// 								Option: to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
	// 								Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
	// 							},
	// 							DiskSizeGB: to.Ptr[int32](14),
	// 							OSType: to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
	// 							Image: &armcomputefleet.VirtualHardDisk{
	// 								URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
	// 							},
	// 							VhdContainers: []*string{
	// 								to.Ptr("tkzcwddtinkfpnfklatw"),
	// 							},
	// 							ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 								StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 								DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 								},
	// 								SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 									SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 								},
	// 							},
	// 							DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 						},
	// 						DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
	// 							{
	// 								Name: to.Ptr("eogiykmdmeikswxmigjws"),
	// 								Lun: to.Ptr[int32](14),
	// 								Caching: to.Ptr(armcomputefleet.CachingTypesNone),
	// 								WriteAcceleratorEnabled: to.Ptr(true),
	// 								CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
	// 								DiskSizeGB: to.Ptr[int32](6),
	// 								ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
	// 									StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
	// 									DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 									},
	// 									SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
	// 										SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
	// 										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
	// 										},
	// 									},
	// 								},
	// 								DiskIOPSReadWrite: to.Ptr[int64](27),
	// 								DiskMBpsReadWrite: to.Ptr[int64](2),
	// 								DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
	// 							},
	// 						},
	// 					},
	// 					NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
	// 						HealthProbe: &armcomputefleet.APIEntityReference{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
	// 						},
	// 						NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
	// 							{
	// 								Name: to.Ptr("i"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
	// 									Primary: to.Ptr(true),
	// 									EnableAcceleratedNetworking: to.Ptr(true),
	// 									DisableTCPStateTracking: to.Ptr(true),
	// 									EnableFpga: to.Ptr(true),
	// 									NetworkSecurityGroup: &armcomputefleet.SubResource{
	// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
	// 									},
	// 									DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
	// 										DNSServers: []*string{
	// 											to.Ptr("nxmmfolhclsesu"),
	// 										},
	// 									},
	// 									IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
	// 										{
	// 											Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
	// 											Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
	// 												Subnet: &armcomputefleet.APIEntityReference{
	// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
	// 												},
	// 												Primary: to.Ptr(true),
	// 												PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
	// 													Name: to.Ptr("fvpqf"),
	// 													Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
	// 														IdleTimeoutInMinutes: to.Ptr[int32](9),
	// 														DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
	// 															DomainNameLabel: to.Ptr("ukrddzvmorpmfsczjwtbvp"),
	// 															DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
	// 														},
	// 														IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
	// 															{
	// 																IPTagType: to.Ptr("sddgsoemnzgqizale"),
	// 																Tag: to.Ptr("wufmhrjsakbiaetyara"),
	// 															},
	// 														},
	// 														PublicIPPrefix: &armcomputefleet.SubResource{
	// 															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
	// 														},
	// 														PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 														DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 													},
	// 													SKU: &armcomputefleet.PublicIPAddressSKU{
	// 														Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
	// 														Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
	// 													},
	// 												},
	// 												PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
	// 												ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												ApplicationSecurityGroups: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
	// 													},
	// 												},
	// 												LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
	// 													},
	// 												},
	// 												LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
	// 													{
	// 														ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
	// 													},
	// 												},
	// 											},
	// 										},
	// 									},
	// 									EnableIPForwarding: to.Ptr(true),
	// 									DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
	// 									AuxiliaryMode: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
	// 									AuxiliarySKU: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
	// 								},
	// 							},
	// 						},
	// 						NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
	// 					},
	// 					SecurityProfile: &armcomputefleet.SecurityProfile{
	// 						UefiSettings: &armcomputefleet.UefiSettings{
	// 							SecureBootEnabled: to.Ptr(true),
	// 							VTpmEnabled: to.Ptr(true),
	// 						},
	// 						EncryptionAtHost: to.Ptr(true),
	// 						SecurityType: to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
	// 						EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
	// 							UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
	// 						},
	// 						ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
	// 							Enabled: to.Ptr(true),
	// 							Mode: to.Ptr(armcomputefleet.ModeAudit),
	// 							KeyIncarnationID: to.Ptr[int32](20),
	// 						},
	// 					},
	// 					DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
	// 						BootDiagnostics: &armcomputefleet.BootDiagnostics{
	// 							Enabled: to.Ptr(true),
	// 							StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
	// 						},
	// 					},
	// 					ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
	// 						Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
	// 							{
	// 								Name: to.Ptr("bndxuxx"),
	// 								Type: to.Ptr("cmeam"),
	// 								Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
	// 									ForceUpdateTag: to.Ptr("yhgxw"),
	// 									Publisher: to.Ptr("kpxtirxjfprhs"),
	// 									Type: to.Ptr("pgjilctjjwaa"),
	// 									TypeHandlerVersion: to.Ptr("zevivcoilxmbwlrihhhibq"),
	// 									AutoUpgradeMinorVersion: to.Ptr(true),
	// 									EnableAutomaticUpgrade: to.Ptr(true),
	// 									Settings: map[string]any{
	// 									},
	// 									ProvisioningState: to.Ptr("Succeeded"),
	// 									ProvisionAfterExtensions: []*string{
	// 										to.Ptr("nftzosroolbcwmpupujzqwqe"),
	// 									},
	// 									SuppressFailures: to.Ptr(true),
	// 									ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
	// 										SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
	// 										SourceVault: &armcomputefleet.SubResource{
	// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
	// 										},
	// 									},
	// 								},
	// 								ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{extensionName}"),
	// 							},
	// 						},
	// 						ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
	// 					},
	// 					LicenseType: to.Ptr("v"),
	// 					ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
	// 						TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("iljppmmw"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 						OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
	// 							NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
	// 							Enable: to.Ptr(true),
	// 						},
	// 					},
	// 					UserData: to.Ptr("s"),
	// 					CapacityReservation: &armcomputefleet.CapacityReservationProfile{
	// 						CapacityReservationGroup: &armcomputefleet.SubResource{
	// 							ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
	// 						},
	// 					},
	// 					ApplicationProfile: &armcomputefleet.ApplicationProfile{
	// 						GalleryApplications: []*armcomputefleet.VMGalleryApplication{
	// 							{
	// 								Tags: to.Ptr("eyrqjbib"),
	// 								Order: to.Ptr[int32](5),
	// 								PackageReferenceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
	// 								TreatFailureAsDeploymentFailure: to.Ptr(true),
	// 								EnableAutomaticUpgrade: to.Ptr(true),
	// 							},
	// 						},
	// 					},
	// 					HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
	// 						VMSizeProperties: &armcomputefleet.VMSizeProperties{
	// 							VCPUsAvailable: to.Ptr[int32](16),
	// 							VCPUsPerCore: to.Ptr[int32](23),
	// 						},
	// 					},
	// 					ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
	// 						ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
	// 					},
	// 					SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
	// 						ID: to.Ptr("mubredelfbshboaxrsxiajihahaa"),
	// 						ExcludeExtensions: []*string{
	// 							to.Ptr("{securityPostureVMExtensionName}"),
	// 						},
	// 						IsOverridable: to.Ptr(true),
	// 					},
	// 					TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 				},
	// 				ComputeAPIVersion: to.Ptr("2023-07-01"),
	// 				PlatformFaultDomainCount: to.Ptr[int32](1),
	// 			},
	// 			TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
	// 			UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
	// 		},
	// 		Zones: []*string{
	// 			to.Ptr("zone1"),
	// 			to.Ptr("zone2"),
	// 		},
	// 		Identity: &armcomputefleet.ManagedServiceIdentity{
	// 			PrincipalID: to.Ptr("4d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 			TenantID: to.Ptr("5d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 			Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
	// 			UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
	// 				"key9851": &armcomputefleet.UserAssignedIdentity{
	// 					PrincipalID: to.Ptr("6d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 					ClientID: to.Ptr("7d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
	// 				},
	// 			},
	// 		},
	// 		Tags: map[string]*string{
	// 			"key3518": to.Ptr("luvrnuvsgdpbuofdskkcoqhfh"),
	// 		},
	// 		Plan: &armcomputefleet.Plan{
	// 			Name: to.Ptr("jwgrcrnrtfoxn"),
	// 			Publisher: to.Ptr("iozjbiqqckqm"),
	// 			Product: to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
	// 			PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
	// 			Version: to.Ptr("wa"),
	// 		},
	// 		Location: to.Ptr("westus"),
	// 		ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
	// 		Name: to.Ptr("testFleet"),
	// 		Type: to.Ptr("Microsoft.AzureFleet/fleets"),
	// 		SystemData: &armcomputefleet.SystemData{
	// 			CreatedBy: to.Ptr("rowegentrpoajsv"),
	// 			CreatedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 			LastModifiedBy: to.Ptr("edwuayhhaoepxzisfaqjhmrxjq"),
	// 			LastModifiedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
	// 			LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
	// 		},
	// 	},
	// }
}

Output:

func (*FleetsClient) NewListByResourceGroupPager 

func (client *FleetsClient) NewListByResourceGroupPager(resourceGroupName string, options *FleetsClientListByResourceGroupOptions) *runtime.Pager[FleetsClientListByResourceGroupResponse]

NewListByResourceGroupPager - List Fleet resources by resource group

Generated from API version 2024-11-01

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

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_ListByResourceGroup.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewFleetsClient().NewListByResourceGroupPager("rgazurefleet", 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 = armcomputefleet.FleetsClientListByResourceGroupResponse{
		// 	FleetListResult: armcomputefleet.FleetListResult{
		// 		Value: []*armcomputefleet.Fleet{
		// 			{
		// 				Properties: &armcomputefleet.FleetProperties{
		// 					ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateCreating),
		// 					SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
		// 						Capacity: to.Ptr[int32](20),
		// 						MinCapacity: to.Ptr[int32](10),
		// 						MaxPricePerVM: to.Ptr[float32](0.00865),
		// 						EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
		// 						AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
		// 						Maintain: to.Ptr(true),
		// 					},
		// 					RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
		// 						Capacity: to.Ptr[int32](20),
		// 						MinCapacity: to.Ptr[int32](10),
		// 						AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
		// 					},
		// 					VMSizesProfile: []*armcomputefleet.VMSizeProfile{
		// 						{
		// 							Name: to.Ptr("Standard_d1_v2"),
		// 							Rank: to.Ptr[int32](19225),
		// 						},
		// 					},
		// 					ComputeProfile: &armcomputefleet.ComputeProfile{
		// 						BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
		// 							OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
		// 								ComputerNamePrefix: to.Ptr("o"),
		// 								AdminUsername: to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
		// 								WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
		// 									ProvisionVMAgent: to.Ptr(true),
		// 									EnableAutomaticUpdates: to.Ptr(true),
		// 									TimeZone: to.Ptr("hlyjiqcfksgrpjrct"),
		// 									AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
		// 										{
		// 											PassName: to.Ptr("OobeSystem"),
		// 											ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
		// 											SettingName: to.Ptr(armcomputefleet.SettingNamesAutoLogon),
		// 										},
		// 									},
		// 									PatchSettings: &armcomputefleet.PatchSettings{
		// 										PatchMode: to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
		// 										EnableHotpatching: to.Ptr(true),
		// 										AssessmentMode: to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
		// 										AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
		// 											RebootSetting: to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
		// 											BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
		// 										},
		// 									},
		// 									WinRM: &armcomputefleet.WinRMConfiguration{
		// 										Listeners: []*armcomputefleet.WinRMListener{
		// 											{
		// 												Protocol: to.Ptr(armcomputefleet.ProtocolTypesHTTP),
		// 												CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
		// 											},
		// 										},
		// 									},
		// 									EnableVMAgentPlatformUpdates: to.Ptr(true),
		// 								},
		// 								LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
		// 									DisablePasswordAuthentication: to.Ptr(true),
		// 									SSH: &armcomputefleet.SSHConfiguration{
		// 										PublicKeys: []*armcomputefleet.SSHPublicKey{
		// 											{
		// 												Path: to.Ptr("kmqz"),
		// 												KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
		// 											},
		// 										},
		// 									},
		// 									ProvisionVMAgent: to.Ptr(true),
		// 									PatchSettings: &armcomputefleet.LinuxPatchSettings{
		// 										PatchMode: to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
		// 										AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
		// 										AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
		// 											RebootSetting: to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
		// 											BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
		// 										},
		// 									},
		// 									EnableVMAgentPlatformUpdates: to.Ptr(true),
		// 								},
		// 								Secrets: []*armcomputefleet.VaultSecretGroup{
		// 									{
		// 										SourceVault: &armcomputefleet.SubResource{
		// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
		// 										},
		// 										VaultCertificates: []*armcomputefleet.VaultCertificate{
		// 											{
		// 												CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
		// 												CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
		// 											},
		// 										},
		// 									},
		// 								},
		// 								AllowExtensionOperations: to.Ptr(true),
		// 								RequireGuestProvisionSignal: to.Ptr(true),
		// 							},
		// 							StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
		// 								ImageReference: &armcomputefleet.ImageReference{
		// 									Publisher: to.Ptr("mqxgwbiyjzmxavhbkd"),
		// 									Offer: to.Ptr("isxgumkarlkomp"),
		// 									SKU: to.Ptr("eojmppqcrnpmxirtp"),
		// 									Version: to.Ptr("wvpcqefgtmqdgltiuz"),
		// 									ExactVersion: to.Ptr("zjbntmiskjexlr"),
		// 									SharedGalleryImageID: to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
		// 									CommunityGalleryImageID: to.Ptr("vlqe"),
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
		// 								},
		// 								OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
		// 									Name: to.Ptr("wfttw"),
		// 									Caching: to.Ptr(armcomputefleet.CachingTypesNone),
		// 									WriteAcceleratorEnabled: to.Ptr(true),
		// 									CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
		// 									DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
		// 										Option: to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
		// 										Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
		// 									},
		// 									DiskSizeGB: to.Ptr[int32](14),
		// 									OSType: to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
		// 									Image: &armcomputefleet.VirtualHardDisk{
		// 										URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
		// 									},
		// 									VhdContainers: []*string{
		// 										to.Ptr("tkzcwddtinkfpnfklatw"),
		// 									},
		// 									ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
		// 										StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
		// 										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 										},
		// 										SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
		// 											SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
		// 											DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 											},
		// 										},
		// 									},
		// 									DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
		// 								},
		// 								DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
		// 									{
		// 										Name: to.Ptr("eogiykmdmeikswxmigjws"),
		// 										Lun: to.Ptr[int32](14),
		// 										Caching: to.Ptr(armcomputefleet.CachingTypesNone),
		// 										WriteAcceleratorEnabled: to.Ptr(true),
		// 										CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
		// 										DiskSizeGB: to.Ptr[int32](6),
		// 										ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
		// 											StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
		// 											DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 											},
		// 											SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
		// 												SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
		// 												DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 												},
		// 											},
		// 										},
		// 										DiskIOPSReadWrite: to.Ptr[int64](27),
		// 										DiskMBpsReadWrite: to.Ptr[int64](2),
		// 										DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
		// 									},
		// 								},
		// 							},
		// 							NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
		// 								HealthProbe: &armcomputefleet.APIEntityReference{
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
		// 								},
		// 								NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
		// 									{
		// 										Name: to.Ptr("i"),
		// 										Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
		// 											Primary: to.Ptr(true),
		// 											EnableAcceleratedNetworking: to.Ptr(true),
		// 											DisableTCPStateTracking: to.Ptr(true),
		// 											EnableFpga: to.Ptr(true),
		// 											NetworkSecurityGroup: &armcomputefleet.SubResource{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
		// 											},
		// 											DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
		// 												DNSServers: []*string{
		// 													to.Ptr("nxmmfolhclsesu"),
		// 												},
		// 											},
		// 											IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
		// 												{
		// 													Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
		// 													Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
		// 														Subnet: &armcomputefleet.APIEntityReference{
		// 															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
		// 														},
		// 														Primary: to.Ptr(true),
		// 														PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
		// 															Name: to.Ptr("fvpqf"),
		// 															Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
		// 																IdleTimeoutInMinutes: to.Ptr[int32](9),
		// 																DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
		// 																	DomainNameLabel: to.Ptr("ukrddzvmorpmfsczjwtbvp"),
		// 																	DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
		// 																},
		// 																IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
		// 																	{
		// 																		IPTagType: to.Ptr("sddgsoemnzgqizale"),
		// 																		Tag: to.Ptr("wufmhrjsakbiaetyara"),
		// 																	},
		// 																},
		// 																PublicIPPrefix: &armcomputefleet.SubResource{
		// 																	ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
		// 																},
		// 																PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
		// 																DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
		// 															},
		// 															SKU: &armcomputefleet.PublicIPAddressSKU{
		// 																Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
		// 																Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
		// 															},
		// 														},
		// 														PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
		// 														ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
		// 															},
		// 														},
		// 														ApplicationSecurityGroups: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
		// 															},
		// 														},
		// 														LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
		// 															},
		// 														},
		// 														LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
		// 															},
		// 														},
		// 													},
		// 												},
		// 											},
		// 											EnableIPForwarding: to.Ptr(true),
		// 											DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
		// 											AuxiliaryMode: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
		// 											AuxiliarySKU: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
		// 										},
		// 									},
		// 								},
		// 								NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
		// 							},
		// 							SecurityProfile: &armcomputefleet.SecurityProfile{
		// 								UefiSettings: &armcomputefleet.UefiSettings{
		// 									SecureBootEnabled: to.Ptr(true),
		// 									VTpmEnabled: to.Ptr(true),
		// 								},
		// 								EncryptionAtHost: to.Ptr(true),
		// 								SecurityType: to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
		// 								EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
		// 									UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
		// 								},
		// 								ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
		// 									Enabled: to.Ptr(true),
		// 									Mode: to.Ptr(armcomputefleet.ModeAudit),
		// 									KeyIncarnationID: to.Ptr[int32](20),
		// 								},
		// 							},
		// 							DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
		// 								BootDiagnostics: &armcomputefleet.BootDiagnostics{
		// 									Enabled: to.Ptr(true),
		// 									StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
		// 								},
		// 							},
		// 							ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
		// 								Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
		// 									{
		// 										Name: to.Ptr("bndxuxx"),
		// 										Type: to.Ptr("cmeam"),
		// 										Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
		// 											ForceUpdateTag: to.Ptr("yhgxw"),
		// 											Publisher: to.Ptr("kpxtirxjfprhs"),
		// 											Type: to.Ptr("pgjilctjjwaa"),
		// 											TypeHandlerVersion: to.Ptr("zevivcoilxmbwlrihhhibq"),
		// 											AutoUpgradeMinorVersion: to.Ptr(true),
		// 											EnableAutomaticUpgrade: to.Ptr(true),
		// 											Settings: map[string]any{
		// 											},
		// 											ProvisioningState: to.Ptr("Succeeded"),
		// 											ProvisionAfterExtensions: []*string{
		// 												to.Ptr("nftzosroolbcwmpupujzqwqe"),
		// 											},
		// 											SuppressFailures: to.Ptr(true),
		// 											ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
		// 												SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
		// 												SourceVault: &armcomputefleet.SubResource{
		// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
		// 												},
		// 											},
		// 										},
		// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{extensionName}"),
		// 									},
		// 								},
		// 								ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
		// 							},
		// 							LicenseType: to.Ptr("v"),
		// 							ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
		// 								TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
		// 									NotBeforeTimeout: to.Ptr("iljppmmw"),
		// 									Enable: to.Ptr(true),
		// 								},
		// 								OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
		// 									NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
		// 									Enable: to.Ptr(true),
		// 								},
		// 							},
		// 							UserData: to.Ptr("s"),
		// 							CapacityReservation: &armcomputefleet.CapacityReservationProfile{
		// 								CapacityReservationGroup: &armcomputefleet.SubResource{
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
		// 								},
		// 							},
		// 							ApplicationProfile: &armcomputefleet.ApplicationProfile{
		// 								GalleryApplications: []*armcomputefleet.VMGalleryApplication{
		// 									{
		// 										Tags: to.Ptr("eyrqjbib"),
		// 										Order: to.Ptr[int32](5),
		// 										PackageReferenceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
		// 										TreatFailureAsDeploymentFailure: to.Ptr(true),
		// 										EnableAutomaticUpgrade: to.Ptr(true),
		// 									},
		// 								},
		// 							},
		// 							HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
		// 								VMSizeProperties: &armcomputefleet.VMSizeProperties{
		// 									VCPUsAvailable: to.Ptr[int32](16),
		// 									VCPUsPerCore: to.Ptr[int32](23),
		// 								},
		// 							},
		// 							ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
		// 								ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
		// 							},
		// 							SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
		// 								ID: to.Ptr("mubredelfbshboaxrsxiajihahaa"),
		// 								ExcludeExtensions: []*string{
		// 									to.Ptr("{securityPostureVMExtensionName}"),
		// 								},
		// 								IsOverridable: to.Ptr(true),
		// 							},
		// 							TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 						},
		// 						ComputeAPIVersion: to.Ptr("2023-07-01"),
		// 						PlatformFaultDomainCount: to.Ptr[int32](1),
		// 					},
		// 					TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
		// 					UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
		// 				},
		// 				Zones: []*string{
		// 					to.Ptr("zone1"),
		// 					to.Ptr("zone2"),
		// 				},
		// 				Identity: &armcomputefleet.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("4d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 					TenantID: to.Ptr("5d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 					Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
		// 					UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
		// 						"key9851": &armcomputefleet.UserAssignedIdentity{
		// 							PrincipalID: to.Ptr("6d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 							ClientID: to.Ptr("7d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 						},
		// 					},
		// 				},
		// 				Plan: &armcomputefleet.Plan{
		// 					Name: to.Ptr("jwgrcrnrtfoxn"),
		// 					Publisher: to.Ptr("iozjbiqqckqm"),
		// 					Product: to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
		// 					PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
		// 					Version: to.Ptr("wa"),
		// 				},
		// 				Tags: map[string]*string{
		// 					"key3518": to.Ptr("luvrnuvsgdpbuofdskkcoqhfh"),
		// 				},
		// 				Location: to.Ptr("westus"),
		// 				ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
		// 				Name: to.Ptr("testFleet"),
		// 				Type: to.Ptr("Microsoft.AzureFleet/fleets"),
		// 				SystemData: &armcomputefleet.SystemData{
		// 					CreatedBy: to.Ptr("rowegentrpoajsv"),
		// 					CreatedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("edwuayhhaoepxzisfaqjhmrxjq"),
		// 					LastModifiedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

func (*FleetsClient) NewListBySubscriptionPager 

func (client *FleetsClient) NewListBySubscriptionPager(options *FleetsClientListBySubscriptionOptions) *runtime.Pager[FleetsClientListBySubscriptionResponse]

NewListBySubscriptionPager - List Fleet resources by subscription ID

Generated from API version 2024-11-01

  • options - FleetsClientListBySubscriptionOptions contains the optional parameters for the FleetsClient.NewListBySubscriptionPager method.
Example

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_ListBySubscription.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewFleetsClient().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 = armcomputefleet.FleetsClientListBySubscriptionResponse{
		// 	FleetListResult: armcomputefleet.FleetListResult{
		// 		Value: []*armcomputefleet.Fleet{
		// 			{
		// 				Properties: &armcomputefleet.FleetProperties{
		// 					ProvisioningState: to.Ptr(armcomputefleet.ProvisioningStateCreating),
		// 					SpotPriorityProfile: &armcomputefleet.SpotPriorityProfile{
		// 						Capacity: to.Ptr[int32](20),
		// 						MinCapacity: to.Ptr[int32](10),
		// 						MaxPricePerVM: to.Ptr[float32](0.00865),
		// 						EvictionPolicy: to.Ptr(armcomputefleet.EvictionPolicyDelete),
		// 						AllocationStrategy: to.Ptr(armcomputefleet.SpotAllocationStrategyPriceCapacityOptimized),
		// 						Maintain: to.Ptr(true),
		// 					},
		// 					RegularPriorityProfile: &armcomputefleet.RegularPriorityProfile{
		// 						Capacity: to.Ptr[int32](20),
		// 						MinCapacity: to.Ptr[int32](10),
		// 						AllocationStrategy: to.Ptr(armcomputefleet.RegularPriorityAllocationStrategyLowestPrice),
		// 					},
		// 					VMSizesProfile: []*armcomputefleet.VMSizeProfile{
		// 						{
		// 							Name: to.Ptr("Standard_d1_v2"),
		// 							Rank: to.Ptr[int32](19225),
		// 						},
		// 					},
		// 					ComputeProfile: &armcomputefleet.ComputeProfile{
		// 						BaseVirtualMachineProfile: &armcomputefleet.BaseVirtualMachineProfile{
		// 							OSProfile: &armcomputefleet.VirtualMachineScaleSetOSProfile{
		// 								ComputerNamePrefix: to.Ptr("o"),
		// 								AdminUsername: to.Ptr("nrgzqciiaaxjrqldbmjbqkyhntp"),
		// 								WindowsConfiguration: &armcomputefleet.WindowsConfiguration{
		// 									ProvisionVMAgent: to.Ptr(true),
		// 									EnableAutomaticUpdates: to.Ptr(true),
		// 									TimeZone: to.Ptr("hlyjiqcfksgrpjrct"),
		// 									AdditionalUnattendContent: []*armcomputefleet.AdditionalUnattendContent{
		// 										{
		// 											PassName: to.Ptr("OobeSystem"),
		// 											ComponentName: to.Ptr("Microsoft-Windows-Shell-Setup"),
		// 											SettingName: to.Ptr(armcomputefleet.SettingNamesAutoLogon),
		// 										},
		// 									},
		// 									PatchSettings: &armcomputefleet.PatchSettings{
		// 										PatchMode: to.Ptr(armcomputefleet.WindowsVMGuestPatchModeManual),
		// 										EnableHotpatching: to.Ptr(true),
		// 										AssessmentMode: to.Ptr(armcomputefleet.WindowsPatchAssessmentModeImageDefault),
		// 										AutomaticByPlatformSettings: &armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformSettings{
		// 											RebootSetting: to.Ptr(armcomputefleet.WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
		// 											BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
		// 										},
		// 									},
		// 									WinRM: &armcomputefleet.WinRMConfiguration{
		// 										Listeners: []*armcomputefleet.WinRMListener{
		// 											{
		// 												Protocol: to.Ptr(armcomputefleet.ProtocolTypesHTTP),
		// 												CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
		// 											},
		// 										},
		// 									},
		// 									EnableVMAgentPlatformUpdates: to.Ptr(true),
		// 								},
		// 								LinuxConfiguration: &armcomputefleet.LinuxConfiguration{
		// 									DisablePasswordAuthentication: to.Ptr(true),
		// 									SSH: &armcomputefleet.SSHConfiguration{
		// 										PublicKeys: []*armcomputefleet.SSHPublicKey{
		// 											{
		// 												Path: to.Ptr("kmqz"),
		// 												KeyData: to.Ptr("kivgsubusvpprwqaqpjcmhsv"),
		// 											},
		// 										},
		// 									},
		// 									ProvisionVMAgent: to.Ptr(true),
		// 									PatchSettings: &armcomputefleet.LinuxPatchSettings{
		// 										PatchMode: to.Ptr(armcomputefleet.LinuxVMGuestPatchModeImageDefault),
		// 										AssessmentMode: to.Ptr(armcomputefleet.LinuxPatchAssessmentModeImageDefault),
		// 										AutomaticByPlatformSettings: &armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformSettings{
		// 											RebootSetting: to.Ptr(armcomputefleet.LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown),
		// 											BypassPlatformSafetyChecksOnUserSchedule: to.Ptr(true),
		// 										},
		// 									},
		// 									EnableVMAgentPlatformUpdates: to.Ptr(true),
		// 								},
		// 								Secrets: []*armcomputefleet.VaultSecretGroup{
		// 									{
		// 										SourceVault: &armcomputefleet.SubResource{
		// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
		// 										},
		// 										VaultCertificates: []*armcomputefleet.VaultCertificate{
		// 											{
		// 												CertificateURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/myCertName"),
		// 												CertificateStore: to.Ptr("nlxrwavpzhueffxsshlun"),
		// 											},
		// 										},
		// 									},
		// 								},
		// 								AllowExtensionOperations: to.Ptr(true),
		// 								RequireGuestProvisionSignal: to.Ptr(true),
		// 							},
		// 							StorageProfile: &armcomputefleet.VirtualMachineScaleSetStorageProfile{
		// 								ImageReference: &armcomputefleet.ImageReference{
		// 									Publisher: to.Ptr("mqxgwbiyjzmxavhbkd"),
		// 									Offer: to.Ptr("isxgumkarlkomp"),
		// 									SKU: to.Ptr("eojmppqcrnpmxirtp"),
		// 									Version: to.Ptr("wvpcqefgtmqdgltiuz"),
		// 									ExactVersion: to.Ptr("zjbntmiskjexlr"),
		// 									SharedGalleryImageID: to.Ptr("kmkgihoxwlawuuhcinfirktdwkmx"),
		// 									CommunityGalleryImageID: to.Ptr("vlqe"),
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}/versions/{versionName}"),
		// 								},
		// 								OSDisk: &armcomputefleet.VirtualMachineScaleSetOSDisk{
		// 									Name: to.Ptr("wfttw"),
		// 									Caching: to.Ptr(armcomputefleet.CachingTypesNone),
		// 									WriteAcceleratorEnabled: to.Ptr(true),
		// 									CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
		// 									DiffDiskSettings: &armcomputefleet.DiffDiskSettings{
		// 										Option: to.Ptr(armcomputefleet.DiffDiskOptionsLocal),
		// 										Placement: to.Ptr(armcomputefleet.DiffDiskPlacementCacheDisk),
		// 									},
		// 									DiskSizeGB: to.Ptr[int32](14),
		// 									OSType: to.Ptr(armcomputefleet.OperatingSystemTypesWindows),
		// 									Image: &armcomputefleet.VirtualHardDisk{
		// 										URI: to.Ptr("https://myStorageAccountName.blob.core.windows.net/myContainerName/myVhdName.vhd"),
		// 									},
		// 									VhdContainers: []*string{
		// 										to.Ptr("tkzcwddtinkfpnfklatw"),
		// 									},
		// 									ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
		// 										StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
		// 										DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 											ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 										},
		// 										SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
		// 											SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
		// 											DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 											},
		// 										},
		// 									},
		// 									DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
		// 								},
		// 								DataDisks: []*armcomputefleet.VirtualMachineScaleSetDataDisk{
		// 									{
		// 										Name: to.Ptr("eogiykmdmeikswxmigjws"),
		// 										Lun: to.Ptr[int32](14),
		// 										Caching: to.Ptr(armcomputefleet.CachingTypesNone),
		// 										WriteAcceleratorEnabled: to.Ptr(true),
		// 										CreateOption: to.Ptr(armcomputefleet.DiskCreateOptionTypesFromImage),
		// 										DiskSizeGB: to.Ptr[int32](6),
		// 										ManagedDisk: &armcomputefleet.VirtualMachineScaleSetManagedDiskParameters{
		// 											StorageAccountType: to.Ptr(armcomputefleet.StorageAccountTypesStandardLRS),
		// 											DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 											},
		// 											SecurityProfile: &armcomputefleet.VMDiskSecurityProfile{
		// 												SecurityEncryptionType: to.Ptr(armcomputefleet.SecurityEncryptionTypesVMGuestStateOnly),
		// 												DiskEncryptionSet: &armcomputefleet.DiskEncryptionSetParameters{
		// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
		// 												},
		// 											},
		// 										},
		// 										DiskIOPSReadWrite: to.Ptr[int64](27),
		// 										DiskMBpsReadWrite: to.Ptr[int64](2),
		// 										DeleteOption: to.Ptr(armcomputefleet.DiskDeleteOptionTypesDelete),
		// 									},
		// 								},
		// 							},
		// 							NetworkProfile: &armcomputefleet.VirtualMachineScaleSetNetworkProfile{
		// 								HealthProbe: &armcomputefleet.APIEntityReference{
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}"),
		// 								},
		// 								NetworkInterfaceConfigurations: []*armcomputefleet.VirtualMachineScaleSetNetworkConfiguration{
		// 									{
		// 										Name: to.Ptr("i"),
		// 										Properties: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationProperties{
		// 											Primary: to.Ptr(true),
		// 											EnableAcceleratedNetworking: to.Ptr(true),
		// 											DisableTCPStateTracking: to.Ptr(true),
		// 											EnableFpga: to.Ptr(true),
		// 											NetworkSecurityGroup: &armcomputefleet.SubResource{
		// 												ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/networkSecurityGroups/{networkSecurityGroupName}"),
		// 											},
		// 											DNSSettings: &armcomputefleet.VirtualMachineScaleSetNetworkConfigurationDNSSettings{
		// 												DNSServers: []*string{
		// 													to.Ptr("nxmmfolhclsesu"),
		// 												},
		// 											},
		// 											IPConfigurations: []*armcomputefleet.VirtualMachineScaleSetIPConfiguration{
		// 												{
		// 													Name: to.Ptr("oezqhkidfhyywlfzwuotilrpbqnjg"),
		// 													Properties: &armcomputefleet.VirtualMachineScaleSetIPConfigurationProperties{
		// 														Subnet: &armcomputefleet.APIEntityReference{
		// 															ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}"),
		// 														},
		// 														Primary: to.Ptr(true),
		// 														PublicIPAddressConfiguration: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfiguration{
		// 															Name: to.Ptr("fvpqf"),
		// 															Properties: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationProperties{
		// 																IdleTimeoutInMinutes: to.Ptr[int32](9),
		// 																DNSSettings: &armcomputefleet.VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings{
		// 																	DomainNameLabel: to.Ptr("ukrddzvmorpmfsczjwtbvp"),
		// 																	DomainNameLabelScope: to.Ptr(armcomputefleet.DomainNameLabelScopeTypesTenantReuse),
		// 																},
		// 																IPTags: []*armcomputefleet.VirtualMachineScaleSetIPTag{
		// 																	{
		// 																		IPTagType: to.Ptr("sddgsoemnzgqizale"),
		// 																		Tag: to.Ptr("wufmhrjsakbiaetyara"),
		// 																	},
		// 																},
		// 																PublicIPPrefix: &armcomputefleet.SubResource{
		// 																	ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/publicIPPrefixes/{publicIPPrefixName}"),
		// 																},
		// 																PublicIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
		// 																DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
		// 															},
		// 															SKU: &armcomputefleet.PublicIPAddressSKU{
		// 																Name: to.Ptr(armcomputefleet.PublicIPAddressSKUNameBasic),
		// 																Tier: to.Ptr(armcomputefleet.PublicIPAddressSKUTierRegional),
		// 															},
		// 														},
		// 														PrivateIPAddressVersion: to.Ptr(armcomputefleet.IPVersionIPv4),
		// 														ApplicationGatewayBackendAddressPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationGateways/{applicationGatewayName}/backendAddressPools/{backendAddressPoolName}"),
		// 															},
		// 														},
		// 														ApplicationSecurityGroups: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/applicationSecurityGroups/{applicationSecurityGroupName}"),
		// 															},
		// 														},
		// 														LoadBalancerBackendAddressPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/backendAddressPools/{backendAddressPoolName}"),
		// 															},
		// 														},
		// 														LoadBalancerInboundNatPools: []*armcomputefleet.SubResource{
		// 															{
		// 																ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/inboundNatPools/{inboundNatPoolName}"),
		// 															},
		// 														},
		// 													},
		// 												},
		// 											},
		// 											EnableIPForwarding: to.Ptr(true),
		// 											DeleteOption: to.Ptr(armcomputefleet.DeleteOptionsDelete),
		// 											AuxiliaryMode: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliaryModeNone),
		// 											AuxiliarySKU: to.Ptr(armcomputefleet.NetworkInterfaceAuxiliarySKUNone),
		// 										},
		// 									},
		// 								},
		// 								NetworkAPIVersion: to.Ptr(armcomputefleet.NetworkAPIVersionV20201101),
		// 							},
		// 							SecurityProfile: &armcomputefleet.SecurityProfile{
		// 								UefiSettings: &armcomputefleet.UefiSettings{
		// 									SecureBootEnabled: to.Ptr(true),
		// 									VTpmEnabled: to.Ptr(true),
		// 								},
		// 								EncryptionAtHost: to.Ptr(true),
		// 								SecurityType: to.Ptr(armcomputefleet.SecurityTypesTrustedLaunch),
		// 								EncryptionIdentity: &armcomputefleet.EncryptionIdentity{
		// 									UserAssignedIdentityResourceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{userAssignedIdentityName}"),
		// 								},
		// 								ProxyAgentSettings: &armcomputefleet.ProxyAgentSettings{
		// 									Enabled: to.Ptr(true),
		// 									Mode: to.Ptr(armcomputefleet.ModeAudit),
		// 									KeyIncarnationID: to.Ptr[int32](20),
		// 								},
		// 							},
		// 							DiagnosticsProfile: &armcomputefleet.DiagnosticsProfile{
		// 								BootDiagnostics: &armcomputefleet.BootDiagnostics{
		// 									Enabled: to.Ptr(true),
		// 									StorageURI: to.Ptr("http://myStorageAccountName.blob.core.windows.net"),
		// 								},
		// 							},
		// 							ExtensionProfile: &armcomputefleet.VirtualMachineScaleSetExtensionProfile{
		// 								Extensions: []*armcomputefleet.VirtualMachineScaleSetExtension{
		// 									{
		// 										Name: to.Ptr("bndxuxx"),
		// 										Type: to.Ptr("cmeam"),
		// 										Properties: &armcomputefleet.VirtualMachineScaleSetExtensionProperties{
		// 											ForceUpdateTag: to.Ptr("yhgxw"),
		// 											Publisher: to.Ptr("kpxtirxjfprhs"),
		// 											Type: to.Ptr("pgjilctjjwaa"),
		// 											TypeHandlerVersion: to.Ptr("zevivcoilxmbwlrihhhibq"),
		// 											AutoUpgradeMinorVersion: to.Ptr(true),
		// 											EnableAutomaticUpgrade: to.Ptr(true),
		// 											Settings: map[string]any{
		// 											},
		// 											ProvisioningState: to.Ptr("Succeeded"),
		// 											ProvisionAfterExtensions: []*string{
		// 												to.Ptr("nftzosroolbcwmpupujzqwqe"),
		// 											},
		// 											SuppressFailures: to.Ptr(true),
		// 											ProtectedSettingsFromKeyVault: &armcomputefleet.KeyVaultSecretReference{
		// 												SecretURL: to.Ptr("https://myVaultName.vault.azure.net/secrets/secret/mySecretName"),
		// 												SourceVault: &armcomputefleet.SubResource{
		// 													ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.KeyVault/vaults/{vaultName}"),
		// 												},
		// 											},
		// 										},
		// 										ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/virtualMachines/{vmName}/extensions/{extensionName}"),
		// 									},
		// 								},
		// 								ExtensionsTimeBudget: to.Ptr("mbhjahtdygwgyszdwjtvlvtgchdwil"),
		// 							},
		// 							LicenseType: to.Ptr("v"),
		// 							ScheduledEventsProfile: &armcomputefleet.ScheduledEventsProfile{
		// 								TerminateNotificationProfile: &armcomputefleet.TerminateNotificationProfile{
		// 									NotBeforeTimeout: to.Ptr("iljppmmw"),
		// 									Enable: to.Ptr(true),
		// 								},
		// 								OSImageNotificationProfile: &armcomputefleet.OSImageNotificationProfile{
		// 									NotBeforeTimeout: to.Ptr("olbpadmevekyczfokodtfprxti"),
		// 									Enable: to.Ptr(true),
		// 								},
		// 							},
		// 							UserData: to.Ptr("s"),
		// 							CapacityReservation: &armcomputefleet.CapacityReservationProfile{
		// 								CapacityReservationGroup: &armcomputefleet.SubResource{
		// 									ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/capacityReservationGroups/{capacityReservationGroupName}"),
		// 								},
		// 							},
		// 							ApplicationProfile: &armcomputefleet.ApplicationProfile{
		// 								GalleryApplications: []*armcomputefleet.VMGalleryApplication{
		// 									{
		// 										Tags: to.Ptr("eyrqjbib"),
		// 										Order: to.Ptr[int32](5),
		// 										PackageReferenceID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{applicationName}/versions/{versionName}"),
		// 										TreatFailureAsDeploymentFailure: to.Ptr(true),
		// 										EnableAutomaticUpgrade: to.Ptr(true),
		// 									},
		// 								},
		// 							},
		// 							HardwareProfile: &armcomputefleet.VirtualMachineScaleSetHardwareProfile{
		// 								VMSizeProperties: &armcomputefleet.VMSizeProperties{
		// 									VCPUsAvailable: to.Ptr[int32](16),
		// 									VCPUsPerCore: to.Ptr[int32](23),
		// 								},
		// 							},
		// 							ServiceArtifactReference: &armcomputefleet.ServiceArtifactReference{
		// 								ID: to.Ptr("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactsName}/vmArtifactsProfiles/{vmArtifactsProfileName}"),
		// 							},
		// 							SecurityPostureReference: &armcomputefleet.SecurityPostureReference{
		// 								ID: to.Ptr("mubredelfbshboaxrsxiajihahaa"),
		// 								ExcludeExtensions: []*string{
		// 									to.Ptr("{securityPostureVMExtensionName}"),
		// 								},
		// 								IsOverridable: to.Ptr(true),
		// 							},
		// 							TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 						},
		// 						ComputeAPIVersion: to.Ptr("2023-07-01"),
		// 						PlatformFaultDomainCount: to.Ptr[int32](1),
		// 					},
		// 					TimeCreated: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-07-10T00:16:34.8590555+00:00"); return t}()),
		// 					UniqueID: to.Ptr("a2f7fabd-bbc2-4a20-afe1-49fdb3885a28"),
		// 				},
		// 				Zones: []*string{
		// 					to.Ptr("zone1"),
		// 					to.Ptr("zone2"),
		// 				},
		// 				Identity: &armcomputefleet.ManagedServiceIdentity{
		// 					PrincipalID: to.Ptr("4d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 					TenantID: to.Ptr("5d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 					Type: to.Ptr(armcomputefleet.ManagedServiceIdentityTypeUserAssigned),
		// 					UserAssignedIdentities: map[string]*armcomputefleet.UserAssignedIdentity{
		// 						"key9851": &armcomputefleet.UserAssignedIdentity{
		// 							PrincipalID: to.Ptr("6d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 							ClientID: to.Ptr("7d508e5b-374b-4382-9a1c-01fb8b6cb37c"),
		// 						},
		// 					},
		// 				},
		// 				Plan: &armcomputefleet.Plan{
		// 					Name: to.Ptr("jwgrcrnrtfoxn"),
		// 					Publisher: to.Ptr("iozjbiqqckqm"),
		// 					Product: to.Ptr("cgopbyvdyqikahwyxfpzwaqk"),
		// 					PromotionCode: to.Ptr("naglezezplcaruqogtxnuizslqnnbr"),
		// 					Version: to.Ptr("wa"),
		// 				},
		// 				Tags: map[string]*string{
		// 					"key3518": to.Ptr("luvrnuvsgdpbuofdskkcoqhfh"),
		// 				},
		// 				Location: to.Ptr("westus"),
		// 				ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/testFleet"),
		// 				Name: to.Ptr("testFleet"),
		// 				Type: to.Ptr("Microsoft.AzureFleet/fleets"),
		// 				SystemData: &armcomputefleet.SystemData{
		// 					CreatedBy: to.Ptr("rowegentrpoajsv"),
		// 					CreatedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
		// 					CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 					LastModifiedBy: to.Ptr("edwuayhhaoepxzisfaqjhmrxjq"),
		// 					LastModifiedByType: to.Ptr(armcomputefleet.CreatedByTypeUser),
		// 					LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2024-04-29T21:51:44.043Z"); return t}()),
		// 				},
		// 			},
		// 		},
		// 		NextLink: to.Ptr("https://microsoft.com/a"),
		// 	},
		// }
	}
}

Output:

func (*FleetsClient) NewListVirtualMachineScaleSetsPager 

func (client *FleetsClient) NewListVirtualMachineScaleSetsPager(resourceGroupName string, name string, options *FleetsClientListVirtualMachineScaleSetsOptions) *runtime.Pager[FleetsClientListVirtualMachineScaleSetsResponse]

NewListVirtualMachineScaleSetsPager - List VirtualMachineScaleSet resources by Fleet

Generated from API version 2024-11-01

  • resourceGroupName - The name of the resource group. The name is case insensitive.
  • name - The name of the Fleet
  • options - FleetsClientListVirtualMachineScaleSetsOptions contains the optional parameters for the FleetsClient.NewListVirtualMachineScaleSetsPager method.
Example

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Fleets_ListVirtualMachineScaleSets.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("1DC2F28C-A625-4B0E-9748-9885A3C9E9EB", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewFleetsClient().NewListVirtualMachineScaleSetsPager("rgazurefleet", "myFleet", 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 = armcomputefleet.FleetsClientListVirtualMachineScaleSetsResponse{
		// 	VirtualMachineScaleSetListResult: armcomputefleet.VirtualMachineScaleSetListResult{
		// 		Value: []*armcomputefleet.VirtualMachineScaleSet{
		// 			{
		// 				Name: to.Ptr("myVmss"),
		// 				ID: to.Ptr("/subscriptions/7B0CD4DB-3381-4013-9B31-FB6E6FD0FF1C/resourceGroups/rgazurefleet/providers/Microsoft.AzureFleet/fleets/myFleet/virtualMachineScaleSets/myVmss"),
		// 				Type: to.Ptr("Microsoft.AzureFleet/fleets/virtualMachineScaleSets"),
		// 				OperationStatus: to.Ptr(armcomputefleet.ProvisioningStateCreating),
		// 				Error: &armcomputefleet.APIError{
		// 					Details: []*armcomputefleet.APIErrorBase{
		// 						{
		// 							Code: to.Ptr("gzhtOverconstrainedAllocationRequestyosk"),
		// 							Target: to.Ptr("qfthabhrmndhfizfnrwpgxvnokpy"),
		// 							Message: to.Ptr("Allocation Failed"),
		// 						},
		// 					},
		// 					Innererror: &armcomputefleet.InnerError{
		// 						ExceptionType: to.Ptr("sfaomfpoaptnbxchrfskm"),
		// 						ErrorDetail: to.Ptr("ihjwbwykq"),
		// 					},
		// 					Code: to.Ptr("OverconstrainedAllocationRequest"),
		// 					Target: to.Ptr("nhaj"),
		// 					Message: to.Ptr("Allocation Failed"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

Output:

type FleetsClientBeginCreateOrUpdateOptions 

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

FleetsClientBeginCreateOrUpdateOptions contains the optional parameters for the FleetsClient.BeginCreateOrUpdate method.

type FleetsClientBeginDeleteOptions 

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

FleetsClientBeginDeleteOptions contains the optional parameters for the FleetsClient.BeginDelete method.

type FleetsClientBeginUpdateOptions 

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

FleetsClientBeginUpdateOptions contains the optional parameters for the FleetsClient.BeginUpdate method.

type FleetsClientCreateOrUpdateResponse 

type FleetsClientCreateOrUpdateResponse struct {
	// An Compute Fleet resource
	Fleet
}

FleetsClientCreateOrUpdateResponse contains the response from method FleetsClient.BeginCreateOrUpdate.

type FleetsClientDeleteResponse 

type FleetsClientDeleteResponse struct {
}

FleetsClientDeleteResponse contains the response from method FleetsClient.BeginDelete.

type FleetsClientGetOptions 

type FleetsClientGetOptions struct {
}

FleetsClientGetOptions contains the optional parameters for the FleetsClient.Get method.

type FleetsClientGetResponse 

type FleetsClientGetResponse struct {
	// An Compute Fleet resource
	Fleet
}

FleetsClientGetResponse contains the response from method FleetsClient.Get.

type FleetsClientListByResourceGroupOptions 

type FleetsClientListByResourceGroupOptions struct {
}

FleetsClientListByResourceGroupOptions contains the optional parameters for the FleetsClient.NewListByResourceGroupPager method.

type FleetsClientListByResourceGroupResponse 

type FleetsClientListByResourceGroupResponse struct {
	// The response of a Fleet list operation.
	FleetListResult
}

FleetsClientListByResourceGroupResponse contains the response from method FleetsClient.NewListByResourceGroupPager.

type FleetsClientListBySubscriptionOptions 

type FleetsClientListBySubscriptionOptions struct {
}

FleetsClientListBySubscriptionOptions contains the optional parameters for the FleetsClient.NewListBySubscriptionPager method.

type FleetsClientListBySubscriptionResponse 

type FleetsClientListBySubscriptionResponse struct {
	// The response of a Fleet list operation.
	FleetListResult
}

FleetsClientListBySubscriptionResponse contains the response from method FleetsClient.NewListBySubscriptionPager.

type FleetsClientListVirtualMachineScaleSetsOptions 

type FleetsClientListVirtualMachineScaleSetsOptions struct {
}

FleetsClientListVirtualMachineScaleSetsOptions contains the optional parameters for the FleetsClient.NewListVirtualMachineScaleSetsPager method.

type FleetsClientListVirtualMachineScaleSetsResponse 

type FleetsClientListVirtualMachineScaleSetsResponse struct {
	// The response of a VirtualMachineScaleSet list operation.
	VirtualMachineScaleSetListResult
}

FleetsClientListVirtualMachineScaleSetsResponse contains the response from method FleetsClient.NewListVirtualMachineScaleSetsPager.

type FleetsClientUpdateResponse 

type FleetsClientUpdateResponse struct {
	// An Compute Fleet resource
	Fleet
}

FleetsClientUpdateResponse contains the response from method FleetsClient.BeginUpdate.

type IPVersion 

type IPVersion string

IPVersion - Available from Api-Version 2017-03-30 onwards, it represents whether the specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible values are: 'IPv4' and 'IPv6'. 

const (
	// IPVersionIPv4 - IPv4 version
	IPVersionIPv4 IPVersion = "IPv4"
	// IPVersionIPv6 - IPv6 version
	IPVersionIPv6 IPVersion = "IPv6"
)

func PossibleIPVersionValues 

func PossibleIPVersionValues() []IPVersion

PossibleIPVersionValues returns the possible values for the IPVersion const type.

type ImageReference 

type ImageReference struct {
	// Specified the community gallery image unique id for vm deployment. This can be
	// fetched from community gallery image GET call.
	CommunityGalleryImageID *string

	// Resource Id
	ID *string

	// Specifies the offer of the platform image or marketplace image used to create
	// the virtual machine.
	Offer *string

	// The image publisher.
	Publisher *string

	// The image SKU.
	SKU *string

	// Specified the shared gallery image unique id for vm deployment. This can be
	// fetched from shared gallery image GET call.
	SharedGalleryImageID *string

	// Specifies the version of the platform image or marketplace image used to create
	// the virtual machine. The allowed formats are Major.Minor.Build or 'latest'.
	// Major, Minor, and Build are decimal numbers. Specify 'latest' to use the latest
	// version of an image available at deploy time. Even if you use 'latest', the VM
	// image will not automatically update after deploy time even if a new version
	// becomes available. Please do not use field 'version' for gallery image
	// deployment, gallery image should always use 'id' field for deployment, to use 'latest'
	// version of gallery image, just set
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/images/{imageName}'
	// in the 'id' field without version input.
	Version *string

	// READ-ONLY; Specifies in decimal numbers, the version of platform image or marketplace
	// image used to create the virtual machine. This readonly field differs from 'version',
	// only if the value specified in 'version' field is 'latest'.
	ExactVersion *string
}

ImageReference - Specifies information about the image to use. You can specify information about platform images, marketplace images, or virtual machine images. This element is required when you want to use a platform image, marketplace image, or virtual machine image, but is not used in other creation operations. NOTE: Image reference publisher and offer can only be set when you create the scale set.

func (ImageReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ImageReference.

func (*ImageReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ImageReference.

type InnerError 

type InnerError struct {
	// The internal error message or exception dump.
	ErrorDetail *string

	// The exception type.
	ExceptionType *string
}

InnerError - Inner error details.

func (InnerError) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type InnerError.

func (*InnerError) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type InnerError.

type KeyVaultSecretReference 

type KeyVaultSecretReference struct {
	// REQUIRED; The URL referencing a secret in a Key Vault.
	SecretURL *string

	// REQUIRED; The relative URL of the Key Vault containing the secret.
	SourceVault *SubResource
}

KeyVaultSecretReference - Describes a reference to Key Vault Secret

func (KeyVaultSecretReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type KeyVaultSecretReference.

func (*KeyVaultSecretReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type KeyVaultSecretReference.

type LinuxConfiguration 

type LinuxConfiguration struct {
	// Specifies whether password authentication should be disabled.
	DisablePasswordAuthentication *bool

	// Indicates whether VMAgent Platform Updates is enabled for the Linux virtual
	// machine. Default value is false.
	EnableVMAgentPlatformUpdates *bool

	// [Preview Feature] Specifies settings related to VM Guest Patching on Linux.
	PatchSettings *LinuxPatchSettings

	// Indicates whether virtual machine agent should be provisioned on the virtual
	// machine. When this property is not specified in the request body, default
	// behavior is to set it to true. This will ensure that VM Agent is installed on
	// the VM so that extensions can be added to the VM later.
	ProvisionVMAgent *bool

	// Specifies the ssh key configuration for a Linux OS.
	SSH *SSHConfiguration
}

LinuxConfiguration - Specifies the Linux operating system settings on the virtual machine. For a list of supported Linux distributions, see [Linux on Azure-Endorsed Distributions](https://docs.microsoft.com/azure/virtual-machines/linux/endorsed-distros).

func (LinuxConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LinuxConfiguration.

func (*LinuxConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LinuxConfiguration.

type LinuxPatchAssessmentMode 

type LinuxPatchAssessmentMode string

LinuxPatchAssessmentMode - Specifies the mode of VM Guest Patch Assessment for the IaaS virtual machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - You control the timing of patch assessments on a virtual machine. <br /><br /> **AutomaticByPlatform** - The platform will trigger periodic patch assessments. The property provisionVMAgent must be true. 

const (
	// LinuxPatchAssessmentModeAutomaticByPlatform - The platform will trigger periodic patch assessments.The property provisionVMAgent
	// must be true.
	LinuxPatchAssessmentModeAutomaticByPlatform LinuxPatchAssessmentMode = "AutomaticByPlatform"
	// LinuxPatchAssessmentModeImageDefault - You control the timing of patch assessments on a virtual machine.
	LinuxPatchAssessmentModeImageDefault LinuxPatchAssessmentMode = "ImageDefault"
)

func PossibleLinuxPatchAssessmentModeValues 

func PossibleLinuxPatchAssessmentModeValues() []LinuxPatchAssessmentMode

PossibleLinuxPatchAssessmentModeValues returns the possible values for the LinuxPatchAssessmentMode const type.

type LinuxPatchSettings 

type LinuxPatchSettings struct {
	// Specifies the mode of VM Guest Patch Assessment for the IaaS virtual
	// machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - You
	// control the timing of patch assessments on a virtual machine. <br /><br />
	// **AutomaticByPlatform** - The platform will trigger periodic patch assessments.
	// The property provisionVMAgent must be true.
	AssessmentMode *LinuxPatchAssessmentMode

	// Specifies additional settings for patch mode AutomaticByPlatform in VM Guest
	// Patching on Linux.
	AutomaticByPlatformSettings *LinuxVMGuestPatchAutomaticByPlatformSettings

	// Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual
	// machines associated to virtual machine scale set with OrchestrationMode as
	// Flexible.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - The
	// virtual machine's default patching configuration is used. <br /><br />
	// **AutomaticByPlatform** - The virtual machine will be automatically updated by
	// the platform. The property provisionVMAgent must be true
	PatchMode *LinuxVMGuestPatchMode
}

LinuxPatchSettings - Specifies settings related to VM Guest Patching on Linux.

func (LinuxPatchSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LinuxPatchSettings.

func (*LinuxPatchSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LinuxPatchSettings.

type LinuxVMGuestPatchAutomaticByPlatformRebootSetting 

type LinuxVMGuestPatchAutomaticByPlatformRebootSetting string

LinuxVMGuestPatchAutomaticByPlatformRebootSetting - Specifies the reboot setting for all AutomaticByPlatform patch installation operations. 

const (
	// LinuxVMGuestPatchAutomaticByPlatformRebootSettingAlways - Always Reboot setting
	LinuxVMGuestPatchAutomaticByPlatformRebootSettingAlways LinuxVMGuestPatchAutomaticByPlatformRebootSetting = "Always"
	// LinuxVMGuestPatchAutomaticByPlatformRebootSettingIfRequired - IfRequired Reboot setting
	LinuxVMGuestPatchAutomaticByPlatformRebootSettingIfRequired LinuxVMGuestPatchAutomaticByPlatformRebootSetting = "IfRequired"
	// LinuxVMGuestPatchAutomaticByPlatformRebootSettingNever - Never Reboot setting
	LinuxVMGuestPatchAutomaticByPlatformRebootSettingNever LinuxVMGuestPatchAutomaticByPlatformRebootSetting = "Never"
	// LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown - Unknown Reboot setting
	LinuxVMGuestPatchAutomaticByPlatformRebootSettingUnknown LinuxVMGuestPatchAutomaticByPlatformRebootSetting = "Unknown"
)

func PossibleLinuxVMGuestPatchAutomaticByPlatformRebootSettingValues 

func PossibleLinuxVMGuestPatchAutomaticByPlatformRebootSettingValues() []LinuxVMGuestPatchAutomaticByPlatformRebootSetting

PossibleLinuxVMGuestPatchAutomaticByPlatformRebootSettingValues returns the possible values for the LinuxVMGuestPatchAutomaticByPlatformRebootSetting const type.

type LinuxVMGuestPatchAutomaticByPlatformSettings 

type LinuxVMGuestPatchAutomaticByPlatformSettings struct {
	// Enables customer to schedule patching without accidental upgrades
	BypassPlatformSafetyChecksOnUserSchedule *bool

	// Specifies the reboot setting for all AutomaticByPlatform patch installation
	// operations.
	RebootSetting *LinuxVMGuestPatchAutomaticByPlatformRebootSetting
}

LinuxVMGuestPatchAutomaticByPlatformSettings - Specifies additional settings to be applied when patch mode AutomaticByPlatform is selected in Linux patch settings.

func (LinuxVMGuestPatchAutomaticByPlatformSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LinuxVMGuestPatchAutomaticByPlatformSettings.

func (*LinuxVMGuestPatchAutomaticByPlatformSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LinuxVMGuestPatchAutomaticByPlatformSettings.

type LinuxVMGuestPatchMode 

type LinuxVMGuestPatchMode string

LinuxVMGuestPatchMode - Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual machines associated to virtual machine scale set with OrchestrationMode as Flexible. 

const (
	// LinuxVMGuestPatchModeAutomaticByPlatform - The virtual machine will be automatically updated by the platform. The property
	// provisionVMAgent must be true.
	LinuxVMGuestPatchModeAutomaticByPlatform LinuxVMGuestPatchMode = "AutomaticByPlatform"
	// LinuxVMGuestPatchModeImageDefault - The virtual machine's default patching configuration is used.
	LinuxVMGuestPatchModeImageDefault LinuxVMGuestPatchMode = "ImageDefault"
)

func PossibleLinuxVMGuestPatchModeValues 

func PossibleLinuxVMGuestPatchModeValues() []LinuxVMGuestPatchMode

PossibleLinuxVMGuestPatchModeValues returns the possible values for the LinuxVMGuestPatchMode const type.

type LocalStorageDiskType added in v1.0.0 

type LocalStorageDiskType string

LocalStorageDiskType - Different kind of Local storage disk types supported by Azure VMs. 

const (
	// LocalStorageDiskTypeHDD - HDD DiskType.
	LocalStorageDiskTypeHDD LocalStorageDiskType = "HDD"
	// LocalStorageDiskTypeSSD - SDD DiskType.
	LocalStorageDiskTypeSSD LocalStorageDiskType = "SSD"
)

func PossibleLocalStorageDiskTypeValues added in v1.0.0 

func PossibleLocalStorageDiskTypeValues() []LocalStorageDiskType

PossibleLocalStorageDiskTypeValues returns the possible values for the LocalStorageDiskType const type.

type LocationProfile added in v1.0.0 

type LocationProfile struct {
	// REQUIRED; The ARM location name of the additional region. If LocationProfile is specified, then location is required.
	Location *string

	// An override for computeProfile.baseVirtualMachineProfile specific to this region.
	// This override is merged with the base virtual machine profile to define the final virtual machine profile for the resources
	// deployed in this location.
	VirtualMachineProfileOverride *BaseVirtualMachineProfile
}

LocationProfile - Represents the profile for a single additional location in the Fleet. The location and the virtualMachineProfileOverride (optional).

func (LocationProfile) MarshalJSON added in v1.0.0 

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

MarshalJSON implements the json.Marshaller interface for type LocationProfile.

func (*LocationProfile) UnmarshalJSON added in v1.0.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type LocationProfile.

type ManagedServiceIdentity 

type ManagedServiceIdentity struct {
	// REQUIRED; The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType 

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed). 

const (
	// ManagedServiceIdentityTypeNone - No managed identity.
	ManagedServiceIdentityTypeNone ManagedServiceIdentityType = "None"
	// ManagedServiceIdentityTypeSystemAndUserAssigned - System and user assigned managed identity.
	ManagedServiceIdentityTypeSystemAndUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	// ManagedServiceIdentityTypeSystemAssigned - System assigned managed identity.
	ManagedServiceIdentityTypeSystemAssigned ManagedServiceIdentityType = "SystemAssigned"
	// ManagedServiceIdentityTypeUserAssigned - User assigned managed identity.
	ManagedServiceIdentityTypeUserAssigned ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type ManagedServiceIdentityUpdate 

type ManagedServiceIdentityUpdate struct {
	// The type of managed identity assigned to this resource.
	Type *ManagedServiceIdentityType

	// The identities assigned to this resource by the user.
	UserAssignedIdentities map[string]*UserAssignedIdentity
}

ManagedServiceIdentityUpdate - The template for adding optional properties.

func (ManagedServiceIdentityUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentityUpdate.

func (*ManagedServiceIdentityUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentityUpdate.

type Mode 

type Mode string

Mode - Specifies the mode that ProxyAgent will execute on if the feature is enabled. ProxyAgent will start to audit or monitor but not enforce access control over requests to host endpoints in Audit mode, while in Enforce mode it will enforce access control. The default value is Enforce mode. 

const (
	// ModeAudit - Audit Mode
	ModeAudit Mode = "Audit"
	// ModeEnforce - Enforce Mode
	ModeEnforce Mode = "Enforce"
)

func PossibleModeValues 

func PossibleModeValues() []Mode

PossibleModeValues returns the possible values for the Mode const type.

type NetworkAPIVersion 

type NetworkAPIVersion string

NetworkAPIVersion - specifies the Microsoft.Network API version used when creating networking resources in the Network Interface Configurations for Virtual Machine Scale Set with orchestration mode 'Flexible' 

const (
	// NetworkAPIVersionV20201101 - Initial version supported. Later versions are supported as well.
	NetworkAPIVersionV20201101 NetworkAPIVersion = "2020-11-01"
)

func PossibleNetworkAPIVersionValues 

func PossibleNetworkAPIVersionValues() []NetworkAPIVersion

PossibleNetworkAPIVersionValues returns the possible values for the NetworkAPIVersion const type.

type NetworkInterfaceAuxiliaryMode 

type NetworkInterfaceAuxiliaryMode string

NetworkInterfaceAuxiliaryMode - Specifies whether the Auxiliary mode is enabled for the Network Interface resource. 

const (
	// NetworkInterfaceAuxiliaryModeAcceleratedConnections - AcceleratedConnections Mode
	NetworkInterfaceAuxiliaryModeAcceleratedConnections NetworkInterfaceAuxiliaryMode = "AcceleratedConnections"
	// NetworkInterfaceAuxiliaryModeFloating - Floating Mode
	NetworkInterfaceAuxiliaryModeFloating NetworkInterfaceAuxiliaryMode = "Floating"
	// NetworkInterfaceAuxiliaryModeNone - None Mode
	NetworkInterfaceAuxiliaryModeNone NetworkInterfaceAuxiliaryMode = "None"
)

func PossibleNetworkInterfaceAuxiliaryModeValues 

func PossibleNetworkInterfaceAuxiliaryModeValues() []NetworkInterfaceAuxiliaryMode

PossibleNetworkInterfaceAuxiliaryModeValues returns the possible values for the NetworkInterfaceAuxiliaryMode const type.

type NetworkInterfaceAuxiliarySKU 

type NetworkInterfaceAuxiliarySKU string

NetworkInterfaceAuxiliarySKU - Specifies whether the Auxiliary sku is enabled for the Network Interface resource. 

const (
	// NetworkInterfaceAuxiliarySKUA1 - A1 sku
	NetworkInterfaceAuxiliarySKUA1 NetworkInterfaceAuxiliarySKU = "A1"
	// NetworkInterfaceAuxiliarySKUA2 - A2 sku
	NetworkInterfaceAuxiliarySKUA2 NetworkInterfaceAuxiliarySKU = "A2"
	// NetworkInterfaceAuxiliarySKUA4 - A4 sku
	NetworkInterfaceAuxiliarySKUA4 NetworkInterfaceAuxiliarySKU = "A4"
	// NetworkInterfaceAuxiliarySKUA8 - A8 sku
	NetworkInterfaceAuxiliarySKUA8 NetworkInterfaceAuxiliarySKU = "A8"
	// NetworkInterfaceAuxiliarySKUNone - no sku
	NetworkInterfaceAuxiliarySKUNone NetworkInterfaceAuxiliarySKU = "None"
)

func PossibleNetworkInterfaceAuxiliarySKUValues 

func PossibleNetworkInterfaceAuxiliarySKUValues() []NetworkInterfaceAuxiliarySKU

PossibleNetworkInterfaceAuxiliarySKUValues returns the possible values for the NetworkInterfaceAuxiliarySKU const type.

type OSImageNotificationProfile 

type OSImageNotificationProfile struct {
	// Specifies whether the OS Image Scheduled event is enabled or disabled.
	Enable *bool

	// Length of time a Virtual Machine being reimaged or having its OS upgraded will
	// have to potentially approve the OS Image Scheduled Event before the event is
	// auto approved (timed out). The configuration is specified in ISO 8601 format,
	// and the value must not exceed 15 minutes (PT15M)
	NotBeforeTimeout *string
}

OSImageNotificationProfile - Specifies OS Image Scheduled Event related configurations.

func (OSImageNotificationProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OSImageNotificationProfile.

func (*OSImageNotificationProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OSImageNotificationProfile.

type OperatingSystemTypes 

type OperatingSystemTypes string

OperatingSystemTypes - This property allows you to specify the type of the OS that is included in the disk if creating a VM from user-image or a specialized VHD. Possible values are: **Windows,** **Linux.** 

const (
	// OperatingSystemTypesLinux - Linux OS type
	OperatingSystemTypesLinux OperatingSystemTypes = "Linux"
	// OperatingSystemTypesWindows - Windows OS type
	OperatingSystemTypesWindows OperatingSystemTypes = "Windows"
)

func PossibleOperatingSystemTypesValues 

func PossibleOperatingSystemTypesValues() []OperatingSystemTypes

PossibleOperatingSystemTypesValues returns the possible values for the OperatingSystemTypes const type.

type Operation 

type Operation struct {
	// Extensible enum. Indicates the action type. "Internal" refers to actions that are for internal only APIs.
	ActionType *ActionType

	// READ-ONLY; Localized display information for this particular operation.
	Display *OperationDisplay

	// READ-ONLY; Whether the operation applies to data-plane. This is "true" for data-plane operations and "false" for Azure
	// Resource Manager/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 and 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 {
	// REQUIRED; The Operation items on this page
	Value []*Operation

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

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 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 2024-11-01

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

Generated from example definition: D:/w/Azure/azure-sdk-for-go/sdk/resourcemanager/computefleet/armcomputefleet/TempTypeSpecFiles/AzureFleet.Management/examples/2024-11-01/Operations_List.json 

package main

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcomputefleet.NewClientFactory("<subscriptionID>", 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 = armcomputefleet.OperationsClientListResponse{
		// 	OperationListResult: armcomputefleet.OperationListResult{
		// 		Value: []*armcomputefleet.Operation{
		// 			{
		// 				Origin: to.Ptr(armcomputefleet.OriginUserSystem),
		// 				Name: to.Ptr("Microsoft.AzureFleet/fleets/read"),
		// 				IsDataAction: to.Ptr(false),
		// 				Display: &armcomputefleet.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft Azure Fleet"),
		// 					Resource: to.Ptr("Fleets"),
		// 					Operation: to.Ptr("Get Azure Fleet"),
		// 					Description: to.Ptr("Get properties of Azure Fleet resource"),
		// 				},
		// 			},
		// 			{
		// 				Origin: to.Ptr(armcomputefleet.OriginUserSystem),
		// 				Name: to.Ptr("Microsoft.AzureFleet/fleets/write"),
		// 				IsDataAction: to.Ptr(false),
		// 				Display: &armcomputefleet.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft Azure Fleet"),
		// 					Resource: to.Ptr("Fleets"),
		// 					Operation: to.Ptr("Create or Update Azure Fleet"),
		// 					Description: to.Ptr("Creates a new Azure Fleet resource or updates an existing one"),
		// 				},
		// 			},
		// 			{
		// 				Origin: to.Ptr(armcomputefleet.OriginUserSystem),
		// 				Name: to.Ptr("Microsoft.AzureFleet/fleets/delete"),
		// 				IsDataAction: to.Ptr(false),
		// 				Display: &armcomputefleet.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft Azure Fleet"),
		// 					Resource: to.Ptr("Fleets"),
		// 					Operation: to.Ptr("Delete Virtual Machine and Virtual Machine scale sets in a Azure Fleet resource"),
		// 					Description: to.Ptr("Deletes all compute resources of Azure Fleet resource"),
		// 				},
		// 			},
		// 			{
		// 				Origin: to.Ptr(armcomputefleet.OriginUserSystem),
		// 				Name: to.Ptr("Microsoft.AzureFleet/register/action"),
		// 				IsDataAction: to.Ptr(false),
		// 				Display: &armcomputefleet.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft Azure Fleet"),
		// 					Resource: to.Ptr("Subscription"),
		// 					Operation: to.Ptr("Register subscription for Microsoft.AzureFleet"),
		// 					Description: to.Ptr("Registers Subscription with Microsoft.AzureFleet resource provider"),
		// 				},
		// 			},
		// 			{
		// 				Origin: to.Ptr(armcomputefleet.OriginUserSystem),
		// 				Name: to.Ptr("Microsoft.AzureFleet/unregister/action"),
		// 				IsDataAction: to.Ptr(false),
		// 				Display: &armcomputefleet.OperationDisplay{
		// 					Provider: to.Ptr("Microsoft Azure Fleet"),
		// 					Resource: to.Ptr("Subscription"),
		// 					Operation: to.Ptr("Unregister Subscription for Microsoft.AzureFleet"),
		// 					Description: to.Ptr("Unregisters Subscription with Microsoft.AzureFleet resource provider"),
		// 				},
		// 			},
		// 		},
		// 	},
		// }
	}
}

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 - Indicates the operation is initiated by a system.
	OriginSystem Origin = "system"
	// OriginUser - Indicates the operation is initiated by a user.
	OriginUser Origin = "user"
	// OriginUserSystem - Indicates the operation is initiated by a user or system.
	OriginUserSystem Origin = "user,system"
)

func PossibleOriginValues 

func PossibleOriginValues() []Origin

PossibleOriginValues returns the possible values for the Origin const type.

type PatchSettings 

type PatchSettings struct {
	// Specifies the mode of VM Guest patch assessment for the IaaS virtual
	// machine.<br /><br /> Possible values are:<br /><br /> **ImageDefault** - You
	// control the timing of patch assessments on a virtual machine.<br /><br />
	// **AutomaticByPlatform** - The platform will trigger periodic patch assessments.
	// The property provisionVMAgent must be true.
	AssessmentMode *WindowsPatchAssessmentMode

	// Specifies additional settings for patch mode AutomaticByPlatform in VM Guest
	// Patching on Windows.
	AutomaticByPlatformSettings *WindowsVMGuestPatchAutomaticByPlatformSettings

	// Enables customers to patch their Azure VMs without requiring a reboot. For
	// enableHotpatching, the 'provisionVMAgent' must be set to true and 'patchMode'
	// must be set to 'AutomaticByPlatform'.
	EnableHotpatching *bool

	// Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual
	// machines associated to virtual machine scale set with OrchestrationMode as
	// Flexible.<br /><br /> Possible values are:<br /><br /> **Manual** - You
	// control the application of patches to a virtual machine. You do this by
	// applying patches manually inside the VM. In this mode, automatic updates are
	// disabled; the property WindowsConfiguration.enableAutomaticUpdates must be
	// false<br /><br /> **AutomaticByOS** - The virtual machine will automatically be
	// updated by the OS. The property WindowsConfiguration.enableAutomaticUpdates
	// must be true. <br /><br /> **AutomaticByPlatform** - the virtual machine will
	// automatically updated by the platform. The properties provisionVMAgent and
	// WindowsConfiguration.enableAutomaticUpdates must be true
	PatchMode *WindowsVMGuestPatchMode
}

PatchSettings - Specifies settings related to VM Guest Patching on Windows.

func (PatchSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PatchSettings.

func (*PatchSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PatchSettings.

type Plan 

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

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

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

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

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

Plan for the resource.

func (Plan) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Plan.

func (*Plan) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Plan.

type ProtocolTypes 

type ProtocolTypes string

ProtocolTypes - Specifies the protocol of WinRM listener. Possible values are: **http,** **https.** 

const (
	// ProtocolTypesHTTP - Http protocol
	ProtocolTypesHTTP ProtocolTypes = "Http"
	// ProtocolTypesHTTPS - Https protocol
	ProtocolTypesHTTPS ProtocolTypes = "Https"
)

func PossibleProtocolTypesValues 

func PossibleProtocolTypesValues() []ProtocolTypes

PossibleProtocolTypesValues returns the possible values for the ProtocolTypes const type.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - The status of the current operation. 

const (
	// ProvisioningStateCanceled - Resource creation was canceled.
	ProvisioningStateCanceled ProvisioningState = "Canceled"
	// ProvisioningStateCreating - Initial creation in progress.
	ProvisioningStateCreating ProvisioningState = "Creating"
	// ProvisioningStateDeleting - Deletion in progress.
	ProvisioningStateDeleting ProvisioningState = "Deleting"
	// ProvisioningStateFailed - Resource creation failed.
	ProvisioningStateFailed ProvisioningState = "Failed"
	// ProvisioningStateMigrating - Resource is being migrated from one subscription or resource group to another.
	ProvisioningStateMigrating ProvisioningState = "Migrating"
	// ProvisioningStateSucceeded - Resource has been created.
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
	// ProvisioningStateUpdating - Update in progress.
	ProvisioningStateUpdating ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type ProxyAgentSettings 

type ProxyAgentSettings struct {
	// Specifies whether ProxyAgent feature should be enabled on the virtual machine
	// or virtual machine scale set.
	Enabled *bool

	// Increase the value of this property allows user to reset the key used for
	// securing communication channel between guest and host.
	KeyIncarnationID *int32

	// Specifies the mode that ProxyAgent will execute on if the feature is enabled.
	// ProxyAgent will start to audit or monitor but not enforce access control over
	// requests to host endpoints in Audit mode, while in Enforce mode it will enforce
	// access control. The default value is Enforce mode.
	Mode *Mode
}

ProxyAgentSettings - Specifies ProxyAgent settings while creating the virtual machine. Minimum api-version: 2023-09-01.

func (ProxyAgentSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProxyAgentSettings.

func (*ProxyAgentSettings) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyAgentSettings.

type PublicIPAddressSKU 

type PublicIPAddressSKU struct {
	// Specify public IP sku name
	Name *PublicIPAddressSKUName

	// Specify public IP sku tier
	Tier *PublicIPAddressSKUTier
}

PublicIPAddressSKU - Describes the public IP Sku. It can only be set with OrchestrationMode as Flexible.

func (PublicIPAddressSKU) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PublicIPAddressSKU.

func (*PublicIPAddressSKU) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type PublicIPAddressSKU.

type PublicIPAddressSKUName 

type PublicIPAddressSKUName string

PublicIPAddressSKUName - Specify public IP sku name. 

const (
	// PublicIPAddressSKUNameBasic - Basic sku name
	PublicIPAddressSKUNameBasic PublicIPAddressSKUName = "Basic"
	// PublicIPAddressSKUNameStandard - Standard sku name
	PublicIPAddressSKUNameStandard PublicIPAddressSKUName = "Standard"
)

func PossiblePublicIPAddressSKUNameValues 

func PossiblePublicIPAddressSKUNameValues() []PublicIPAddressSKUName

PossiblePublicIPAddressSKUNameValues returns the possible values for the PublicIPAddressSKUName const type.

type PublicIPAddressSKUTier 

type PublicIPAddressSKUTier string

PublicIPAddressSKUTier - Specify public IP sku tier 

const (
	// PublicIPAddressSKUTierGlobal - Global sku tier
	PublicIPAddressSKUTierGlobal PublicIPAddressSKUTier = "Global"
	// PublicIPAddressSKUTierRegional - Regional sku tier
	PublicIPAddressSKUTierRegional PublicIPAddressSKUTier = "Regional"
)

func PossiblePublicIPAddressSKUTierValues 

func PossiblePublicIPAddressSKUTierValues() []PublicIPAddressSKUTier

PossiblePublicIPAddressSKUTierValues returns the possible values for the PublicIPAddressSKUTier const type.

type RegularPriorityAllocationStrategy 

type RegularPriorityAllocationStrategy string

RegularPriorityAllocationStrategy - Regular VM Allocation strategy types for Compute Fleet 

const (
	// RegularPriorityAllocationStrategyLowestPrice - Default. VM sizes distribution will be determined to optimize for price.
	RegularPriorityAllocationStrategyLowestPrice RegularPriorityAllocationStrategy = "LowestPrice"
	// RegularPriorityAllocationStrategyPrioritized - VM sizes distribution will be determined to optimize for the 'priority'
	// as specified for each vm size.
	RegularPriorityAllocationStrategyPrioritized RegularPriorityAllocationStrategy = "Prioritized"
)

func PossibleRegularPriorityAllocationStrategyValues 

func PossibleRegularPriorityAllocationStrategyValues() []RegularPriorityAllocationStrategy

PossibleRegularPriorityAllocationStrategyValues returns the possible values for the RegularPriorityAllocationStrategy const type.

type RegularPriorityProfile 

type RegularPriorityProfile struct {
	// Allocation strategy to follow when determining the VM sizes distribution for Regular VMs.
	AllocationStrategy *RegularPriorityAllocationStrategy

	// Total capacity to achieve. It is currently in terms of number of VMs.
	Capacity *int32

	// Minimum capacity to achieve which cannot be updated. If we will not be able to "guarantee" minimum capacity, we will reject
	// the request in the sync path itself.
	MinCapacity *int32
}

RegularPriorityProfile - Configuration Options for Regular instances in Compute Fleet.

func (RegularPriorityProfile) MarshalJSON 

func (r RegularPriorityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type RegularPriorityProfile.

func (*RegularPriorityProfile) UnmarshalJSON 

func (r *RegularPriorityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type RegularPriorityProfile.

type ResourcePlanUpdate 

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

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

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

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

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

ResourcePlanUpdate - The template for adding optional properties.

func (ResourcePlanUpdate) MarshalJSON 

func (r ResourcePlanUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ResourcePlanUpdate.

func (*ResourcePlanUpdate) UnmarshalJSON 

func (r *ResourcePlanUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ResourcePlanUpdate.

type SSHConfiguration 

type SSHConfiguration struct {
	// The list of SSH public keys used to authenticate with linux based VMs.
	PublicKeys []*SSHPublicKey
}

SSHConfiguration - SSH configuration for Linux based VMs running on Azure

func (SSHConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SSHConfiguration.

func (*SSHConfiguration) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SSHConfiguration.

type SSHPublicKey 

type SSHPublicKey struct {
	// SSH public key certificate used to authenticate with the VM through ssh. The
	// key needs to be at least 2048-bit and in ssh-rsa format. For creating ssh keys,
	// see [Create SSH keys on Linux and Mac for Linux VMs in
	// Azure]https://docs.microsoft.com/azure/virtual-machines/linux/create-ssh-keys-detailed).
	KeyData *string

	// Specifies the full path on the created VM where ssh public key is stored. If
	// the file already exists, the specified key is appended to the file. Example:
	// /home/user/.ssh/authorized_keys
	Path *string
}

SSHPublicKey - Contains information about SSH certificate public key and the path on the Linux VM where the public key is placed.

func (SSHPublicKey) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SSHPublicKey.

func (*SSHPublicKey) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SSHPublicKey.

type ScheduledEventsProfile 

type ScheduledEventsProfile struct {
	// Specifies OS Image Scheduled Event related configurations.
	OSImageNotificationProfile *OSImageNotificationProfile

	// Specifies Terminate Scheduled Event related configurations.
	TerminateNotificationProfile *TerminateNotificationProfile
}

ScheduledEventsProfile - Specifies Scheduled Event related configurations.

func (ScheduledEventsProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ScheduledEventsProfile.

func (*ScheduledEventsProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ScheduledEventsProfile.

type SecurityEncryptionTypes 

type SecurityEncryptionTypes string

SecurityEncryptionTypes - Specifies the EncryptionType of the managed disk. **Note:** It can be set for only Confidential VMs. 

const (
	// SecurityEncryptionTypesDiskWithVMGuestState - EncryptionType of the managed disk is set to DiskWithVMGuestState for encryption
	// of the managed disk along with VMGuestState blob.
	SecurityEncryptionTypesDiskWithVMGuestState SecurityEncryptionTypes = "DiskWithVMGuestState"
	// SecurityEncryptionTypesNonPersistedTPM - EncryptionType of the managed disk is set to NonPersistedTPM for not persisting
	// firmware state in the VMGuestState blob.
	SecurityEncryptionTypesNonPersistedTPM SecurityEncryptionTypes = "NonPersistedTPM"
	// SecurityEncryptionTypesVMGuestStateOnly - EncryptionType of the managed disk is set to VMGuestStateOnly for encryption
	// of just the VMGuestState blob.
	SecurityEncryptionTypesVMGuestStateOnly SecurityEncryptionTypes = "VMGuestStateOnly"
)

func PossibleSecurityEncryptionTypesValues 

func PossibleSecurityEncryptionTypesValues() []SecurityEncryptionTypes

PossibleSecurityEncryptionTypesValues returns the possible values for the SecurityEncryptionTypes const type.

type SecurityPostureReference 

type SecurityPostureReference struct {
	// List of virtual machine extension names to exclude when applying the security
	// posture.
	ExcludeExtensions []*string

	// The security posture reference id in the form of
	// /CommunityGalleries/{communityGalleryName}/securityPostures/{securityPostureName}/versions/{major.minor.patch}|{major.*}|latest
	ID *string

	// Whether the security posture can be overridden by the user.
	IsOverridable *bool
}

SecurityPostureReference - Specifies the security posture to be used for all virtual machines in the scale set. Minimum api-version: 2023-03-01

func (SecurityPostureReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecurityPostureReference.

func (*SecurityPostureReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityPostureReference.

type SecurityProfile 

type SecurityProfile struct {
	// This property can be used by user in the request to enable or disable the Host
	// Encryption for the virtual machine or virtual machine scale set. This will
	// enable the encryption for all the disks including Resource/Temp disk at host
	// itself. The default behavior is: The Encryption at host will be disabled unless
	// this property is set to true for the resource.
	EncryptionAtHost *bool

	// Specifies the Managed Identity used by ADE to get access token for keyvault
	// operations.
	EncryptionIdentity *EncryptionIdentity

	// Specifies ProxyAgent settings while creating the virtual machine. Minimum
	// api-version: 2023-09-01.
	ProxyAgentSettings *ProxyAgentSettings

	// Specifies the SecurityType of the virtual machine. It has to be set to any
	// specified value to enable UefiSettings. The default behavior is: UefiSettings
	// will not be enabled unless this property is set.
	SecurityType *SecurityTypes

	// Specifies the security settings like secure boot and vTPM used while creating
	// the virtual machine. Minimum api-version: 2020-12-01.
	UefiSettings *UefiSettings
}

SecurityProfile - Specifies the Security profile settings for the virtual machine or virtual machine scale set.

func (SecurityProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SecurityProfile.

func (*SecurityProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SecurityProfile.

type SecurityTypes 

type SecurityTypes string

SecurityTypes - Specifies the SecurityType of the virtual machine. It has to be set to any specified value to enable UefiSettings. The default behavior is: UefiSettings will not be enabled unless this property is set. 

const (
	// SecurityTypesConfidentialVM - ConfidentialVM security type
	SecurityTypesConfidentialVM SecurityTypes = "ConfidentialVM"
	// SecurityTypesTrustedLaunch - TrustedLaunch security type
	SecurityTypesTrustedLaunch SecurityTypes = "TrustedLaunch"
)

func PossibleSecurityTypesValues 

func PossibleSecurityTypesValues() []SecurityTypes

PossibleSecurityTypesValues returns the possible values for the SecurityTypes const type.

type ServiceArtifactReference 

type ServiceArtifactReference struct {
	// The service artifact reference id in the form of
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroup}/providers/Microsoft.Compute/galleries/{galleryName}/serviceArtifacts/{serviceArtifactName}/vmArtifactsProfiles/{vmArtifactsProfilesName}
	ID *string
}

ServiceArtifactReference - Specifies the service artifact reference id used to set same image version for all virtual machines in the scale set when using 'latest' image version. Minimum api-version: 2022-11-01

func (ServiceArtifactReference) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServiceArtifactReference.

func (*ServiceArtifactReference) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServiceArtifactReference.

type SettingNames 

type SettingNames string

SettingNames - Specifies the name of the setting to which the content applies. Possible values are: FirstLogonCommands and AutoLogon. 

const (
	// SettingNamesAutoLogon - AutoLogon setting
	SettingNamesAutoLogon SettingNames = "AutoLogon"
	// SettingNamesFirstLogonCommands - FirstLogonCommands setting
	SettingNamesFirstLogonCommands SettingNames = "FirstLogonCommands"
)

func PossibleSettingNamesValues 

func PossibleSettingNamesValues() []SettingNames

PossibleSettingNamesValues returns the possible values for the SettingNames const type.

type SpotAllocationStrategy 

type SpotAllocationStrategy string

SpotAllocationStrategy - Spot allocation strategy types for Compute Fleet 

const (
	// SpotAllocationStrategyCapacityOptimized - VM sizes distribution will be determined to optimize for capacity.
	SpotAllocationStrategyCapacityOptimized SpotAllocationStrategy = "CapacityOptimized"
	// SpotAllocationStrategyLowestPrice - VM sizes distribution will be determined to optimize for price. Note: Capacity will
	// still be considered here but will be given much less weight.
	SpotAllocationStrategyLowestPrice SpotAllocationStrategy = "LowestPrice"
	// SpotAllocationStrategyPriceCapacityOptimized - Default. VM sizes distribution will be determined to optimize for both price
	// and capacity.
	SpotAllocationStrategyPriceCapacityOptimized SpotAllocationStrategy = "PriceCapacityOptimized"
)

func PossibleSpotAllocationStrategyValues 

func PossibleSpotAllocationStrategyValues() []SpotAllocationStrategy

PossibleSpotAllocationStrategyValues returns the possible values for the SpotAllocationStrategy const type.

type SpotPriorityProfile 

type SpotPriorityProfile struct {
	// Allocation strategy to follow when determining the VM sizes distribution for Spot VMs.
	AllocationStrategy *SpotAllocationStrategy

	// Total capacity to achieve. It is currently in terms of number of VMs.
	Capacity *int32

	// Eviction Policy to follow when evicting Spot VMs.
	EvictionPolicy *EvictionPolicy

	// Flag to enable/disable continuous goal seeking for the desired capacity and restoration of evicted Spot VMs.
	// If maintain is enabled, AzureFleetRP will use all VM sizes in vmSizesProfile to create new VMs (if VMs are evicted deleted)
	// or update existing VMs with new VM sizes (if VMs are evicted deallocated or failed to allocate due to capacity constraint)
	// in order to achieve the desired capacity.
	// Maintain is enabled by default.
	Maintain *bool

	// Price per hour of each Spot VM will never exceed this.
	MaxPricePerVM *float32

	// Minimum capacity to achieve which cannot be updated. If we will not be able to "guarantee" minimum capacity, we will reject
	// the request in the sync path itself.
	MinCapacity *int32
}

SpotPriorityProfile - Configuration Options for Spot instances in Compute Fleet.

func (SpotPriorityProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SpotPriorityProfile.

func (*SpotPriorityProfile) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SpotPriorityProfile.

type StorageAccountTypes 

type StorageAccountTypes string

StorageAccountTypes - Specifies the storage account type for the managed disk. Managed OS disk storage account type can only be set when you create the scale set. NOTE: UltraSSD_LRS can only be used with data disks. It cannot be used with OS Disk. Standard_LRS uses Standard HDD. StandardSSD_LRS uses Standard SSD. Premium_LRS uses Premium SSD. UltraSSD_LRS uses Ultra disk. Premium_ZRS uses Premium SSD zone redundant storage. StandardSSD_ZRS uses Standard SSD zone redundant storage. For more information regarding disks supported for Windows Virtual Machines, refer to https://docs.microsoft.com/azure/virtual-machines/windows/disks-types and, for Linux Virtual Machines, refer to https://docs.microsoft.com/azure/virtual-machines/linux/disks-types 

const (
	// StorageAccountTypesPremiumLRS - Premium_LRS option.
	StorageAccountTypesPremiumLRS StorageAccountTypes = "Premium_LRS"
	// StorageAccountTypesPremiumV2LRS - PremiumV2_LRS option.
	StorageAccountTypesPremiumV2LRS StorageAccountTypes = "PremiumV2_LRS"
	// StorageAccountTypesPremiumZRS - Premium_ZRS option.
	StorageAccountTypesPremiumZRS StorageAccountTypes = "Premium_ZRS"
	// StorageAccountTypesStandardLRS - Standard_LRS option.
	StorageAccountTypesStandardLRS StorageAccountTypes = "Standard_LRS"
	// StorageAccountTypesStandardSSDLRS - StandardSSD_LRS option.
	StorageAccountTypesStandardSSDLRS StorageAccountTypes = "StandardSSD_LRS"
	// StorageAccountTypesStandardSSDZRS - StandardSSD_ZRS option.
	StorageAccountTypesStandardSSDZRS StorageAccountTypes = "StandardSSD_ZRS"
	// StorageAccountTypesUltraSSDLRS - UltraSSD_LRS option.
	StorageAccountTypesUltraSSDLRS StorageAccountTypes = "UltraSSD_LRS"
)

func PossibleStorageAccountTypesValues 

func PossibleStorageAccountTypesValues() []StorageAccountTypes

PossibleStorageAccountTypesValues returns the possible values for the StorageAccountTypes const type.

type SubResource 

type SubResource struct {
	// Resource Id
	ID *string
}

SubResource - Describes SubResource

func (SubResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SubResource.

func (*SubResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SubResource.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TerminateNotificationProfile 

type TerminateNotificationProfile struct {
	// Specifies whether the Terminate Scheduled event is enabled or disabled.
	Enable *bool

	// Configurable length of time a Virtual Machine being deleted will have to
	// potentially approve the Terminate Scheduled Event before the event is auto
	// approved (timed out). The configuration must be specified in ISO 8601 format,
	// the default value is 5 minutes (PT5M)
	NotBeforeTimeout *string
}

TerminateNotificationProfile - Specifies Terminate Scheduled Event related configurations.

func (TerminateNotificationProfile) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TerminateNotificationProfile.

func (*TerminateNotificationProfile) UnmarshalJSON 

func (t *TerminateNotificationProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type TerminateNotificationProfile.

type UefiSettings 

type UefiSettings struct {
	// Specifies whether secure boot should be enabled on the virtual machine. Minimum
	// api-version: 2020-12-01.
	SecureBootEnabled *bool

	// Specifies whether vTPM should be enabled on the virtual machine. Minimum
	// api-version: 2020-12-01.
	VTpmEnabled *bool
}

UefiSettings - Specifies the security settings like secure boot and vTPM used while creating the virtual machine. Minimum api-version: 2020-12-01.

func (UefiSettings) MarshalJSON 

func (u UefiSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UefiSettings.

func (*UefiSettings) UnmarshalJSON 

func (u *UefiSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UefiSettings.

type UserAssignedIdentity 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON 

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON 

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type VMAttributeMinMaxDouble added in v1.0.0 

type VMAttributeMinMaxDouble struct {
	// Maximum value. Double.MaxValue(1.7976931348623157E+308)
	Max *float64

	// Minimum value. default 0. Double.MinValue()
	Min *float64
}

VMAttributeMinMaxDouble - VMAttributes using double values.

func (VMAttributeMinMaxDouble) MarshalJSON added in v1.0.0 

func (v VMAttributeMinMaxDouble) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMAttributeMinMaxDouble.

func (*VMAttributeMinMaxDouble) UnmarshalJSON added in v1.0.0 

func (v *VMAttributeMinMaxDouble) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMAttributeMinMaxDouble.

type VMAttributeMinMaxInteger added in v1.0.0 

type VMAttributeMinMaxInteger struct {
	// Max VMSize from CRS, Max = 4294967295 (uint.MaxValue) if not specified.
	Max *int32

	// Min VMSize from CRS, Min = 0 (uint.MinValue) if not specified.
	Min *int32
}

VMAttributeMinMaxInteger - While retrieving VMSizes from CRS, Min = 0 (uint.MinValue) if not specified, Max = 4294967295 (uint.MaxValue) if not specified. This allows to filter VMAttributes on all available VMSizes.

func (VMAttributeMinMaxInteger) MarshalJSON added in v1.0.0 

func (v VMAttributeMinMaxInteger) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMAttributeMinMaxInteger.

func (*VMAttributeMinMaxInteger) UnmarshalJSON added in v1.0.0 

func (v *VMAttributeMinMaxInteger) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMAttributeMinMaxInteger.

type VMAttributeSupport added in v1.0.0 

type VMAttributeSupport string

VMAttributeSupport - VMSizes supported by Azure VMs. Included is a union of Excluded and Required. 

const (
	// VMAttributeSupportExcluded - All VMSizes having the feature support will be excluded.
	VMAttributeSupportExcluded VMAttributeSupport = "Excluded"
	// VMAttributeSupportIncluded - VMSizes that have the feature support and that do not have the feature support will be used.
	// Included is a union of Excluded and Required.
	VMAttributeSupportIncluded VMAttributeSupport = "Included"
	// VMAttributeSupportRequired - Only the VMSizes having the feature support will be used.
	VMAttributeSupportRequired VMAttributeSupport = "Required"
)

func PossibleVMAttributeSupportValues added in v1.0.0 

func PossibleVMAttributeSupportValues() []VMAttributeSupport

PossibleVMAttributeSupportValues returns the possible values for the VMAttributeSupport const type.

type VMAttributes added in v1.0.0 

type VMAttributes struct {
	// REQUIRED; The range of memory specified from Min to Max. Must be specified if VMAttributes are specified, either Min or
	// Max is required if specified.
	MemoryInGiB *VMAttributeMinMaxDouble

	// REQUIRED; The range of vCpuCount specified from Min to Max. Must be specified if VMAttributes are specified, either Min
	// or Max is required if specified.
	VCPUCount *VMAttributeMinMaxInteger

	// The range of accelerator count specified from min to max. Optional parameter. Either Min or Max is required if specified.
	// acceleratorSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If acceleratorSupport is "Excluded", this VMAttribute can not be used.
	AcceleratorCount *VMAttributeMinMaxInteger

	// The accelerator manufacturers specified as a list.
	// acceleratorSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If acceleratorSupport is "Excluded", this VMAttribute can not be used.
	AcceleratorManufacturers []*AcceleratorManufacturer

	// Specifies whether the VMSize supporting accelerator should be used to build Fleet or not.
	// acceleratorSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If acceleratorSupport is "Excluded", this VMAttribute can not be used.
	AcceleratorSupport *VMAttributeSupport

	// The accelerator types specified as a list. acceleratorSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If acceleratorSupport is "Excluded", this VMAttribute can not be used.
	AcceleratorTypes []*AcceleratorType

	// The VM architecture types specified as a list. Optional parameter.
	ArchitectureTypes []*ArchitectureType

	// Specifies whether the VMSize supporting burstable capability should be used to build Fleet or not.
	BurstableSupport *VMAttributeSupport

	// The VM CPU manufacturers specified as a list. Optional parameter.
	CPUManufacturers []*CPUManufacturer

	// The range of data disk count specified from Min to Max. Optional parameter. Either Min or Max is required if specified.
	DataDiskCount *VMAttributeMinMaxInteger

	// Specifies which VMSizes should be excluded while building Fleet. Optional parameter.
	ExcludedVMSizes []*string

	// The local storage disk types specified as a list. LocalStorageSupport should be set to "Included" or "Required" to use
	// this VMAttribute.
	// If localStorageSupport is "Excluded", this VMAttribute can not be used.
	LocalStorageDiskTypes []*LocalStorageDiskType

	// LocalStorageSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If localStorageSupport is "Excluded", this VMAttribute can not be used.
	LocalStorageInGiB *VMAttributeMinMaxDouble

	// Specifies whether the VMSize supporting local storage should be used to build Fleet or not.
	LocalStorageSupport *VMAttributeSupport

	// The range of memory in GiB per vCPU specified from min to max. Optional parameter. Either Min or Max is required if specified.
	MemoryInGiBPerVCpu *VMAttributeMinMaxDouble

	// The range of network bandwidth in Mbps specified from Min to Max. Optional parameter. Either Min or Max is required if
	// specified.
	NetworkBandwidthInMbps *VMAttributeMinMaxDouble

	// The range of network interface count specified from Min to Max. Optional parameter. Either Min or Max is required if specified.
	NetworkInterfaceCount *VMAttributeMinMaxInteger

	// The range of RDMA (Remote Direct Memory Access) network interface count specified from Min to Max. Optional parameter.
	// Either Min or Max is required if specified.
	// rdmaSupport should be set to "Included" or "Required" to use this VMAttribute.
	// If rdmaSupport is "Excluded", this VMAttribute can not be used.
	RdmaNetworkInterfaceCount *VMAttributeMinMaxInteger

	// Specifies whether the VMSize supporting RDMA (Remote Direct Memory Access) should be used to build Fleet or not.
	RdmaSupport *VMAttributeSupport

	// The VM category specified as a list. Optional parameter.
	VMCategories []*VMCategory
}

VMAttributes that will be used to filter VMSizes which will be used to build Fleet.

func (VMAttributes) MarshalJSON added in v1.0.0 

func (v VMAttributes) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMAttributes.

func (*VMAttributes) UnmarshalJSON added in v1.0.0 

func (v *VMAttributes) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMAttributes.

type VMCategory added in v1.0.0 

type VMCategory string

VMCategory - VMCategories defined for Azure VMs. See: https://learn.microsoft.com/en-us/azure/virtual-machines/sizes/overview?tabs=breakdownseries%2Cgeneralsizelist%2Ccomputesizelist%2Cmemorysizelist%2Cstoragesizelist%2Cgpusizelist%2Cfpgasizelist%2Chpcsizelist#general-purpose 

const (
	// VMCategoryComputeOptimized - Compute optimized VM sizes have a high CPU-to-memory ratio. These sizes are good for medium
	// traffic web servers, network appliances, batch processes, and application servers.
	VMCategoryComputeOptimized VMCategory = "ComputeOptimized"
	// VMCategoryFpgaAccelerated - FPGA optimized VM sizes are specialized virtual machines available with single or multiple
	// FPGA.
	// These sizes are designed for compute-intensive workloads. This article provides information about the number and type of
	// FPGA, vCPUs, data disks, and NICs.
	// Storage throughput and network bandwidth are also included for each size in this grouping.
	VMCategoryFpgaAccelerated VMCategory = "FpgaAccelerated"
	// VMCategoryGeneralPurpose - General purpose VM sizes provide balanced CPU-to-memory ratio. Ideal for testing and development,
	// small to medium databases, and low to medium traffic web servers.
	VMCategoryGeneralPurpose VMCategory = "GeneralPurpose"
	// VMCategoryGpuAccelerated - GPU optimized VM sizes are specialized virtual machines available with single, multiple, or
	// fractional GPUs.
	// These sizes are designed for compute-intensive, graphics-intensive, and visualization workloads.
	VMCategoryGpuAccelerated VMCategory = "GpuAccelerated"
	// VMCategoryHighPerformanceCompute - Azure High Performance Compute VMs are optimized for various HPC workloads such as computational
	// fluid dynamics, finite element analysis, frontend and backend EDA,
	// rendering, molecular dynamics, computational geo science, weather simulation, and financial risk analysis.
	VMCategoryHighPerformanceCompute VMCategory = "HighPerformanceCompute"
	// VMCategoryMemoryOptimized - Memory optimized VM sizes offer a high memory-to-CPU ratio that is great for relational database
	// servers, medium to large caches, and in-memory analytics.
	VMCategoryMemoryOptimized VMCategory = "MemoryOptimized"
	// VMCategoryStorageOptimized - Storage optimized virtual machine (VM) sizes offer high disk throughput and IO, and are ideal
	// for Big Data, SQL, NoSQL databases, data warehousing, and large transactional databases.
	// Examples include Cassandra, MongoDB, Cloudera, and Redis.
	VMCategoryStorageOptimized VMCategory = "StorageOptimized"
)

func PossibleVMCategoryValues added in v1.0.0 

func PossibleVMCategoryValues() []VMCategory

PossibleVMCategoryValues returns the possible values for the VMCategory const type.

type VMDiskSecurityProfile 

type VMDiskSecurityProfile struct {
	// Specifies the customer managed disk encryption set resource id for the managed
	// disk that is used for Customer Managed Key encrypted ConfidentialVM OS Disk and
	// VMGuest blob.
	DiskEncryptionSet *DiskEncryptionSetParameters

	// Specifies the EncryptionType of the managed disk. It is set to
	// DiskWithVMGuestState for encryption of the managed disk along with VMGuestState
	// blob, VMGuestStateOnly for encryption of just the VMGuestState blob, and
	// NonPersistedTPM for not persisting firmware state in the VMGuestState blob..
	// **Note:** It can be set for only Confidential VMs.
	SecurityEncryptionType *SecurityEncryptionTypes
}

VMDiskSecurityProfile - Specifies the security profile settings for the managed disk. **Note:** It can only be set for Confidential VMs.

func (VMDiskSecurityProfile) MarshalJSON 

func (v VMDiskSecurityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMDiskSecurityProfile.

func (*VMDiskSecurityProfile) UnmarshalJSON 

func (v *VMDiskSecurityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMDiskSecurityProfile.

type VMGalleryApplication 

type VMGalleryApplication struct {
	// REQUIRED; Specifies the GalleryApplicationVersion resource id on the form of
	// /subscriptions/{SubscriptionId}/resourceGroups/{ResourceGroupName}/providers/Microsoft.Compute/galleries/{galleryName}/applications/{application}/versions/{version}
	PackageReferenceID *string

	// Optional, Specifies the uri to an azure blob that will replace the default
	// configuration for the package if provided
	ConfigurationReference *string

	// If set to true, when a new Gallery Application version is available in PIR/SIG,
	// it will be automatically updated for the VM/VMSS
	EnableAutomaticUpgrade *bool

	// Optional, Specifies the order in which the packages have to be installed
	Order *int32

	// Optional, Specifies a passthrough value for more generic context.
	Tags *string

	// Optional, If true, any failure for any operation in the VmApplication will fail
	// the deployment
	TreatFailureAsDeploymentFailure *bool
}

VMGalleryApplication - Specifies the required information to reference a compute gallery application version

func (VMGalleryApplication) MarshalJSON 

func (v VMGalleryApplication) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMGalleryApplication.

func (*VMGalleryApplication) UnmarshalJSON 

func (v *VMGalleryApplication) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMGalleryApplication.

type VMSizeProfile 

type VMSizeProfile struct {
	// REQUIRED; The Sku name (e.g. 'Standard_DS1_v2')
	Name *string

	// The rank of the VM size. This is used with 'RegularPriorityAllocationStrategy.Prioritized'
	// The lower the number, the higher the priority. Starting with 0.
	Rank *int32
}

VMSizeProfile - Specifications about a VM Size. This will also contain the corresponding rank and weight in future.

func (VMSizeProfile) MarshalJSON 

func (v VMSizeProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMSizeProfile.

func (*VMSizeProfile) UnmarshalJSON 

func (v *VMSizeProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMSizeProfile.

type VMSizeProperties 

type VMSizeProperties struct {
	// Specifies the number of vCPUs available for the VM. When this property is not
	// specified in the request body the default behavior is to set it to the value of
	// vCPUs available for that VM size exposed in api response of [List all available
	// virtual machine sizes in a
	// region](https://docs.microsoft.com/en-us/rest/api/compute/resource-skus/list).
	VCPUsAvailable *int32

	// Specifies the vCPU to physical core ratio. When this property is not specified
	// in the request body the default behavior is set to the value of vCPUsPerCore
	// for the VM Size exposed in api response of [List all available virtual machine
	// sizes in a
	// region](https://docs.microsoft.com/en-us/rest/api/compute/resource-skus/list).
	// **Setting this property to 1 also means that hyper-threading is disabled.**
	VCPUsPerCore *int32
}

VMSizeProperties - Specifies VM Size Property settings on the virtual machine.

func (VMSizeProperties) MarshalJSON 

func (v VMSizeProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VMSizeProperties.

func (*VMSizeProperties) UnmarshalJSON 

func (v *VMSizeProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VMSizeProperties.

type VaultCertificate 

type VaultCertificate struct {
	// For Windows VMs, specifies the certificate store on the Virtual Machine to
	// which the certificate should be added. The specified certificate store is
	// implicitly in the LocalMachine account. For Linux VMs, the certificate file is
	// placed under the /var/lib/waagent directory, with the file name
	// &lt;UppercaseThumbprint&gt;.crt for the X509 certificate file and
	// &lt;UppercaseThumbprint&gt;.prv for private key. Both of these files are .pem
	// formatted.
	CertificateStore *string

	// This is the URL of a certificate that has been uploaded to Key Vault as a
	// secret. For adding a secret to the Key Vault, see [Add a key or secret to the
	// key
	// vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add).
	// In this case, your certificate needs to be It is the Base64 encoding of the
	// following JSON Object which is encoded in UTF-8: <br><br> {<br>
	// "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br>
	// "password":"<pfx-file-password>"<br>} <br> To install certificates on a virtual
	// machine it is recommended to use the [Azure Key Vault virtual machine extension
	// for
	// Linux](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-linux)
	// or the [Azure Key Vault virtual machine extension for
	// Windows](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-windows).
	CertificateURL *string
}

VaultCertificate - Describes a single certificate reference in a Key Vault, and where the certificate should reside on the VM.

func (VaultCertificate) MarshalJSON 

func (v VaultCertificate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VaultCertificate.

func (*VaultCertificate) UnmarshalJSON 

func (v *VaultCertificate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VaultCertificate.

type VaultSecretGroup 

type VaultSecretGroup struct {
	// The relative URL of the Key Vault containing all of the certificates in
	// VaultCertificates.
	SourceVault *SubResource

	// The list of key vault references in SourceVault which contain certificates.
	VaultCertificates []*VaultCertificate
}

VaultSecretGroup - Describes a set of certificates which are all in the same Key Vault.

func (VaultSecretGroup) MarshalJSON 

func (v VaultSecretGroup) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VaultSecretGroup.

func (*VaultSecretGroup) UnmarshalJSON 

func (v *VaultSecretGroup) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VaultSecretGroup.

type VirtualHardDisk 

type VirtualHardDisk struct {
	// Specifies the virtual hard disk's uri.
	URI *string
}

VirtualHardDisk - Describes the uri of a disk.

func (VirtualHardDisk) MarshalJSON 

func (v VirtualHardDisk) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualHardDisk.

func (*VirtualHardDisk) UnmarshalJSON 

func (v *VirtualHardDisk) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualHardDisk.

type VirtualMachineScaleSet 

type VirtualMachineScaleSet struct {
	// READ-ONLY; The compute RP resource id of the virtualMachineScaleSet
	// "subscriptions/{subId}/resourceGroups/{rgName}/providers/Microsoft.Compute/virtualMachineScaleSets/{vmssName}"
	ID *string

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

	// READ-ONLY; This represents the operationStatus of the VMSS in response to the last operation that was performed on it by
	// Azure Fleet resource.
	OperationStatus *ProvisioningState

	// READ-ONLY; Error Information when `operationStatus` is `Failed`
	Error *APIError

	// READ-ONLY; Type of the virtualMachineScaleSet
	Type *string
}

VirtualMachineScaleSet - An AzureFleet's virtualMachineScaleSet

func (VirtualMachineScaleSet) MarshalJSON 

func (v VirtualMachineScaleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSet.

func (*VirtualMachineScaleSet) UnmarshalJSON 

func (v *VirtualMachineScaleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSet.

type VirtualMachineScaleSetDataDisk 

type VirtualMachineScaleSetDataDisk struct {
	// REQUIRED; The create option.
	CreateOption *DiskCreateOptionTypes

	// REQUIRED; 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

	// Specifies the caching requirements. Possible values are: **None,**
	// **ReadOnly,** **ReadWrite.** The default values are: **None for Standard
	// storage. ReadOnly for Premium storage.**
	Caching *CachingTypes

	// Specifies whether data disk should be deleted or detached upon VMSS Flex
	// deletion (This feature is available for VMSS with Flexible OrchestrationMode
	// only).<br><br> Possible values: <br><br> **Delete** If this value is used, the
	// data disk is deleted when the VMSS Flex VM is deleted.<br><br> **Detach** If
	// this value is used, the data disk is retained after VMSS Flex VM is
	// deleted.<br><br> The default value is set to **Delete**.
	DeleteOption *DiskDeleteOptionTypes

	// Specifies the Read-Write IOPS for the managed disk. Should be used only when
	// StorageAccountType is UltraSSD_LRS. If not specified, a default value would be
	// assigned based on diskSizeGB.
	DiskIOPSReadWrite *int64

	// Specifies the bandwidth in MB per second for the managed disk. Should be used
	// only when StorageAccountType is UltraSSD_LRS. If not specified, a default value
	// would be assigned based on diskSizeGB.
	DiskMBpsReadWrite *int64

	// Specifies the size of an empty data disk in gigabytes. This element can be used
	// to overwrite the size of the disk in a virtual machine image. The property
	// diskSizeGB is the number of bytes x 1024^3 for the disk and the value cannot be
	// larger than 1023.
	DiskSizeGB *int32

	// The managed disk parameters.
	ManagedDisk *VirtualMachineScaleSetManagedDiskParameters

	// The disk name.
	Name *string

	// Specifies whether writeAccelerator should be enabled or disabled on the disk.
	WriteAcceleratorEnabled *bool
}

VirtualMachineScaleSetDataDisk - Describes a virtual machine scale set data disk.

func (VirtualMachineScaleSetDataDisk) MarshalJSON 

func (v VirtualMachineScaleSetDataDisk) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetDataDisk.

func (*VirtualMachineScaleSetDataDisk) UnmarshalJSON 

func (v *VirtualMachineScaleSetDataDisk) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetDataDisk.

type VirtualMachineScaleSetExtension 

type VirtualMachineScaleSetExtension struct {
	// The name of the extension.
	Name *string

	// Describes the properties of a Virtual Machine Scale Set Extension.
	Properties *VirtualMachineScaleSetExtensionProperties

	// READ-ONLY; Resource Id
	ID *string

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

VirtualMachineScaleSetExtension - Describes a Virtual Machine Scale Set Extension.

func (VirtualMachineScaleSetExtension) MarshalJSON 

func (v VirtualMachineScaleSetExtension) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetExtension.

func (*VirtualMachineScaleSetExtension) UnmarshalJSON 

func (v *VirtualMachineScaleSetExtension) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetExtension.

type VirtualMachineScaleSetExtensionProfile 

type VirtualMachineScaleSetExtensionProfile struct {
	// The virtual machine scale set child extension resources.
	Extensions []*VirtualMachineScaleSetExtension

	// Specifies the time alloted for all extensions to start. The time duration
	// should be between 15 minutes and 120 minutes (inclusive) and should be
	// specified in ISO 8601 format. The default value is 90 minutes (PT1H30M).
	// Minimum api-version: 2020-06-01.
	ExtensionsTimeBudget *string
}

VirtualMachineScaleSetExtensionProfile - Describes a virtual machine scale set extension profile.

func (VirtualMachineScaleSetExtensionProfile) MarshalJSON 

func (v VirtualMachineScaleSetExtensionProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetExtensionProfile.

func (*VirtualMachineScaleSetExtensionProfile) UnmarshalJSON 

func (v *VirtualMachineScaleSetExtensionProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetExtensionProfile.

type VirtualMachineScaleSetExtensionProperties 

type VirtualMachineScaleSetExtensionProperties struct {
	// Indicates whether the extension should use a newer minor version if one is
	// available at deployment time. Once deployed, however, the extension will not
	// upgrade minor versions unless redeployed, even with this property set to true.
	AutoUpgradeMinorVersion *bool

	// Indicates whether the extension should be automatically upgraded by the
	// platform if there is a newer version of the extension available.
	EnableAutomaticUpgrade *bool

	// If a value is provided and is different from the previous value, the extension
	// handler will be forced to update even if the extension configuration has not
	// changed.
	ForceUpdateTag *string

	// The extension can contain either protectedSettings or
	// protectedSettingsFromKeyVault or no protected settings at all.
	ProtectedSettings map[string]any

	// The extensions protected settings that are passed by reference, and consumed
	// from key vault
	ProtectedSettingsFromKeyVault *KeyVaultSecretReference

	// Collection of extension names after which this extension needs to be
	// provisioned.
	ProvisionAfterExtensions []*string

	// The name of the extension handler publisher.
	Publisher *string

	// Json formatted public settings for the extension.
	Settings map[string]any

	// Indicates whether failures stemming from the extension will be suppressed
	// (Operational failures such as not connecting to the VM will not be suppressed
	// regardless of this value). The default is false.
	SuppressFailures *bool

	// Specifies the type of the extension; an example is "CustomScriptExtension".
	Type *string

	// Specifies the version of the script handler.
	TypeHandlerVersion *string

	// READ-ONLY; The provisioning state, which only appears in the response.
	ProvisioningState *string
}

VirtualMachineScaleSetExtensionProperties - Describes the properties of a Virtual Machine Scale Set Extension.

func (VirtualMachineScaleSetExtensionProperties) MarshalJSON 

func (v VirtualMachineScaleSetExtensionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetExtensionProperties.

func (*VirtualMachineScaleSetExtensionProperties) UnmarshalJSON 

func (v *VirtualMachineScaleSetExtensionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetExtensionProperties.

type VirtualMachineScaleSetHardwareProfile 

type VirtualMachineScaleSetHardwareProfile struct {
	// Specifies the properties for customizing the size of the virtual machine.
	// Minimum api-version: 2021-11-01. Please follow the instructions in [VM
	// Customization](https://aka.ms/vmcustomization) for more details.
	VMSizeProperties *VMSizeProperties
}

VirtualMachineScaleSetHardwareProfile - Specifies the hardware settings for the virtual machine scale set.

func (VirtualMachineScaleSetHardwareProfile) MarshalJSON 

func (v VirtualMachineScaleSetHardwareProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetHardwareProfile.

func (*VirtualMachineScaleSetHardwareProfile) UnmarshalJSON 

func (v *VirtualMachineScaleSetHardwareProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetHardwareProfile.

type VirtualMachineScaleSetIPConfiguration 

type VirtualMachineScaleSetIPConfiguration struct {
	// REQUIRED; The IP configuration name.
	Name *string

	// Describes a virtual machine scale set network profile's IP configuration
	// properties.
	Properties *VirtualMachineScaleSetIPConfigurationProperties
}

VirtualMachineScaleSetIPConfiguration - Describes a virtual machine scale set network profile's IP configuration.

func (VirtualMachineScaleSetIPConfiguration) MarshalJSON 

func (v VirtualMachineScaleSetIPConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetIPConfiguration.

func (*VirtualMachineScaleSetIPConfiguration) UnmarshalJSON 

func (v *VirtualMachineScaleSetIPConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetIPConfiguration.

type VirtualMachineScaleSetIPConfigurationProperties 

type VirtualMachineScaleSetIPConfigurationProperties struct {
	// Specifies an array of references to backend address pools of application
	// gateways. A scale set can reference backend address pools of multiple
	// application gateways. Multiple scale sets cannot use the same application
	// gateway.
	ApplicationGatewayBackendAddressPools []*SubResource

	// Specifies an array of references to application security group.
	ApplicationSecurityGroups []*SubResource

	// Specifies an array of references to backend address pools of load balancers. A
	// scale set can reference backend address pools of one public and one internal
	// load balancer. Multiple scale sets cannot use the same basic sku load balancer.
	LoadBalancerBackendAddressPools []*SubResource

	// Specifies an array of references to inbound Nat pools of the load balancers. A
	// scale set can reference inbound nat pools of one public and one internal load
	// balancer. Multiple scale sets cannot use the same basic sku load balancer.
	LoadBalancerInboundNatPools []*SubResource

	// Specifies the primary network interface in case the virtual machine has more
	// than 1 network interface.
	Primary *bool

	// Available from Api-Version 2017-03-30 onwards, it represents whether the
	// specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible
	// values are: 'IPv4' and 'IPv6'.
	PrivateIPAddressVersion *IPVersion

	// The publicIPAddressConfiguration.
	PublicIPAddressConfiguration *VirtualMachineScaleSetPublicIPAddressConfiguration

	// Specifies the identifier of the subnet.
	Subnet *APIEntityReference
}

VirtualMachineScaleSetIPConfigurationProperties - Describes a virtual machine scale set network profile's IP configuration properties.

func (VirtualMachineScaleSetIPConfigurationProperties) MarshalJSON 

func (v VirtualMachineScaleSetIPConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetIPConfigurationProperties.

func (*VirtualMachineScaleSetIPConfigurationProperties) UnmarshalJSON 

func (v *VirtualMachineScaleSetIPConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetIPConfigurationProperties.

type VirtualMachineScaleSetIPTag 

type VirtualMachineScaleSetIPTag struct {
	// IP tag type. Example: FirstPartyUsage.
	IPTagType *string

	// IP tag associated with the public IP. Example: SQL, Storage etc.
	Tag *string
}

VirtualMachineScaleSetIPTag - Contains the IP tag associated with the public IP address.

func (VirtualMachineScaleSetIPTag) MarshalJSON 

func (v VirtualMachineScaleSetIPTag) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetIPTag.

func (*VirtualMachineScaleSetIPTag) UnmarshalJSON 

func (v *VirtualMachineScaleSetIPTag) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetIPTag.

type VirtualMachineScaleSetListResult 

type VirtualMachineScaleSetListResult struct {
	// REQUIRED; The VirtualMachineScaleSet items on this page
	Value []*VirtualMachineScaleSet

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

VirtualMachineScaleSetListResult - The response of a VirtualMachineScaleSet list operation.

func (VirtualMachineScaleSetListResult) MarshalJSON 

func (v VirtualMachineScaleSetListResult) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetListResult.

func (*VirtualMachineScaleSetListResult) UnmarshalJSON 

func (v *VirtualMachineScaleSetListResult) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetListResult.

type VirtualMachineScaleSetManagedDiskParameters 

type VirtualMachineScaleSetManagedDiskParameters struct {
	// Specifies the customer managed disk encryption set resource id for the managed
	// disk.
	DiskEncryptionSet *DiskEncryptionSetParameters

	// Specifies the security profile for the managed disk.
	SecurityProfile *VMDiskSecurityProfile

	// Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can
	// only be used with data disks, it cannot be used with OS Disk.
	StorageAccountType *StorageAccountTypes
}

VirtualMachineScaleSetManagedDiskParameters - Describes the parameters of a ScaleSet managed disk.

func (VirtualMachineScaleSetManagedDiskParameters) MarshalJSON 

func (v VirtualMachineScaleSetManagedDiskParameters) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetManagedDiskParameters.

func (*VirtualMachineScaleSetManagedDiskParameters) UnmarshalJSON 

func (v *VirtualMachineScaleSetManagedDiskParameters) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetManagedDiskParameters.

type VirtualMachineScaleSetNetworkConfiguration 

type VirtualMachineScaleSetNetworkConfiguration struct {
	// REQUIRED; The network configuration name.
	Name *string

	// Describes a virtual machine scale set network profile's IP configuration.
	Properties *VirtualMachineScaleSetNetworkConfigurationProperties
}

VirtualMachineScaleSetNetworkConfiguration - Describes a virtual machine scale set network profile's network configurations.

func (VirtualMachineScaleSetNetworkConfiguration) MarshalJSON 

func (v VirtualMachineScaleSetNetworkConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetNetworkConfiguration.

func (*VirtualMachineScaleSetNetworkConfiguration) UnmarshalJSON 

func (v *VirtualMachineScaleSetNetworkConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetNetworkConfiguration.

type VirtualMachineScaleSetNetworkConfigurationDNSSettings 

type VirtualMachineScaleSetNetworkConfigurationDNSSettings struct {
	// List of DNS servers IP addresses
	DNSServers []*string
}

VirtualMachineScaleSetNetworkConfigurationDNSSettings - Describes a virtual machines scale sets network configuration's DNS settings.

func (VirtualMachineScaleSetNetworkConfigurationDNSSettings) MarshalJSON 

func (v VirtualMachineScaleSetNetworkConfigurationDNSSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetNetworkConfigurationDNSSettings.

func (*VirtualMachineScaleSetNetworkConfigurationDNSSettings) UnmarshalJSON 

func (v *VirtualMachineScaleSetNetworkConfigurationDNSSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetNetworkConfigurationDNSSettings.

type VirtualMachineScaleSetNetworkConfigurationProperties 

type VirtualMachineScaleSetNetworkConfigurationProperties struct {
	// REQUIRED; Specifies the IP configurations of the network interface.
	IPConfigurations []*VirtualMachineScaleSetIPConfiguration

	// Specifies whether the Auxiliary mode is enabled for the Network Interface
	// resource.
	AuxiliaryMode *NetworkInterfaceAuxiliaryMode

	// Specifies whether the Auxiliary sku is enabled for the Network Interface
	// resource.
	AuxiliarySKU *NetworkInterfaceAuxiliarySKU

	// The dns settings to be applied on the network interfaces.
	DNSSettings *VirtualMachineScaleSetNetworkConfigurationDNSSettings

	// Specify what happens to the network interface when the VM is deleted
	DeleteOption *DeleteOptions

	// Specifies whether the network interface is disabled for tcp state tracking.
	DisableTCPStateTracking *bool

	// Specifies whether the network interface is accelerated networking-enabled.
	EnableAcceleratedNetworking *bool

	// Specifies whether the network interface is FPGA networking-enabled.
	EnableFpga *bool

	// Whether IP forwarding enabled on this NIC.
	EnableIPForwarding *bool

	// The network security group.
	NetworkSecurityGroup *SubResource

	// Specifies the primary network interface in case the virtual machine has more
	// than 1 network interface.
	Primary *bool
}

VirtualMachineScaleSetNetworkConfigurationProperties - Describes a virtual machine scale set network profile's IP configuration.

func (VirtualMachineScaleSetNetworkConfigurationProperties) MarshalJSON 

func (v VirtualMachineScaleSetNetworkConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetNetworkConfigurationProperties.

func (*VirtualMachineScaleSetNetworkConfigurationProperties) UnmarshalJSON 

func (v *VirtualMachineScaleSetNetworkConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetNetworkConfigurationProperties.

type VirtualMachineScaleSetNetworkProfile 

type VirtualMachineScaleSetNetworkProfile struct {
	// A reference to a load balancer probe used to determine the health of an
	// instance in the virtual machine scale set. The reference will be in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}'.
	HealthProbe *APIEntityReference

	// specifies the Microsoft.Network API version used when creating networking
	// resources in the Network Interface Configurations for Virtual Machine Scale Set
	// with orchestration mode 'Flexible'
	NetworkAPIVersion *NetworkAPIVersion

	// The list of network configurations.
	NetworkInterfaceConfigurations []*VirtualMachineScaleSetNetworkConfiguration
}

VirtualMachineScaleSetNetworkProfile - Describes a virtual machine scale set network profile.

func (VirtualMachineScaleSetNetworkProfile) MarshalJSON 

func (v VirtualMachineScaleSetNetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetNetworkProfile.

func (*VirtualMachineScaleSetNetworkProfile) UnmarshalJSON 

func (v *VirtualMachineScaleSetNetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetNetworkProfile.

type VirtualMachineScaleSetOSDisk 

type VirtualMachineScaleSetOSDisk struct {
	// REQUIRED; Specifies how the virtual machines in the scale set should be created. The only
	// allowed value is: **FromImage.** This value is used when you are using an image
	// to create the virtual machine. If you are using a platform image, you also use
	// the imageReference element described above. If you are using a marketplace
	// image, you also use the plan element previously described.
	CreateOption *DiskCreateOptionTypes

	// Specifies the caching requirements. Possible values are: **None,**
	// **ReadOnly,** **ReadWrite.** The default values are: **None for Standard
	// storage. ReadOnly for Premium storage.**
	Caching *CachingTypes

	// Specifies whether OS Disk should be deleted or detached upon VMSS Flex deletion
	// (This feature is available for VMSS with Flexible OrchestrationMode only).
	// <br><br> Possible values: <br><br> **Delete** If this value is used, the OS
	// disk is deleted when VMSS Flex VM is deleted.<br><br> **Detach** If this value
	// is used, the OS disk is retained after VMSS Flex VM is deleted. <br><br> The
	// default value is set to **Delete**. For an Ephemeral OS Disk, the default value
	// is set to **Delete**. User cannot change the delete option for Ephemeral OS
	// Disk.
	DeleteOption *DiskDeleteOptionTypes

	// Specifies the ephemeral disk Settings for the operating system disk used by the
	// virtual machine scale set.
	DiffDiskSettings *DiffDiskSettings

	// Specifies the size of an empty data disk in gigabytes. This element can be used
	// to overwrite the size of the disk in a virtual machine image. The property 'diskSizeGB'
	// is the number of bytes x 1024^3 for the disk and the value cannot
	// be larger than 1023.
	DiskSizeGB *int32

	// Specifies information about the unmanaged user image to base the scale set on.
	Image *VirtualHardDisk

	// The managed disk parameters.
	ManagedDisk *VirtualMachineScaleSetManagedDiskParameters

	// The disk name.
	Name *string

	// This property allows you to specify the type of the OS that is included in the
	// disk if creating a VM from user-image or a specialized VHD. Possible values
	// are: **Windows,** **Linux.**
	OSType *OperatingSystemTypes

	// Specifies the container urls that are used to store operating system disks for
	// the scale set.
	VhdContainers []*string

	// Specifies whether writeAccelerator should be enabled or disabled on the disk.
	WriteAcceleratorEnabled *bool
}

VirtualMachineScaleSetOSDisk - Describes a virtual machine scale set operating system disk.

func (VirtualMachineScaleSetOSDisk) MarshalJSON 

func (v VirtualMachineScaleSetOSDisk) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetOSDisk.

func (*VirtualMachineScaleSetOSDisk) UnmarshalJSON 

func (v *VirtualMachineScaleSetOSDisk) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetOSDisk.

type VirtualMachineScaleSetOSProfile 

type VirtualMachineScaleSetOSProfile struct {
	// Specifies the password of the administrator account. <br><br> **Minimum-length
	// (Windows):** 8 characters <br><br> **Minimum-length (Linux):** 6 characters
	// <br><br> **Max-length (Windows):** 123 characters <br><br> **Max-length
	// (Linux):** 72 characters <br><br> **Complexity requirements:** 3 out of 4
	// conditions below need to be fulfilled <br> Has lower characters <br>Has upper
	// characters <br> Has a digit <br> Has a special character (Regex match [\W_])
	// <br><br> **Disallowed values:** "abc@123", "P@$$w0rd", "P@ssw0rd",
	// "P@ssword123", "Pa$$word", "pass@word1", "Password!", "Password1",
	// "Password22", "iloveyou!" <br><br> For resetting the password, see [How to
	// reset the Remote Desktop service or its login password in a Windows
	// VM](https://docs.microsoft.com/troubleshoot/azure/virtual-machines/reset-rdp)
	// <br><br> For resetting root password, see [Manage users, SSH, and check or
	// repair disks on Azure Linux VMs using the VMAccess
	// Extension](https://docs.microsoft.com/troubleshoot/azure/virtual-machines/troubleshoot-ssh-connection)
	AdminPassword *string

	// Specifies the name of the administrator account. <br><br> **Windows-only
	// restriction:** Cannot end in "." <br><br> **Disallowed values:**
	// "administrator", "admin", "user", "user1", "test", "user2", "test1", "user3",
	// "admin1", "1", "123", "a", "actuser", "adm", "admin2", "aspnet", "backup",
	// "console", "david", "guest", "john", "owner", "root", "server", "sql",
	// "support", "support_388945a0", "sys", "test2", "test3", "user4", "user5".
	// <br><br> **Minimum-length (Linux):** 1 character <br><br> **Max-length
	// (Linux):** 64 characters <br><br> **Max-length (Windows):** 20 characters
	AdminUsername *string

	// Specifies whether extension operations should be allowed on the virtual machine
	// scale set. This may only be set to False when no extensions are present on the
	// virtual machine scale set.
	AllowExtensionOperations *bool

	// Specifies the computer name prefix for all of the virtual machines in the scale
	// set. Computer name prefixes must be 1 to 15 characters long.
	ComputerNamePrefix *string

	// Specifies a base-64 encoded string of custom data. The base-64 encoded string
	// is decoded to a binary array that is saved as a file on the Virtual Machine.
	// The maximum length of the binary array is 65535 bytes. For using cloud-init for
	// your VM, see [Using cloud-init to customize a Linux VM during
	// creation](https://docs.microsoft.com/azure/virtual-machines/linux/using-cloud-init)
	CustomData *string

	// Specifies the Linux operating system settings on the virtual machine. For a
	// list of supported Linux distributions, see [Linux on Azure-Endorsed
	// Distributions](https://docs.microsoft.com/azure/virtual-machines/linux/endorsed-distros).
	LinuxConfiguration *LinuxConfiguration

	// Optional property which must either be set to True or omitted.
	RequireGuestProvisionSignal *bool

	// Specifies set of certificates that should be installed onto the virtual
	// machines in the scale set. To install certificates on a virtual machine it is
	// recommended to use the [Azure Key Vault virtual machine extension for
	// Linux](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-linux)
	// or the [Azure Key Vault virtual machine extension for
	// Windows](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-windows).
	Secrets []*VaultSecretGroup

	// Specifies Windows operating system settings on the virtual machine.
	WindowsConfiguration *WindowsConfiguration
}

VirtualMachineScaleSetOSProfile - Describes a virtual machine scale set OS profile.

func (VirtualMachineScaleSetOSProfile) MarshalJSON 

func (v VirtualMachineScaleSetOSProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetOSProfile.

func (*VirtualMachineScaleSetOSProfile) UnmarshalJSON 

func (v *VirtualMachineScaleSetOSProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetOSProfile.

type VirtualMachineScaleSetPublicIPAddressConfiguration 

type VirtualMachineScaleSetPublicIPAddressConfiguration struct {
	// REQUIRED; The publicIP address configuration name.
	Name *string

	// Describes a virtual machines scale set IP Configuration's PublicIPAddress
	// configuration
	Properties *VirtualMachineScaleSetPublicIPAddressConfigurationProperties

	// Describes the public IP Sku. It can only be set with OrchestrationMode as
	// Flexible.
	SKU *PublicIPAddressSKU
}

VirtualMachineScaleSetPublicIPAddressConfiguration - Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration

func (VirtualMachineScaleSetPublicIPAddressConfiguration) MarshalJSON 

func (v VirtualMachineScaleSetPublicIPAddressConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetPublicIPAddressConfiguration.

func (*VirtualMachineScaleSetPublicIPAddressConfiguration) UnmarshalJSON 

func (v *VirtualMachineScaleSetPublicIPAddressConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetPublicIPAddressConfiguration.

type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings 

type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings struct {
	// REQUIRED; The Domain name label.The concatenation of the domain name label and vm index
	// will be the domain name labels of the PublicIPAddress resources that will be
	// created
	DomainNameLabel *string

	// The Domain name label scope.The concatenation of the hashed domain name label
	// that generated according to the policy from domain name label scope and vm
	// index will be the domain name labels of the PublicIPAddress resources that will
	// be created
	DomainNameLabelScope *DomainNameLabelScopeTypes
}

VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings - Describes a virtual machines scale sets network configuration's DNS settings.

func (VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings) MarshalJSON 

func (v VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings.

func (*VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings) UnmarshalJSON 

func (v *VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings.

type VirtualMachineScaleSetPublicIPAddressConfigurationProperties 

type VirtualMachineScaleSetPublicIPAddressConfigurationProperties struct {
	// The dns settings to be applied on the publicIP addresses .
	DNSSettings *VirtualMachineScaleSetPublicIPAddressConfigurationDNSSettings

	// Specify what happens to the public IP when the VM is deleted
	DeleteOption *DeleteOptions

	// The list of IP tags associated with the public IP address.
	IPTags []*VirtualMachineScaleSetIPTag

	// The idle timeout of the public IP address.
	IdleTimeoutInMinutes *int32

	// Available from Api-Version 2019-07-01 onwards, it represents whether the
	// specific ipconfiguration is IPv4 or IPv6. Default is taken as IPv4. Possible
	// values are: 'IPv4' and 'IPv6'.
	PublicIPAddressVersion *IPVersion

	// The PublicIPPrefix from which to allocate publicIP addresses.
	PublicIPPrefix *SubResource
}

VirtualMachineScaleSetPublicIPAddressConfigurationProperties - Describes a virtual machines scale set IP Configuration's PublicIPAddress configuration

func (VirtualMachineScaleSetPublicIPAddressConfigurationProperties) MarshalJSON 

func (v VirtualMachineScaleSetPublicIPAddressConfigurationProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetPublicIPAddressConfigurationProperties.

func (*VirtualMachineScaleSetPublicIPAddressConfigurationProperties) UnmarshalJSON 

func (v *VirtualMachineScaleSetPublicIPAddressConfigurationProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetPublicIPAddressConfigurationProperties.

type VirtualMachineScaleSetStorageProfile 

type VirtualMachineScaleSetStorageProfile struct {
	// Specifies the parameters that are used to add data disks to the virtual
	// machines in the scale set. For more information about disks, see [About disks
	// and VHDs for Azure virtual
	// machines](https://docs.microsoft.com/azure/virtual-machines/managed-disks-overview).
	DataDisks []*VirtualMachineScaleSetDataDisk

	// Specifies the disk controller type configured for the virtual machines in the scale set. Minimum api-version: 2022-08-01
	DiskControllerType *DiskControllerTypes

	// Specifies information about the image to use. You can specify information about
	// platform images, marketplace images, or virtual machine images. This element is
	// required when you want to use a platform image, marketplace image, or virtual
	// machine image, but is not used in other creation operations.
	ImageReference *ImageReference

	// Specifies information about the operating system disk used by the virtual
	// machines in the scale set. For more information about disks, see [About disks
	// and VHDs for Azure virtual
	// machines](https://docs.microsoft.com/azure/virtual-machines/managed-disks-overview).
	OSDisk *VirtualMachineScaleSetOSDisk
}

VirtualMachineScaleSetStorageProfile - Describes a virtual machine scale set storage profile.

func (VirtualMachineScaleSetStorageProfile) MarshalJSON 

func (v VirtualMachineScaleSetStorageProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type VirtualMachineScaleSetStorageProfile.

func (*VirtualMachineScaleSetStorageProfile) UnmarshalJSON 

func (v *VirtualMachineScaleSetStorageProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type VirtualMachineScaleSetStorageProfile.

type WinRMConfiguration 

type WinRMConfiguration struct {
	// The list of Windows Remote Management listeners
	Listeners []*WinRMListener
}

WinRMConfiguration - Describes Windows Remote Management configuration of the VM

func (WinRMConfiguration) MarshalJSON 

func (w WinRMConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WinRMConfiguration.

func (*WinRMConfiguration) UnmarshalJSON 

func (w *WinRMConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WinRMConfiguration.

type WinRMListener 

type WinRMListener struct {
	// This is the URL of a certificate that has been uploaded to Key Vault as a
	// secret. For adding a secret to the Key Vault, see [Add a key or secret to the
	// key
	// vault](https://docs.microsoft.com/azure/key-vault/key-vault-get-started/#add).
	// In this case, your certificate needs to be the Base64 encoding of the following
	// JSON Object which is encoded in UTF-8: <br><br> {<br>
	// "data":"<Base64-encoded-certificate>",<br> "dataType":"pfx",<br>
	// "password":"<pfx-file-password>"<br>} <br> To install certificates on a virtual
	// machine it is recommended to use the [Azure Key Vault virtual machine extension
	// for
	// Linux](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-linux)
	// or the [Azure Key Vault virtual machine extension for
	// Windows](https://docs.microsoft.com/azure/virtual-machines/extensions/key-vault-windows).
	CertificateURL *string

	// Specifies the protocol of WinRM listener. Possible values are: **http,**
	// **https.**
	Protocol *ProtocolTypes
}

WinRMListener - Describes Protocol and thumbprint of Windows Remote Management listener

func (WinRMListener) MarshalJSON 

func (w WinRMListener) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WinRMListener.

func (*WinRMListener) UnmarshalJSON 

func (w *WinRMListener) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WinRMListener.

type WindowsConfiguration 

type WindowsConfiguration struct {
	// Specifies additional base-64 encoded XML formatted information that can be
	// included in the Unattend.xml file, which is used by Windows Setup.
	AdditionalUnattendContent []*AdditionalUnattendContent

	// Indicates whether Automatic Updates is enabled for the Windows virtual machine.
	// Default value is true. For virtual machine scale sets, this property can be
	// updated and updates will take effect on OS reprovisioning.
	EnableAutomaticUpdates *bool

	// Indicates whether VMAgent Platform Updates is enabled for the Windows virtual
	// machine. Default value is false.
	EnableVMAgentPlatformUpdates *bool

	// [Preview Feature] Specifies settings related to VM Guest Patching on Windows.
	PatchSettings *PatchSettings

	// Indicates whether virtual machine agent should be provisioned on the virtual
	// machine. When this property is not specified in the request body, it is set to
	// true by default. This will ensure that VM Agent is installed on the VM so that
	// extensions can be added to the VM later.
	ProvisionVMAgent *bool

	// Specifies the time zone of the virtual machine. e.g. "Pacific Standard Time".
	// Possible values can be
	// [TimeZoneInfo.Id](https://docs.microsoft.com/dotnet/api/system.timezoneinfo.id?#System_TimeZoneInfo_Id)
	// value from time zones returned by
	// [TimeZoneInfo.GetSystemTimeZones](https://docs.microsoft.com/dotnet/api/system.timezoneinfo.getsystemtimezones).
	TimeZone *string

	// Specifies the Windows Remote Management listeners. This enables remote Windows
	// PowerShell.
	WinRM *WinRMConfiguration
}

WindowsConfiguration - Specifies Windows operating system settings on the virtual machine.

func (WindowsConfiguration) MarshalJSON 

func (w WindowsConfiguration) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WindowsConfiguration.

func (*WindowsConfiguration) UnmarshalJSON 

func (w *WindowsConfiguration) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WindowsConfiguration.

type WindowsPatchAssessmentMode 

type WindowsPatchAssessmentMode string

WindowsPatchAssessmentMode - Specifies the mode of VM Guest patch assessment for the IaaS virtual machine. 

const (
	// WindowsPatchAssessmentModeAutomaticByPlatform - The platform will trigger periodic patch assessments. The property provisionVMAgent
	// must be true.
	WindowsPatchAssessmentModeAutomaticByPlatform WindowsPatchAssessmentMode = "AutomaticByPlatform"
	// WindowsPatchAssessmentModeImageDefault - You control the timing of patch assessments on a virtual machine.
	WindowsPatchAssessmentModeImageDefault WindowsPatchAssessmentMode = "ImageDefault"
)

func PossibleWindowsPatchAssessmentModeValues 

func PossibleWindowsPatchAssessmentModeValues() []WindowsPatchAssessmentMode

PossibleWindowsPatchAssessmentModeValues returns the possible values for the WindowsPatchAssessmentMode const type.

type WindowsVMGuestPatchAutomaticByPlatformRebootSetting 

type WindowsVMGuestPatchAutomaticByPlatformRebootSetting string

WindowsVMGuestPatchAutomaticByPlatformRebootSetting - Specifies the reboot setting for all AutomaticByPlatform patch installation operations. 

const (
	// WindowsVMGuestPatchAutomaticByPlatformRebootSettingAlways - Always Reboot setting
	WindowsVMGuestPatchAutomaticByPlatformRebootSettingAlways WindowsVMGuestPatchAutomaticByPlatformRebootSetting = "Always"
	// WindowsVMGuestPatchAutomaticByPlatformRebootSettingIfRequired - IfRequired Reboot setting
	WindowsVMGuestPatchAutomaticByPlatformRebootSettingIfRequired WindowsVMGuestPatchAutomaticByPlatformRebootSetting = "IfRequired"
	// WindowsVMGuestPatchAutomaticByPlatformRebootSettingNever - Never Reboot setting
	WindowsVMGuestPatchAutomaticByPlatformRebootSettingNever WindowsVMGuestPatchAutomaticByPlatformRebootSetting = "Never"
	// WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown - Unknown Reboot setting
	WindowsVMGuestPatchAutomaticByPlatformRebootSettingUnknown WindowsVMGuestPatchAutomaticByPlatformRebootSetting = "Unknown"
)

func PossibleWindowsVMGuestPatchAutomaticByPlatformRebootSettingValues 

func PossibleWindowsVMGuestPatchAutomaticByPlatformRebootSettingValues() []WindowsVMGuestPatchAutomaticByPlatformRebootSetting

PossibleWindowsVMGuestPatchAutomaticByPlatformRebootSettingValues returns the possible values for the WindowsVMGuestPatchAutomaticByPlatformRebootSetting const type.

type WindowsVMGuestPatchAutomaticByPlatformSettings 

type WindowsVMGuestPatchAutomaticByPlatformSettings struct {
	// Enables customer to schedule patching without accidental upgrades
	BypassPlatformSafetyChecksOnUserSchedule *bool

	// Specifies the reboot setting for all AutomaticByPlatform patch installation
	// operations.
	RebootSetting *WindowsVMGuestPatchAutomaticByPlatformRebootSetting
}

WindowsVMGuestPatchAutomaticByPlatformSettings - Specifies additional settings to be applied when patch mode AutomaticByPlatform is selected in Windows patch settings.

func (WindowsVMGuestPatchAutomaticByPlatformSettings) MarshalJSON 

func (w WindowsVMGuestPatchAutomaticByPlatformSettings) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WindowsVMGuestPatchAutomaticByPlatformSettings.

func (*WindowsVMGuestPatchAutomaticByPlatformSettings) UnmarshalJSON 

func (w *WindowsVMGuestPatchAutomaticByPlatformSettings) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WindowsVMGuestPatchAutomaticByPlatformSettings.

type WindowsVMGuestPatchMode 

type WindowsVMGuestPatchMode string

WindowsVMGuestPatchMode - Specifies the mode of VM Guest Patching to IaaS virtual machine or virtual machines associated to virtual machine scale set with OrchestrationMode as Flexible. 

const (
	// WindowsVMGuestPatchModeAutomaticByOS - The virtual machine will automatically be updated by the OS.
	// The property WindowsConfiguration.enableAutomaticUpdates must be true.
	WindowsVMGuestPatchModeAutomaticByOS WindowsVMGuestPatchMode = "AutomaticByOS"
	// WindowsVMGuestPatchModeAutomaticByPlatform - The virtual machine will automatically updated by the platform. The properties
	// provisionVMAgent and WindowsConfiguration.enableAutomaticUpdates must be true.
	WindowsVMGuestPatchModeAutomaticByPlatform WindowsVMGuestPatchMode = "AutomaticByPlatform"
	// WindowsVMGuestPatchModeManual - You control the application of patches to a virtual machine.
	// You do this by applying patches manually inside the VM. In this mode,
	// automatic updates are disabled; the property WindowsConfiguration.enableAutomaticUpdates
	// must be false
	WindowsVMGuestPatchModeManual WindowsVMGuestPatchMode = "Manual"
)

func PossibleWindowsVMGuestPatchModeValues 

func PossibleWindowsVMGuestPatchModeValues() []WindowsVMGuestPatchMode

PossibleWindowsVMGuestPatchModeValues returns the possible values for the WindowsVMGuestPatchMode const type.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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