armsqlvirtualmachine

package module
v0.6.0 Latest Latest
Warning

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

 Go to latest Published: Jun 6, 2022 License: MIT Imports: 16 Imported by: 4

README

Azure SQL Server on Azure Virtual Machines Module for Go

PkgGoDev

The armsqlvirtualmachine module provides operations for working with Azure SQL Server on Azure Virtual Machines.

Source code

Getting started

Prerequisites

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure SQL Server on Azure Virtual Machines module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine

Authorization

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

cred, err := azidentity.NewDefaultAzureCredential(nil)

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

Clients

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

client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient(<subscription ID>, cred, nil)

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

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient(<subscription ID>, cred, &options)

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the SQL Server on Azure Virtual Machines 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 AdditionalFeaturesServerConfigurations 

type AdditionalFeaturesServerConfigurations struct {
	// Enable or disable R services (SQL 2016 onwards).
	IsRServicesEnabled *bool `json:"isRServicesEnabled,omitempty"`
}

AdditionalFeaturesServerConfigurations - Additional SQL Server feature settings.

type AgConfiguration added in v0.3.0 

type AgConfiguration struct {
	// READ-ONLY; Replica configurations.
	Replicas []*AgReplica `json:"replicas,omitempty" azure:"ro"`
}

AgConfiguration - Availability group configuration.

func (AgConfiguration) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AgConfiguration.

type AgReplica added in v0.3.0 

type AgReplica struct {
	// Replica commit mode in availability group.
	Commit *Commit `json:"commit,omitempty"`

	// Replica failover mode in availability group.
	Failover *Failover `json:"failover,omitempty"`

	// Replica readable secondary mode in availability group.
	ReadableSecondary *ReadableSecondary `json:"readableSecondary,omitempty"`

	// Replica Role in availability group.
	Role *Role `json:"role,omitempty"`

	// Sql VirtualMachine Instance Id.
	SQLVirtualMachineInstanceID *string `json:"sqlVirtualMachineInstanceId,omitempty"`
}

AgReplica - Availability group replica configuration.

type AssessmentDayOfWeek added in v0.6.0 

type AssessmentDayOfWeek string

AssessmentDayOfWeek - Day of the week to run assessment. 

const (
	AssessmentDayOfWeekMonday    AssessmentDayOfWeek = "Monday"
	AssessmentDayOfWeekTuesday   AssessmentDayOfWeek = "Tuesday"
	AssessmentDayOfWeekWednesday AssessmentDayOfWeek = "Wednesday"
	AssessmentDayOfWeekThursday  AssessmentDayOfWeek = "Thursday"
	AssessmentDayOfWeekFriday    AssessmentDayOfWeek = "Friday"
	AssessmentDayOfWeekSaturday  AssessmentDayOfWeek = "Saturday"
	AssessmentDayOfWeekSunday    AssessmentDayOfWeek = "Sunday"
)

func PossibleAssessmentDayOfWeekValues added in v0.6.0 

func PossibleAssessmentDayOfWeekValues() []AssessmentDayOfWeek

PossibleAssessmentDayOfWeekValues returns the possible values for the AssessmentDayOfWeek const type.

type AssessmentSettings added in v0.3.0 

type AssessmentSettings struct {
	// Enable or disable assessment feature on SQL virtual machine.
	Enable *bool `json:"enable,omitempty"`

	// Run assessment immediately on SQL virtual machine.
	RunImmediately *bool `json:"runImmediately,omitempty"`

	// Schedule for Assessment.
	Schedule *Schedule `json:"schedule,omitempty"`
}

AssessmentSettings - Configure assessment for databases in your SQL virtual machine.

type AutoBackupDaysOfWeek added in v0.6.0 

type AutoBackupDaysOfWeek string
const (
	AutoBackupDaysOfWeekFriday    AutoBackupDaysOfWeek = "Friday"
	AutoBackupDaysOfWeekMonday    AutoBackupDaysOfWeek = "Monday"
	AutoBackupDaysOfWeekSaturday  AutoBackupDaysOfWeek = "Saturday"
	AutoBackupDaysOfWeekSunday    AutoBackupDaysOfWeek = "Sunday"
	AutoBackupDaysOfWeekThursday  AutoBackupDaysOfWeek = "Thursday"
	AutoBackupDaysOfWeekTuesday   AutoBackupDaysOfWeek = "Tuesday"
	AutoBackupDaysOfWeekWednesday AutoBackupDaysOfWeek = "Wednesday"
)

func PossibleAutoBackupDaysOfWeekValues added in v0.6.0 

func PossibleAutoBackupDaysOfWeekValues() []AutoBackupDaysOfWeek

PossibleAutoBackupDaysOfWeekValues returns the possible values for the AutoBackupDaysOfWeek const type.

type AutoBackupSettings 

type AutoBackupSettings struct {
	// Backup schedule type.
	BackupScheduleType *BackupScheduleType `json:"backupScheduleType,omitempty"`

	// Include or exclude system databases from auto backup.
	BackupSystemDbs *bool `json:"backupSystemDbs,omitempty"`

	// Days of the week for the backups when FullBackupFrequency is set to Weekly.
	DaysOfWeek []*AutoBackupDaysOfWeek `json:"daysOfWeek,omitempty"`

	// Enable or disable autobackup on SQL virtual machine.
	Enable *bool `json:"enable,omitempty"`

	// Enable or disable encryption for backup on SQL virtual machine.
	EnableEncryption *bool `json:"enableEncryption,omitempty"`

	// Frequency of full backups. In both cases, full backups begin during the next scheduled time window.
	FullBackupFrequency *FullBackupFrequencyType `json:"fullBackupFrequency,omitempty"`

	// Start time of a given day during which full backups can take place. 0-23 hours.
	FullBackupStartTime *int32 `json:"fullBackupStartTime,omitempty"`

	// Duration of the time window of a given day during which full backups can take place. 1-23 hours.
	FullBackupWindowHours *int32 `json:"fullBackupWindowHours,omitempty"`

	// Frequency of log backups. 5-60 minutes.
	LogBackupFrequency *int32 `json:"logBackupFrequency,omitempty"`

	// Password for encryption on backup.
	Password *string `json:"password,omitempty"`

	// Retention period of backup: 1-90 days.
	RetentionPeriod *int32 `json:"retentionPeriod,omitempty"`

	// Storage account key where backup will be taken to.
	StorageAccessKey *string `json:"storageAccessKey,omitempty"`

	// Storage account url where backup will be taken to.
	StorageAccountURL *string `json:"storageAccountUrl,omitempty"`

	// Storage container name where backup will be taken to.
	StorageContainerName *string `json:"storageContainerName,omitempty"`
}

AutoBackupSettings - Configure backups for databases in your SQL virtual machine.

func (AutoBackupSettings) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type AutoBackupSettings.

type AutoPatchingSettings 

type AutoPatchingSettings struct {
	// Day of week to apply the patch on.
	DayOfWeek *DayOfWeek `json:"dayOfWeek,omitempty"`

	// Enable or disable autopatching on SQL virtual machine.
	Enable *bool `json:"enable,omitempty"`

	// Duration of patching.
	MaintenanceWindowDuration *int32 `json:"maintenanceWindowDuration,omitempty"`

	// Hour of the day when patching is initiated. Local VM time.
	MaintenanceWindowStartingHour *int32 `json:"maintenanceWindowStartingHour,omitempty"`
}

AutoPatchingSettings - Set a patching window during which Windows and SQL patches will be applied.

type AvailabilityGroupListener 

type AvailabilityGroupListener struct {
	// Resource properties.
	Properties *AvailabilityGroupListenerProperties `json:"properties,omitempty"`

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

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

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

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

AvailabilityGroupListener - A SQL Server availability group listener.

type AvailabilityGroupListenerListResult 

type AvailabilityGroupListenerListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`

	// READ-ONLY; Array of results.
	Value []*AvailabilityGroupListener `json:"value,omitempty" azure:"ro"`
}

AvailabilityGroupListenerListResult - A list of availability group listeners.

type AvailabilityGroupListenerProperties 

type AvailabilityGroupListenerProperties struct {
	// Availability Group configuration.
	AvailabilityGroupConfiguration *AgConfiguration `json:"availabilityGroupConfiguration,omitempty"`

	// Name of the availability group.
	AvailabilityGroupName *string `json:"availabilityGroupName,omitempty"`

	// Create a default availability group if it does not exist.
	CreateDefaultAvailabilityGroupIfNotExist *bool `json:"createDefaultAvailabilityGroupIfNotExist,omitempty"`

	// List of load balancer configurations for an availability group listener.
	LoadBalancerConfigurations []*LoadBalancerConfiguration `json:"loadBalancerConfigurations,omitempty"`

	// Listener port.
	Port *int32 `json:"port,omitempty"`

	// READ-ONLY; Provisioning state to track the async operation status.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

AvailabilityGroupListenerProperties - The properties of an availability group listener.

func (AvailabilityGroupListenerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type AvailabilityGroupListenerProperties.

type AvailabilityGroupListenersClient 

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

AvailabilityGroupListenersClient contains the methods for the AvailabilityGroupListeners group. Don't use this type directly, use NewAvailabilityGroupListenersClient() instead.

func NewAvailabilityGroupListenersClient 

func NewAvailabilityGroupListenersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AvailabilityGroupListenersClient, error)

NewAvailabilityGroupListenersClient creates a new instance of AvailabilityGroupListenersClient with the specified values. subscriptionID - Subscription ID that identifies an Azure subscription. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*AvailabilityGroupListenersClient) BeginCreateOrUpdate 

func (client *AvailabilityGroupListenersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, availabilityGroupListenerName string, parameters AvailabilityGroupListener, options *AvailabilityGroupListenersClientBeginCreateOrUpdateOptions) (*runtime.Poller[AvailabilityGroupListenersClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates an availability group listener. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. availabilityGroupListenerName - Name of the availability group listener. parameters - The availability group listener. options - AvailabilityGroupListenersClientBeginCreateOrUpdateOptions contains the optional parameters for the AvailabilityGroupListenersClient.BeginCreateOrUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/CreateOrUpdateAvailabilityGroupListener.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewAvailabilityGroupListenersClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreateOrUpdate(ctx,
		"testrg",
		"testvmgroup",
		"agl-test",
		armsqlvirtualmachine.AvailabilityGroupListener{
			Properties: &armsqlvirtualmachine.AvailabilityGroupListenerProperties{
				AvailabilityGroupName: to.Ptr("ag-test"),
				LoadBalancerConfigurations: []*armsqlvirtualmachine.LoadBalancerConfiguration{
					{
						LoadBalancerResourceID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Network/loadBalancers/lb-test"),
						PrivateIPAddress: &armsqlvirtualmachine.PrivateIPAddress{
							IPAddress:        to.Ptr("10.1.0.112"),
							SubnetResourceID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Network/virtualNetworks/test-vnet/subnets/default"),
						},
						ProbePort: to.Ptr[int32](59983),
						SQLVirtualMachineInstances: []*string{
							to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.SqlVirtualMachine/sqlVirtualMachines/testvm2"),
							to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.SqlVirtualMachine/sqlVirtualMachines/testvm3")},
					}},
				Port: to.Ptr[int32](1433),
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*AvailabilityGroupListenersClient) BeginDelete 

func (client *AvailabilityGroupListenersClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, availabilityGroupListenerName string, options *AvailabilityGroupListenersClientBeginDeleteOptions) (*runtime.Poller[AvailabilityGroupListenersClientDeleteResponse], error)

BeginDelete - Deletes an availability group listener. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. availabilityGroupListenerName - Name of the availability group listener. options - AvailabilityGroupListenersClientBeginDeleteOptions contains the optional parameters for the AvailabilityGroupListenersClient.BeginDelete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/DeleteAvailabilityGroupListener.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewAvailabilityGroupListenersClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(ctx,
		"testrg",
		"testvmgroup",
		"agl-test",
		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 (*AvailabilityGroupListenersClient) Get 

func (client *AvailabilityGroupListenersClient) Get(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, availabilityGroupListenerName string, options *AvailabilityGroupListenersClientGetOptions) (AvailabilityGroupListenersClientGetResponse, error)

Get - Gets an availability group listener. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. availabilityGroupListenerName - Name of the availability group listener. options - AvailabilityGroupListenersClientGetOptions contains the optional parameters for the AvailabilityGroupListenersClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/GetAvailabilityGroupListener.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewAvailabilityGroupListenersClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"testrg",
		"testvmgroup",
		"agl-test",
		&armsqlvirtualmachine.AvailabilityGroupListenersClientGetOptions{Expand: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*AvailabilityGroupListenersClient) NewListByGroupPager added in v0.4.0 

func (client *AvailabilityGroupListenersClient) NewListByGroupPager(resourceGroupName string, sqlVirtualMachineGroupName string, options *AvailabilityGroupListenersClientListByGroupOptions) *runtime.Pager[AvailabilityGroupListenersClientListByGroupResponse]

NewListByGroupPager - Lists all availability group listeners in a SQL virtual machine group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. options - AvailabilityGroupListenersClientListByGroupOptions contains the optional parameters for the AvailabilityGroupListenersClient.ListByGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListByGroupAvailabilityGroupListener.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewAvailabilityGroupListenersClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByGroupPager("testrg",
		"testvmgroup",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

type AvailabilityGroupListenersClientBeginCreateOrUpdateOptions added in v0.2.0 

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

AvailabilityGroupListenersClientBeginCreateOrUpdateOptions contains the optional parameters for the AvailabilityGroupListenersClient.BeginCreateOrUpdate method.

type AvailabilityGroupListenersClientBeginDeleteOptions added in v0.2.0 

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

AvailabilityGroupListenersClientBeginDeleteOptions contains the optional parameters for the AvailabilityGroupListenersClient.BeginDelete method.

type AvailabilityGroupListenersClientCreateOrUpdateResponse added in v0.2.0 

type AvailabilityGroupListenersClientCreateOrUpdateResponse struct {
	AvailabilityGroupListener
}

AvailabilityGroupListenersClientCreateOrUpdateResponse contains the response from method AvailabilityGroupListenersClient.CreateOrUpdate.

type AvailabilityGroupListenersClientDeleteResponse added in v0.2.0 

type AvailabilityGroupListenersClientDeleteResponse struct {
}

AvailabilityGroupListenersClientDeleteResponse contains the response from method AvailabilityGroupListenersClient.Delete.

type AvailabilityGroupListenersClientGetOptions added in v0.2.0 

type AvailabilityGroupListenersClientGetOptions struct {
	// The child resources to include in the response.
	Expand *string
}

AvailabilityGroupListenersClientGetOptions contains the optional parameters for the AvailabilityGroupListenersClient.Get method.

type AvailabilityGroupListenersClientGetResponse added in v0.2.0 

type AvailabilityGroupListenersClientGetResponse struct {
	AvailabilityGroupListener
}

AvailabilityGroupListenersClientGetResponse contains the response from method AvailabilityGroupListenersClient.Get.

type AvailabilityGroupListenersClientListByGroupOptions added in v0.2.0 

type AvailabilityGroupListenersClientListByGroupOptions struct {
}

AvailabilityGroupListenersClientListByGroupOptions contains the optional parameters for the AvailabilityGroupListenersClient.ListByGroup method.

type AvailabilityGroupListenersClientListByGroupResponse added in v0.2.0 

type AvailabilityGroupListenersClientListByGroupResponse struct {
	AvailabilityGroupListenerListResult
}

AvailabilityGroupListenersClientListByGroupResponse contains the response from method AvailabilityGroupListenersClient.ListByGroup.

type BackupScheduleType 

type BackupScheduleType string

BackupScheduleType - Backup schedule type. 

const (
	BackupScheduleTypeAutomated BackupScheduleType = "Automated"
	BackupScheduleTypeManual    BackupScheduleType = "Manual"
)

func PossibleBackupScheduleTypeValues 

func PossibleBackupScheduleTypeValues() []BackupScheduleType

PossibleBackupScheduleTypeValues returns the possible values for the BackupScheduleType const type.

type ClusterConfiguration 

type ClusterConfiguration string

ClusterConfiguration - Cluster type. 

const (
	ClusterConfigurationDomainful ClusterConfiguration = "Domainful"
)

func PossibleClusterConfigurationValues 

func PossibleClusterConfigurationValues() []ClusterConfiguration

PossibleClusterConfigurationValues returns the possible values for the ClusterConfiguration const type.

type ClusterManagerType 

type ClusterManagerType string

ClusterManagerType - Type of cluster manager: Windows Server Failover Cluster (WSFC), implied by the scale type of the group and the OS type. 

const (
	ClusterManagerTypeWSFC ClusterManagerType = "WSFC"
)

func PossibleClusterManagerTypeValues 

func PossibleClusterManagerTypeValues() []ClusterManagerType

PossibleClusterManagerTypeValues returns the possible values for the ClusterManagerType const type.

type Commit added in v0.3.0 

type Commit string

Commit - Replica commit mode in availability group. 

const (
	CommitASYNCHRONOUSCOMMIT Commit = "ASYNCHRONOUS_COMMIT"
	CommitSYNCHRONOUSCOMMIT  Commit = "SYNCHRONOUS_COMMIT"
)

func PossibleCommitValues added in v0.3.0 

func PossibleCommitValues() []Commit

PossibleCommitValues returns the possible values for the Commit const type.

type ConnectivityType 

type ConnectivityType string

ConnectivityType - SQL Server connectivity option. 

const (
	ConnectivityTypeLOCAL   ConnectivityType = "LOCAL"
	ConnectivityTypePRIVATE ConnectivityType = "PRIVATE"
	ConnectivityTypePUBLIC  ConnectivityType = "PUBLIC"
)

func PossibleConnectivityTypeValues 

func PossibleConnectivityTypeValues() []ConnectivityType

PossibleConnectivityTypeValues returns the possible values for the ConnectivityType const type.

type CreatedByType added in v0.3.0 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues added in v0.3.0 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type DayOfWeek 

type DayOfWeek string

DayOfWeek - Day of week to apply the patch on. 

const (
	DayOfWeekEveryday  DayOfWeek = "Everyday"
	DayOfWeekMonday    DayOfWeek = "Monday"
	DayOfWeekTuesday   DayOfWeek = "Tuesday"
	DayOfWeekWednesday DayOfWeek = "Wednesday"
	DayOfWeekThursday  DayOfWeek = "Thursday"
	DayOfWeekFriday    DayOfWeek = "Friday"
	DayOfWeekSaturday  DayOfWeek = "Saturday"
	DayOfWeekSunday    DayOfWeek = "Sunday"
)

func PossibleDayOfWeekValues 

func PossibleDayOfWeekValues() []DayOfWeek

PossibleDayOfWeekValues returns the possible values for the DayOfWeek const type.

type DiskConfigurationType 

type DiskConfigurationType string

DiskConfigurationType - Disk configuration to apply to SQL Server. 

const (
	DiskConfigurationTypeADD    DiskConfigurationType = "ADD"
	DiskConfigurationTypeEXTEND DiskConfigurationType = "EXTEND"
	DiskConfigurationTypeNEW    DiskConfigurationType = "NEW"
)

func PossibleDiskConfigurationTypeValues 

func PossibleDiskConfigurationTypeValues() []DiskConfigurationType

PossibleDiskConfigurationTypeValues returns the possible values for the DiskConfigurationType const type.

type Failover added in v0.3.0 

type Failover string

Failover - Replica failover mode in availability group. 

const (
	FailoverAUTOMATIC Failover = "AUTOMATIC"
	FailoverMANUAL    Failover = "MANUAL"
)

func PossibleFailoverValues added in v0.3.0 

func PossibleFailoverValues() []Failover

PossibleFailoverValues returns the possible values for the Failover const type.

type FullBackupFrequencyType 

type FullBackupFrequencyType string

FullBackupFrequencyType - Frequency of full backups. In both cases, full backups begin during the next scheduled time window. 

const (
	FullBackupFrequencyTypeDaily  FullBackupFrequencyType = "Daily"
	FullBackupFrequencyTypeWeekly FullBackupFrequencyType = "Weekly"
)

func PossibleFullBackupFrequencyTypeValues 

func PossibleFullBackupFrequencyTypeValues() []FullBackupFrequencyType

PossibleFullBackupFrequencyTypeValues returns the possible values for the FullBackupFrequencyType const type.

type Group added in v0.2.0 

type Group struct {
	// REQUIRED; Resource location.
	Location *string `json:"location,omitempty"`

	// Resource properties.
	Properties *GroupProperties `json:"properties,omitempty"`

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

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

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

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

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

Group - A SQL virtual machine group.

func (Group) MarshalJSON added in v0.2.0 

func (g Group) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Group.

type GroupListResult added in v0.2.0 

type GroupListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`

	// READ-ONLY; Array of results.
	Value []*Group `json:"value,omitempty" azure:"ro"`
}

GroupListResult - A list of SQL virtual machine groups.

type GroupProperties added in v0.2.0 

type GroupProperties struct {
	// SQL image offer. Examples may include SQL2016-WS2016, SQL2017-WS2016.
	SQLImageOffer *string `json:"sqlImageOffer,omitempty"`

	// SQL image sku.
	SQLImageSKU *SQLVMGroupImageSKU `json:"sqlImageSku,omitempty"`

	// Cluster Active Directory domain profile.
	WsfcDomainProfile *WsfcDomainProfile `json:"wsfcDomainProfile,omitempty"`

	// READ-ONLY; Cluster type.
	ClusterConfiguration *ClusterConfiguration `json:"clusterConfiguration,omitempty" azure:"ro"`

	// READ-ONLY; Type of cluster manager: Windows Server Failover Cluster (WSFC), implied by the scale type of the group and
	// the OS type.
	ClusterManagerType *ClusterManagerType `json:"clusterManagerType,omitempty" azure:"ro"`

	// READ-ONLY; Provisioning state to track the async operation status.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Scale type.
	ScaleType *ScaleType `json:"scaleType,omitempty" azure:"ro"`
}

GroupProperties - The properties of a SQL virtual machine group.

type GroupUpdate added in v0.2.0 

type GroupUpdate struct {
	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`
}

GroupUpdate - An update to a SQL virtual machine group.

func (GroupUpdate) MarshalJSON added in v0.2.0 

func (g GroupUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type GroupUpdate.

type GroupsClient added in v0.2.0 

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

GroupsClient contains the methods for the SQLVirtualMachineGroups group. Don't use this type directly, use NewGroupsClient() instead.

func NewGroupsClient added in v0.2.0 

func NewGroupsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*GroupsClient, error)

NewGroupsClient creates a new instance of GroupsClient with the specified values. subscriptionID - Subscription ID that identifies an Azure subscription. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*GroupsClient) BeginCreateOrUpdate added in v0.2.0 

func (client *GroupsClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, parameters Group, options *GroupsClientBeginCreateOrUpdateOptions) (*runtime.Poller[GroupsClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a SQL virtual machine group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. parameters - The SQL virtual machine group. options - GroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the GroupsClient.BeginCreateOrUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/CreateOrUpdateSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewGroupsClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreateOrUpdate(ctx,
		"testrg",
		"testvmgroup",
		armsqlvirtualmachine.Group{
			Location: to.Ptr("northeurope"),
			Tags: map[string]*string{
				"mytag": to.Ptr("myval"),
			},
			Properties: &armsqlvirtualmachine.GroupProperties{
				SQLImageOffer: to.Ptr("SQL2016-WS2016"),
				SQLImageSKU:   to.Ptr(armsqlvirtualmachine.SQLVMGroupImageSKUEnterprise),
				WsfcDomainProfile: &armsqlvirtualmachine.WsfcDomainProfile{
					ClusterBootstrapAccount:  to.Ptr("testrpadmin"),
					ClusterOperatorAccount:   to.Ptr("testrp@testdomain.com"),
					DomainFqdn:               to.Ptr("testdomain.com"),
					OuPath:                   to.Ptr("OU=WSCluster,DC=testdomain,DC=com"),
					SQLServiceAccount:        to.Ptr("sqlservice@testdomain.com"),
					StorageAccountPrimaryKey: to.Ptr("<primary storage access key>"),
					StorageAccountURL:        to.Ptr("https://storgact.blob.core.windows.net/"),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*GroupsClient) BeginDelete added in v0.2.0 

func (client *GroupsClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, options *GroupsClientBeginDeleteOptions) (*runtime.Poller[GroupsClientDeleteResponse], error)

BeginDelete - Deletes a SQL virtual machine group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. options - GroupsClientBeginDeleteOptions contains the optional parameters for the GroupsClient.BeginDelete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/DeleteSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewGroupsClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(ctx,
		"testrg",
		"testvmgroup",
		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 (*GroupsClient) BeginUpdate added in v0.2.0 

func (client *GroupsClient) BeginUpdate(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, parameters GroupUpdate, options *GroupsClientBeginUpdateOptions) (*runtime.Poller[GroupsClientUpdateResponse], error)

BeginUpdate - Updates SQL virtual machine group tags. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. parameters - The SQL virtual machine group. options - GroupsClientBeginUpdateOptions contains the optional parameters for the GroupsClient.BeginUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/UpdateSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewGroupsClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginUpdate(ctx,
		"testrg",
		"testvmgroup",
		armsqlvirtualmachine.GroupUpdate{
			Tags: map[string]*string{
				"mytag": to.Ptr("myval"),
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*GroupsClient) Get added in v0.2.0 

func (client *GroupsClient) Get(ctx context.Context, resourceGroupName string, sqlVirtualMachineGroupName string, options *GroupsClientGetOptions) (GroupsClientGetResponse, error)

Get - Gets a SQL virtual machine group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. options - GroupsClientGetOptions contains the optional parameters for the GroupsClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/GetSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewGroupsClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"testrg",
		"testvmgroup",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*GroupsClient) NewListByResourceGroupPager added in v0.4.0 

func (client *GroupsClient) NewListByResourceGroupPager(resourceGroupName string, options *GroupsClientListByResourceGroupOptions) *runtime.Pager[GroupsClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets all SQL virtual machine groups in a resource group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. options - GroupsClientListByResourceGroupOptions contains the optional parameters for the GroupsClient.ListByResourceGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListByResourceGroupSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewGroupsClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByResourceGroupPager("testrg",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

func (*GroupsClient) NewListPager added in v0.4.0 

func (client *GroupsClient) NewListPager(options *GroupsClientListOptions) *runtime.Pager[GroupsClientListResponse]

NewListPager - Gets all SQL virtual machine groups in a subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview options - GroupsClientListOptions contains the optional parameters for the GroupsClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListSubscriptionSqlVirtualMachineGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

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

Output:

type GroupsClientBeginCreateOrUpdateOptions added in v0.2.0 

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

GroupsClientBeginCreateOrUpdateOptions contains the optional parameters for the GroupsClient.BeginCreateOrUpdate method.

type GroupsClientBeginDeleteOptions added in v0.2.0 

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

GroupsClientBeginDeleteOptions contains the optional parameters for the GroupsClient.BeginDelete method.

type GroupsClientBeginUpdateOptions added in v0.2.0 

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

GroupsClientBeginUpdateOptions contains the optional parameters for the GroupsClient.BeginUpdate method.

type GroupsClientCreateOrUpdateResponse added in v0.2.0 

type GroupsClientCreateOrUpdateResponse struct {
	Group
}

GroupsClientCreateOrUpdateResponse contains the response from method GroupsClient.CreateOrUpdate.

type GroupsClientDeleteResponse added in v0.2.0 

type GroupsClientDeleteResponse struct {
}

GroupsClientDeleteResponse contains the response from method GroupsClient.Delete.

type GroupsClientGetOptions added in v0.2.0 

type GroupsClientGetOptions struct {
}

GroupsClientGetOptions contains the optional parameters for the GroupsClient.Get method.

type GroupsClientGetResponse added in v0.2.0 

type GroupsClientGetResponse struct {
	Group
}

GroupsClientGetResponse contains the response from method GroupsClient.Get.

type GroupsClientListByResourceGroupOptions added in v0.2.0 

type GroupsClientListByResourceGroupOptions struct {
}

GroupsClientListByResourceGroupOptions contains the optional parameters for the GroupsClient.ListByResourceGroup method.

type GroupsClientListByResourceGroupResponse added in v0.2.0 

type GroupsClientListByResourceGroupResponse struct {
	GroupListResult
}

GroupsClientListByResourceGroupResponse contains the response from method GroupsClient.ListByResourceGroup.

type GroupsClientListOptions added in v0.2.0 

type GroupsClientListOptions struct {
}

GroupsClientListOptions contains the optional parameters for the GroupsClient.List method.

type GroupsClientListResponse added in v0.2.0 

type GroupsClientListResponse struct {
	GroupListResult
}

GroupsClientListResponse contains the response from method GroupsClient.List.

type GroupsClientUpdateResponse added in v0.2.0 

type GroupsClientUpdateResponse struct {
	Group
}

GroupsClientUpdateResponse contains the response from method GroupsClient.Update.

type IdentityType 

type IdentityType string

IdentityType - The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an Azure Active Directory principal for the resource. 

const (
	IdentityTypeNone           IdentityType = "None"
	IdentityTypeSystemAssigned IdentityType = "SystemAssigned"
)

func PossibleIdentityTypeValues 

func PossibleIdentityTypeValues() []IdentityType

PossibleIdentityTypeValues returns the possible values for the IdentityType const type.

type KeyVaultCredentialSettings 

type KeyVaultCredentialSettings struct {
	// Azure Key Vault url.
	AzureKeyVaultURL *string `json:"azureKeyVaultUrl,omitempty"`

	// Credential name.
	CredentialName *string `json:"credentialName,omitempty"`

	// Enable or disable key vault credential setting.
	Enable *bool `json:"enable,omitempty"`

	// Service principal name to access key vault.
	ServicePrincipalName *string `json:"servicePrincipalName,omitempty"`

	// Service principal name secret to access key vault.
	ServicePrincipalSecret *string `json:"servicePrincipalSecret,omitempty"`
}

KeyVaultCredentialSettings - Configure your SQL virtual machine to be able to connect to the Azure Key Vault service.

type ListResult added in v0.2.0 

type ListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`

	// READ-ONLY; Array of results.
	Value []*SQLVirtualMachine `json:"value,omitempty" azure:"ro"`
}

ListResult - A list of SQL virtual machines.

type LoadBalancerConfiguration 

type LoadBalancerConfiguration struct {
	// Resource id of the load balancer.
	LoadBalancerResourceID *string `json:"loadBalancerResourceId,omitempty"`

	// Private IP address.
	PrivateIPAddress *PrivateIPAddress `json:"privateIpAddress,omitempty"`

	// Probe port.
	ProbePort *int32 `json:"probePort,omitempty"`

	// Resource id of the public IP.
	PublicIPAddressResourceID *string `json:"publicIpAddressResourceId,omitempty"`

	// List of the SQL virtual machine instance resource id's that are enrolled into the availability group listener.
	SQLVirtualMachineInstances []*string `json:"sqlVirtualMachineInstances,omitempty"`
}

LoadBalancerConfiguration - A load balancer configuration for an availability group listener.

func (LoadBalancerConfiguration) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type LoadBalancerConfiguration.

type Operation 

type Operation struct {
	// READ-ONLY; The localized display information for this particular operation / action.
	Display *OperationDisplay `json:"display,omitempty" azure:"ro"`

	// READ-ONLY; The name of the operation being performed on this particular object.
	Name *string `json:"name,omitempty" azure:"ro"`

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

	// READ-ONLY; Additional descriptions for the operation.
	Properties map[string]interface{} `json:"properties,omitempty" azure:"ro"`
}

Operation - SQL REST API operation definition.

type OperationDisplay 

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

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

	// READ-ONLY; The localized friendly form of the resource provider name.
	Provider *string `json:"provider,omitempty" azure:"ro"`

	// READ-ONLY; The localized friendly form of the resource type related to this action/operation.
	Resource *string `json:"resource,omitempty" azure:"ro"`
}

OperationDisplay - Display metadata associated with the operation.

type OperationListResult 

type OperationListResult struct {
	// READ-ONLY; Link to retrieve next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`

	// READ-ONLY; Array of results.
	Value []*Operation `json:"value,omitempty" azure:"ro"`
}

OperationListResult - Result of the request to list SQL operations.

type OperationOrigin 

type OperationOrigin string

OperationOrigin - The intended executor of the operation. 

const (
	OperationOriginSystem OperationOrigin = "system"
	OperationOriginUser   OperationOrigin = "user"
)

func PossibleOperationOriginValues 

func PossibleOperationOriginValues() []OperationOrigin

PossibleOperationOriginValues returns the possible values for the OperationOrigin const type.

type OperationsClient 

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

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

func NewOperationsClient 

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

NewOperationsClient creates a new instance of OperationsClient with the specified values. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*OperationsClient) NewListPager added in v0.4.0 

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

NewListPager - Lists all of the available SQL Virtual Machine Rest API operations. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview options - OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListOperation.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

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

Output:

type OperationsClientListOptions added in v0.2.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.2.0 

type OperationsClientListResponse struct {
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type PrivateIPAddress 

type PrivateIPAddress struct {
	// Private IP address bound to the availability group listener.
	IPAddress *string `json:"ipAddress,omitempty"`

	// Subnet used to include private IP.
	SubnetResourceID *string `json:"subnetResourceId,omitempty"`
}

PrivateIPAddress - A private IP address bound to the availability group listener.

type Properties added in v0.2.0 

type Properties struct {
	// Assessment Settings.
	AssessmentSettings *AssessmentSettings `json:"assessmentSettings,omitempty"`

	// Auto backup settings for SQL Server.
	AutoBackupSettings *AutoBackupSettings `json:"autoBackupSettings,omitempty"`

	// Auto patching settings for applying critical security updates to SQL virtual machine.
	AutoPatchingSettings *AutoPatchingSettings `json:"autoPatchingSettings,omitempty"`

	// Key vault credential settings.
	KeyVaultCredentialSettings *KeyVaultCredentialSettings `json:"keyVaultCredentialSettings,omitempty"`

	// SQL image offer. Examples include SQL2016-WS2016, SQL2017-WS2016.
	SQLImageOffer *string `json:"sqlImageOffer,omitempty"`

	// SQL Server edition type.
	SQLImageSKU *SQLImageSKU `json:"sqlImageSku,omitempty"`

	// SQL Server Management type.
	SQLManagement *SQLManagementMode `json:"sqlManagement,omitempty"`

	// SQL Server license type.
	SQLServerLicenseType *SQLServerLicenseType `json:"sqlServerLicenseType,omitempty"`

	// ARM resource id of the SQL virtual machine group this SQL virtual machine is or will be part of.
	SQLVirtualMachineGroupResourceID *string `json:"sqlVirtualMachineGroupResourceId,omitempty"`

	// SQL Server configuration management settings.
	ServerConfigurationsManagementSettings *ServerConfigurationsManagementSettings `json:"serverConfigurationsManagementSettings,omitempty"`

	// Storage Configuration Settings.
	StorageConfigurationSettings *StorageConfigurationSettings `json:"storageConfigurationSettings,omitempty"`

	// ARM Resource id of underlying virtual machine created from SQL marketplace image.
	VirtualMachineResourceID *string `json:"virtualMachineResourceId,omitempty"`

	// Domain credentials for setting up Windows Server Failover Cluster for SQL availability group.
	WsfcDomainCredentials *WsfcDomainCredentials `json:"wsfcDomainCredentials,omitempty"`

	// READ-ONLY; Provisioning state to track the async operation status.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

Properties - The SQL virtual machine properties.

type ProxyResource 

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

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

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

ProxyResource - ARM proxy resource.

type ReadableSecondary added in v0.3.0 

type ReadableSecondary string

ReadableSecondary - Replica readable secondary mode in availability group. 

const (
	ReadableSecondaryALL      ReadableSecondary = "ALL"
	ReadableSecondaryNO       ReadableSecondary = "NO"
	ReadableSecondaryREADONLY ReadableSecondary = "READ_ONLY"
)

func PossibleReadableSecondaryValues added in v0.3.0 

func PossibleReadableSecondaryValues() []ReadableSecondary

PossibleReadableSecondaryValues returns the possible values for the ReadableSecondary const type.

type Resource 

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

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

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

Resource - ARM resource.

type ResourceIdentity 

type ResourceIdentity struct {
	// The identity type. Set this to 'SystemAssigned' in order to automatically create and assign an Azure Active Directory principal
	// for the resource.
	Type *IdentityType `json:"type,omitempty"`

	// READ-ONLY; The Azure Active Directory principal id.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`

	// READ-ONLY; The Azure Active Directory tenant id.
	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
}

ResourceIdentity - Azure Active Directory identity configuration for a resource.

type Role added in v0.3.0 

type Role string

Role - Replica Role in availability group. 

const (
	RolePRIMARY   Role = "PRIMARY"
	RoleSECONDARY Role = "SECONDARY"
)

func PossibleRoleValues added in v0.3.0 

func PossibleRoleValues() []Role

PossibleRoleValues returns the possible values for the Role const type.

type SQLConnectivityUpdateSettings 

type SQLConnectivityUpdateSettings struct {
	// SQL Server connectivity option.
	ConnectivityType *ConnectivityType `json:"connectivityType,omitempty"`

	// SQL Server port.
	Port *int32 `json:"port,omitempty"`

	// SQL Server sysadmin login password.
	SQLAuthUpdatePassword *string `json:"sqlAuthUpdatePassword,omitempty"`

	// SQL Server sysadmin login to create.
	SQLAuthUpdateUserName *string `json:"sqlAuthUpdateUserName,omitempty"`
}

SQLConnectivityUpdateSettings - Set the access level and network port settings for SQL Server.

type SQLImageSKU 

type SQLImageSKU string

SQLImageSKU - SQL Server edition type. 

const (
	SQLImageSKUDeveloper  SQLImageSKU = "Developer"
	SQLImageSKUEnterprise SQLImageSKU = "Enterprise"
	SQLImageSKUExpress    SQLImageSKU = "Express"
	SQLImageSKUStandard   SQLImageSKU = "Standard"
	SQLImageSKUWeb        SQLImageSKU = "Web"
)

func PossibleSQLImageSKUValues 

func PossibleSQLImageSKUValues() []SQLImageSKU

PossibleSQLImageSKUValues returns the possible values for the SQLImageSKU const type.

type SQLInstanceSettings added in v0.3.0 

type SQLInstanceSettings struct {
	// SQL Server Collation.
	Collation *string `json:"collation,omitempty"`

	// SQL Server Optimize for Adhoc workloads.
	IsOptimizeForAdHocWorkloadsEnabled *bool `json:"isOptimizeForAdHocWorkloadsEnabled,omitempty"`

	// SQL Server MAXDOP.
	MaxDop *int32 `json:"maxDop,omitempty"`

	// SQL Server maximum memory.
	MaxServerMemoryMB *int32 `json:"maxServerMemoryMB,omitempty"`

	// SQL Server minimum memory.
	MinServerMemoryMB *int32 `json:"minServerMemoryMB,omitempty"`
}

SQLInstanceSettings - Set the server/instance-level settings for SQL Server.

type SQLManagementMode 

type SQLManagementMode string

SQLManagementMode - SQL Server Management type. 

const (
	SQLManagementModeFull        SQLManagementMode = "Full"
	SQLManagementModeLightWeight SQLManagementMode = "LightWeight"
	SQLManagementModeNoAgent     SQLManagementMode = "NoAgent"
)

func PossibleSQLManagementModeValues 

func PossibleSQLManagementModeValues() []SQLManagementMode

PossibleSQLManagementModeValues returns the possible values for the SQLManagementMode const type.

type SQLServerLicenseType 

type SQLServerLicenseType string

SQLServerLicenseType - SQL Server license type. 

const (
	SQLServerLicenseTypeAHUB SQLServerLicenseType = "AHUB"
	SQLServerLicenseTypeDR   SQLServerLicenseType = "DR"
	SQLServerLicenseTypePAYG SQLServerLicenseType = "PAYG"
)

func PossibleSQLServerLicenseTypeValues 

func PossibleSQLServerLicenseTypeValues() []SQLServerLicenseType

PossibleSQLServerLicenseTypeValues returns the possible values for the SQLServerLicenseType const type.

type SQLStorageSettings 

type SQLStorageSettings struct {
	// SQL Server default file path
	DefaultFilePath *string `json:"defaultFilePath,omitempty"`

	// Logical Unit Numbers for the disks.
	Luns []*int32 `json:"luns,omitempty"`
}

SQLStorageSettings - Set disk storage settings for SQL Server.

func (SQLStorageSettings) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SQLStorageSettings.

type SQLStorageUpdateSettings 

type SQLStorageUpdateSettings struct {
	// Disk configuration to apply to SQL Server.
	DiskConfigurationType *DiskConfigurationType `json:"diskConfigurationType,omitempty"`

	// Virtual machine disk count.
	DiskCount *int32 `json:"diskCount,omitempty"`

	// Device id of the first disk to be updated.
	StartingDeviceID *int32 `json:"startingDeviceId,omitempty"`
}

SQLStorageUpdateSettings - Set disk storage settings for SQL Server.

type SQLTempDbSettings added in v0.3.0 

type SQLTempDbSettings struct {
	// SQL Server default file count
	DataFileCount *int32 `json:"dataFileCount,omitempty"`

	// SQL Server default file size
	DataFileSize *int32 `json:"dataFileSize,omitempty"`

	// SQL Server default file autoGrowth size
	DataGrowth *int32 `json:"dataGrowth,omitempty"`

	// SQL Server default file path
	DefaultFilePath *string `json:"defaultFilePath,omitempty"`

	// SQL Server default file size
	LogFileSize *int32 `json:"logFileSize,omitempty"`

	// SQL Server default file autoGrowth size
	LogGrowth *int32 `json:"logGrowth,omitempty"`

	// Logical Unit Numbers for the disks.
	Luns []*int32 `json:"luns,omitempty"`
}

func (SQLTempDbSettings) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SQLTempDbSettings.

type SQLVMGroupImageSKU 

type SQLVMGroupImageSKU string

SQLVMGroupImageSKU - SQL image sku. 

const (
	SQLVMGroupImageSKUDeveloper  SQLVMGroupImageSKU = "Developer"
	SQLVMGroupImageSKUEnterprise SQLVMGroupImageSKU = "Enterprise"
)

func PossibleSQLVMGroupImageSKUValues 

func PossibleSQLVMGroupImageSKUValues() []SQLVMGroupImageSKU

PossibleSQLVMGroupImageSKUValues returns the possible values for the SQLVMGroupImageSKU const type.

type SQLVirtualMachine 

type SQLVirtualMachine struct {
	// REQUIRED; Resource location.
	Location *string `json:"location,omitempty"`

	// Azure Active Directory identity of the server.
	Identity *ResourceIdentity `json:"identity,omitempty"`

	// Resource properties.
	Properties *Properties `json:"properties,omitempty"`

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

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

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

	// READ-ONLY; Metadata pertaining to creation and last modification of the resource.
	SystemData *SystemData `json:"systemData,omitempty" azure:"ro"`

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

SQLVirtualMachine - A SQL virtual machine.

func (SQLVirtualMachine) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SQLVirtualMachine.

type SQLVirtualMachinesClient 

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

SQLVirtualMachinesClient contains the methods for the SQLVirtualMachines group. Don't use this type directly, use NewSQLVirtualMachinesClient() instead.

func NewSQLVirtualMachinesClient 

func NewSQLVirtualMachinesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*SQLVirtualMachinesClient, error)

NewSQLVirtualMachinesClient creates a new instance of SQLVirtualMachinesClient with the specified values. subscriptionID - Subscription ID that identifies an Azure subscription. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*SQLVirtualMachinesClient) BeginCreateOrUpdate 

func (client *SQLVirtualMachinesClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, parameters SQLVirtualMachine, options *SQLVirtualMachinesClientBeginCreateOrUpdateOptions) (*runtime.Poller[SQLVirtualMachinesClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - Creates or updates a SQL virtual machine. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. parameters - The SQL virtual machine. options - SQLVirtualMachinesClientBeginCreateOrUpdateOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginCreateOrUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/CreateOrUpdateVirtualMachineWithVMGroup.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreateOrUpdate(ctx,
		"testrg",
		"testvm",
		armsqlvirtualmachine.SQLVirtualMachine{
			Location: to.Ptr("northeurope"),
			Properties: &armsqlvirtualmachine.Properties{
				SQLVirtualMachineGroupResourceID: to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.SqlVirtualMachine/sqlVirtualMachineGroups/testvmgroup"),
				VirtualMachineResourceID:         to.Ptr("/subscriptions/00000000-1111-2222-3333-444444444444/resourceGroups/testrg/providers/Microsoft.Compute/virtualMachines/testvm2"),
				WsfcDomainCredentials: &armsqlvirtualmachine.WsfcDomainCredentials{
					ClusterBootstrapAccountPassword: to.Ptr("<Password>"),
					ClusterOperatorAccountPassword:  to.Ptr("<Password>"),
					SQLServiceAccountPassword:       to.Ptr("<Password>"),
				},
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*SQLVirtualMachinesClient) BeginDelete 

func (client *SQLVirtualMachinesClient) BeginDelete(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, options *SQLVirtualMachinesClientBeginDeleteOptions) (*runtime.Poller[SQLVirtualMachinesClientDeleteResponse], error)

BeginDelete - Deletes a SQL virtual machine. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. options - SQLVirtualMachinesClientBeginDeleteOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginDelete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/DeleteSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(ctx,
		"testrg",
		"testvm1",
		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 (*SQLVirtualMachinesClient) BeginRedeploy added in v0.3.0 

func (client *SQLVirtualMachinesClient) BeginRedeploy(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, options *SQLVirtualMachinesClientBeginRedeployOptions) (*runtime.Poller[SQLVirtualMachinesClientRedeployResponse], error)

BeginRedeploy - Uninstalls and reinstalls the SQL Iaas Extension. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. options - SQLVirtualMachinesClientBeginRedeployOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginRedeploy method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/RedeploySqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginRedeploy(ctx,
		"testrg",
		"testvm",
		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 (*SQLVirtualMachinesClient) BeginStartAssessment added in v0.3.0 

func (client *SQLVirtualMachinesClient) BeginStartAssessment(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, options *SQLVirtualMachinesClientBeginStartAssessmentOptions) (*runtime.Poller[SQLVirtualMachinesClientStartAssessmentResponse], error)

BeginStartAssessment - Starts Assessment on SQL virtual machine. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. options - SQLVirtualMachinesClientBeginStartAssessmentOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginStartAssessment method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/StartAssessmentOnSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginStartAssessment(ctx,
		"testrg",
		"testvm",
		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 (*SQLVirtualMachinesClient) BeginUpdate 

func (client *SQLVirtualMachinesClient) BeginUpdate(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, parameters Update, options *SQLVirtualMachinesClientBeginUpdateOptions) (*runtime.Poller[SQLVirtualMachinesClientUpdateResponse], error)

BeginUpdate - Updates a SQL virtual machine. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. parameters - The SQL virtual machine. options - SQLVirtualMachinesClientBeginUpdateOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/UpdateSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

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

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginUpdate(ctx,
		"testrg",
		"testvm",
		armsqlvirtualmachine.Update{
			Tags: map[string]*string{
				"mytag": to.Ptr("myval"),
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*SQLVirtualMachinesClient) Get 

func (client *SQLVirtualMachinesClient) Get(ctx context.Context, resourceGroupName string, sqlVirtualMachineName string, options *SQLVirtualMachinesClientGetOptions) (SQLVirtualMachinesClientGetResponse, error)

Get - Gets a SQL virtual machine. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineName - Name of the SQL virtual machine. options - SQLVirtualMachinesClientGetOptions contains the optional parameters for the SQLVirtualMachinesClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/GetSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"testrg",
		"testvm",
		&armsqlvirtualmachine.SQLVirtualMachinesClientGetOptions{Expand: nil})
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*SQLVirtualMachinesClient) NewListByResourceGroupPager added in v0.4.0 

func (client *SQLVirtualMachinesClient) NewListByResourceGroupPager(resourceGroupName string, options *SQLVirtualMachinesClientListByResourceGroupOptions) *runtime.Pager[SQLVirtualMachinesClientListByResourceGroupResponse]

NewListByResourceGroupPager - Gets all SQL virtual machines in a resource group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. options - SQLVirtualMachinesClientListByResourceGroupOptions contains the optional parameters for the SQLVirtualMachinesClient.ListByResourceGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListByResourceGroupSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armsqlvirtualmachine.NewSQLVirtualMachinesClient("00000000-1111-2222-3333-444444444444", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByResourceGroupPager("testrg",
		nil)
	for pager.More() {
		nextResult, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range nextResult.Value {
			// TODO: use page item
			_ = v
		}
	}
}

Output:

func (*SQLVirtualMachinesClient) NewListBySQLVMGroupPager added in v0.4.0 

func (client *SQLVirtualMachinesClient) NewListBySQLVMGroupPager(resourceGroupName string, sqlVirtualMachineGroupName string, options *SQLVirtualMachinesClientListBySQLVMGroupOptions) *runtime.Pager[SQLVirtualMachinesClientListBySQLVMGroupResponse]

NewListBySQLVMGroupPager - Gets the list of sql virtual machines in a SQL virtual machine group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview resourceGroupName - Name of the resource group that contains the resource. You can obtain this value from the Azure Resource Manager API or the portal. sqlVirtualMachineGroupName - Name of the SQL virtual machine group. options - SQLVirtualMachinesClientListBySQLVMGroupOptions contains the optional parameters for the SQLVirtualMachinesClient.ListBySQLVMGroup method.

func (*SQLVirtualMachinesClient) NewListPager added in v0.4.0 

func (client *SQLVirtualMachinesClient) NewListPager(options *SQLVirtualMachinesClientListOptions) *runtime.Pager[SQLVirtualMachinesClientListResponse]

NewListPager - Gets all SQL virtual machines in a subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-11-01-preview options - SQLVirtualMachinesClientListOptions contains the optional parameters for the SQLVirtualMachinesClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/sqlvirtualmachine/resource-manager/Microsoft.SqlVirtualMachine/preview/2021-11-01-preview/examples/ListSubscriptionSqlVirtualMachine.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/sqlvirtualmachine/armsqlvirtualmachine"
)

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

Output:

type SQLVirtualMachinesClientBeginCreateOrUpdateOptions added in v0.2.0 

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

SQLVirtualMachinesClientBeginCreateOrUpdateOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginCreateOrUpdate method.

type SQLVirtualMachinesClientBeginDeleteOptions added in v0.2.0 

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

SQLVirtualMachinesClientBeginDeleteOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginDelete method.

type SQLVirtualMachinesClientBeginRedeployOptions added in v0.3.0 

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

SQLVirtualMachinesClientBeginRedeployOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginRedeploy method.

type SQLVirtualMachinesClientBeginStartAssessmentOptions added in v0.3.0 

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

SQLVirtualMachinesClientBeginStartAssessmentOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginStartAssessment method.

type SQLVirtualMachinesClientBeginUpdateOptions added in v0.2.0 

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

SQLVirtualMachinesClientBeginUpdateOptions contains the optional parameters for the SQLVirtualMachinesClient.BeginUpdate method.

type SQLVirtualMachinesClientCreateOrUpdateResponse added in v0.2.0 

type SQLVirtualMachinesClientCreateOrUpdateResponse struct {
	SQLVirtualMachine
}

SQLVirtualMachinesClientCreateOrUpdateResponse contains the response from method SQLVirtualMachinesClient.CreateOrUpdate.

type SQLVirtualMachinesClientDeleteResponse added in v0.2.0 

type SQLVirtualMachinesClientDeleteResponse struct {
}

SQLVirtualMachinesClientDeleteResponse contains the response from method SQLVirtualMachinesClient.Delete.

type SQLVirtualMachinesClientGetOptions added in v0.2.0 

type SQLVirtualMachinesClientGetOptions struct {
	// The child resources to include in the response.
	Expand *string
}

SQLVirtualMachinesClientGetOptions contains the optional parameters for the SQLVirtualMachinesClient.Get method.

type SQLVirtualMachinesClientGetResponse added in v0.2.0 

type SQLVirtualMachinesClientGetResponse struct {
	SQLVirtualMachine
}

SQLVirtualMachinesClientGetResponse contains the response from method SQLVirtualMachinesClient.Get.

type SQLVirtualMachinesClientListByResourceGroupOptions added in v0.2.0 

type SQLVirtualMachinesClientListByResourceGroupOptions struct {
}

SQLVirtualMachinesClientListByResourceGroupOptions contains the optional parameters for the SQLVirtualMachinesClient.ListByResourceGroup method.

type SQLVirtualMachinesClientListByResourceGroupResponse added in v0.2.0 

type SQLVirtualMachinesClientListByResourceGroupResponse struct {
	ListResult
}

SQLVirtualMachinesClientListByResourceGroupResponse contains the response from method SQLVirtualMachinesClient.ListByResourceGroup.

type SQLVirtualMachinesClientListBySQLVMGroupOptions added in v0.2.0 

type SQLVirtualMachinesClientListBySQLVMGroupOptions struct {
}

SQLVirtualMachinesClientListBySQLVMGroupOptions contains the optional parameters for the SQLVirtualMachinesClient.ListBySQLVMGroup method.

type SQLVirtualMachinesClientListBySQLVMGroupResponse added in v0.2.0 

type SQLVirtualMachinesClientListBySQLVMGroupResponse struct {
	ListResult
}

SQLVirtualMachinesClientListBySQLVMGroupResponse contains the response from method SQLVirtualMachinesClient.ListBySQLVMGroup.

type SQLVirtualMachinesClientListOptions added in v0.2.0 

type SQLVirtualMachinesClientListOptions struct {
}

SQLVirtualMachinesClientListOptions contains the optional parameters for the SQLVirtualMachinesClient.List method.

type SQLVirtualMachinesClientListResponse added in v0.2.0 

type SQLVirtualMachinesClientListResponse struct {
	ListResult
}

SQLVirtualMachinesClientListResponse contains the response from method SQLVirtualMachinesClient.List.

type SQLVirtualMachinesClientRedeployResponse added in v0.3.0 

type SQLVirtualMachinesClientRedeployResponse struct {
}

SQLVirtualMachinesClientRedeployResponse contains the response from method SQLVirtualMachinesClient.Redeploy.

type SQLVirtualMachinesClientStartAssessmentResponse added in v0.3.0 

type SQLVirtualMachinesClientStartAssessmentResponse struct {
}

SQLVirtualMachinesClientStartAssessmentResponse contains the response from method SQLVirtualMachinesClient.StartAssessment.

type SQLVirtualMachinesClientUpdateResponse added in v0.2.0 

type SQLVirtualMachinesClientUpdateResponse struct {
	SQLVirtualMachine
}

SQLVirtualMachinesClientUpdateResponse contains the response from method SQLVirtualMachinesClient.Update.

type SQLWorkloadType 

type SQLWorkloadType string

SQLWorkloadType - SQL Server workload type. 

const (
	SQLWorkloadTypeDW      SQLWorkloadType = "DW"
	SQLWorkloadTypeGENERAL SQLWorkloadType = "GENERAL"
	SQLWorkloadTypeOLTP    SQLWorkloadType = "OLTP"
)

func PossibleSQLWorkloadTypeValues 

func PossibleSQLWorkloadTypeValues() []SQLWorkloadType

PossibleSQLWorkloadTypeValues returns the possible values for the SQLWorkloadType const type.

type SQLWorkloadTypeUpdateSettings 

type SQLWorkloadTypeUpdateSettings struct {
	// SQL Server workload type.
	SQLWorkloadType *SQLWorkloadType `json:"sqlWorkloadType,omitempty"`
}

SQLWorkloadTypeUpdateSettings - Set workload type to optimize storage for SQL Server.

type ScaleType 

type ScaleType string

ScaleType - Scale type. 

const (
	ScaleTypeHA ScaleType = "HA"
)

func PossibleScaleTypeValues 

func PossibleScaleTypeValues() []ScaleType

PossibleScaleTypeValues returns the possible values for the ScaleType const type.

type Schedule added in v0.3.0 

type Schedule struct {
	// Day of the week to run assessment.
	DayOfWeek *AssessmentDayOfWeek `json:"dayOfWeek,omitempty"`

	// Enable or disable assessment schedule on SQL virtual machine.
	Enable *bool `json:"enable,omitempty"`

	// Occurrence of the DayOfWeek day within a month to schedule assessment. Takes values: 1,2,3,4 and -1. Use -1 for last DayOfWeek
	// day of the month
	MonthlyOccurrence *int32 `json:"monthlyOccurrence,omitempty"`

	// Time of the day in HH:mm format. Eg. 17:30
	StartTime *string `json:"startTime,omitempty"`

	// Number of weeks to schedule between 2 assessment runs. Takes value from 1-6
	WeeklyInterval *int32 `json:"weeklyInterval,omitempty"`
}

type ServerConfigurationsManagementSettings 

type ServerConfigurationsManagementSettings struct {
	// Additional SQL feature settings.
	AdditionalFeaturesServerConfigurations *AdditionalFeaturesServerConfigurations `json:"additionalFeaturesServerConfigurations,omitempty"`

	// SQL connectivity type settings.
	SQLConnectivityUpdateSettings *SQLConnectivityUpdateSettings `json:"sqlConnectivityUpdateSettings,omitempty"`

	// SQL Instance settings.
	SQLInstanceSettings *SQLInstanceSettings `json:"sqlInstanceSettings,omitempty"`

	// SQL storage update settings.
	SQLStorageUpdateSettings *SQLStorageUpdateSettings `json:"sqlStorageUpdateSettings,omitempty"`

	// SQL workload type settings.
	SQLWorkloadTypeUpdateSettings *SQLWorkloadTypeUpdateSettings `json:"sqlWorkloadTypeUpdateSettings,omitempty"`
}

ServerConfigurationsManagementSettings - Set the connectivity, storage and workload settings.

type StorageConfigurationSettings 

type StorageConfigurationSettings struct {
	// Disk configuration to apply to SQL Server.
	DiskConfigurationType *DiskConfigurationType `json:"diskConfigurationType,omitempty"`

	// SQL Server Data Storage Settings.
	SQLDataSettings *SQLStorageSettings `json:"sqlDataSettings,omitempty"`

	// SQL Server Log Storage Settings.
	SQLLogSettings *SQLStorageSettings `json:"sqlLogSettings,omitempty"`

	// SQL Server SystemDb Storage on DataPool if true.
	SQLSystemDbOnDataDisk *bool `json:"sqlSystemDbOnDataDisk,omitempty"`

	// SQL Server TempDb Storage Settings.
	SQLTempDbSettings *SQLTempDbSettings `json:"sqlTempDbSettings,omitempty"`

	// Storage workload type.
	StorageWorkloadType *StorageWorkloadType `json:"storageWorkloadType,omitempty"`
}

StorageConfigurationSettings - Storage Configurations for SQL Data, Log and TempDb.

type StorageWorkloadType 

type StorageWorkloadType string

StorageWorkloadType - Storage workload type. 

const (
	StorageWorkloadTypeDW      StorageWorkloadType = "DW"
	StorageWorkloadTypeGENERAL StorageWorkloadType = "GENERAL"
	StorageWorkloadTypeOLTP    StorageWorkloadType = "OLTP"
)

func PossibleStorageWorkloadTypeValues 

func PossibleStorageWorkloadTypeValues() []StorageWorkloadType

PossibleStorageWorkloadTypeValues returns the possible values for the StorageWorkloadType const type.

type SystemData added in v0.3.0 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON added in v0.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; Resource location.
	Location *string `json:"location,omitempty"`

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

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

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

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

TrackedResource - ARM tracked top level resource.

func (TrackedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

type Update added in v0.2.0 

type Update struct {
	// Resource tags.
	Tags map[string]*string `json:"tags,omitempty"`
}

Update - An update to a SQL virtual machine.

func (Update) MarshalJSON added in v0.2.0 

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

MarshalJSON implements the json.Marshaller interface for type Update.

type WsfcDomainCredentials 

type WsfcDomainCredentials struct {
	// Cluster bootstrap account password.
	ClusterBootstrapAccountPassword *string `json:"clusterBootstrapAccountPassword,omitempty"`

	// Cluster operator account password.
	ClusterOperatorAccountPassword *string `json:"clusterOperatorAccountPassword,omitempty"`

	// SQL service account password.
	SQLServiceAccountPassword *string `json:"sqlServiceAccountPassword,omitempty"`
}

WsfcDomainCredentials - Domain credentials for setting up Windows Server Failover Cluster for SQL availability group.

type WsfcDomainProfile 

type WsfcDomainProfile struct {
	// Account name used for creating cluster (at minimum needs permissions to 'Create Computer Objects' in domain).
	ClusterBootstrapAccount *string `json:"clusterBootstrapAccount,omitempty"`

	// Account name used for operating cluster i.e. will be part of administrators group on all the participating virtual machines
	// in the cluster.
	ClusterOperatorAccount *string `json:"clusterOperatorAccount,omitempty"`

	// Fully qualified name of the domain.
	DomainFqdn *string `json:"domainFqdn,omitempty"`

	// Optional path for fileshare witness.
	FileShareWitnessPath *string `json:"fileShareWitnessPath,omitempty"`

	// Organizational Unit path in which the nodes and cluster will be present.
	OuPath *string `json:"ouPath,omitempty"`

	// Account name under which SQL service will run on all participating SQL virtual machines in the cluster.
	SQLServiceAccount *string `json:"sqlServiceAccount,omitempty"`

	// Primary key of the witness storage account.
	StorageAccountPrimaryKey *string `json:"storageAccountPrimaryKey,omitempty"`

	// Fully qualified ARM resource id of the witness storage account.
	StorageAccountURL *string `json:"storageAccountUrl,omitempty"`
}

WsfcDomainProfile - Active Directory account details to operate Windows Server Failover Cluster.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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