armfluidrelay

package module
v1.2.0 Latest Latest
Warning

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

 Go to latest Published: Nov 24, 2023 License: MIT Imports: 14 Imported by: 2

README

Azure Fluidrelay Module for Go

PkgGoDev

The armfluidrelay module provides operations for working with Azure Fluidrelay.

Source code

Getting started

Prerequisites

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

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Fluidrelay module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay

Authorization

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

cred, err := azidentity.NewDefaultAzureCredential(nil)

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

Client Factory

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

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

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

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

Clients

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

client := clientFactory.NewServersClient()

Fakes

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

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

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Fluidrelay 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 ClientFactory added in v1.1.0 

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

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

func NewClientFactory added in v1.1.0 

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

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

  • subscriptionID - The subscription id (GUID) for this resource.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ClientFactory) NewContainersClient added in v1.1.0 

func (c *ClientFactory) NewContainersClient() *ContainersClient

NewContainersClient creates a new instance of ContainersClient.

func (*ClientFactory) NewOperationsClient added in v1.1.0 

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewServersClient added in v1.1.0 

func (c *ClientFactory) NewServersClient() *ServersClient

NewServersClient creates a new instance of ServersClient.

type CmkIdentityType 

type CmkIdentityType string

CmkIdentityType - Values can be SystemAssigned or UserAssigned 

const (
	CmkIdentityTypeSystemAssigned CmkIdentityType = "SystemAssigned"
	CmkIdentityTypeUserAssigned   CmkIdentityType = "UserAssigned"
)

func PossibleCmkIdentityTypeValues 

func PossibleCmkIdentityTypeValues() []CmkIdentityType

PossibleCmkIdentityTypeValues returns the possible values for the CmkIdentityType const type.

type Container 

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

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

	// READ-ONLY; The resource-specific properties for this resource.
	Properties *ContainerProperties

	// READ-ONLY; System meta data for this resource, including creation and modification information.
	SystemData *SystemData

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

Container - A FluidRelay Container.

func (Container) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Container.

func (*Container) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Container.

type ContainerList 

type ContainerList struct {
	// A sequence of FluidRelay containers.
	Value []*Container

	// READ-ONLY; A link to the next page of results, if any.
	NextLink *string
}

ContainerList - Paged response

func (ContainerList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ContainerList.

func (*ContainerList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ContainerList.

type ContainerProperties 

type ContainerProperties struct {
	// READ-ONLY; The creation time of this resource
	CreationTime *time.Time

	// READ-ONLY; The frsContainerId for this container
	FrsContainerID *string

	// READ-ONLY; The Fluid tenantId for this container
	FrsTenantID *string

	// READ-ONLY; Last time when user access this resource
	LastAccessTime *time.Time

	// READ-ONLY; Provision states for FluidRelay RP
	ProvisioningState *ProvisioningState
}

ContainerProperties - The properties of a Fluid Relay Container resource.

func (ContainerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ContainerProperties.

func (*ContainerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ContainerProperties.

type ContainersClient 

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

ContainersClient contains the methods for the FluidRelayContainers group. Don't use this type directly, use NewContainersClient() instead.

func NewContainersClient 

func NewContainersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ContainersClient, error)

NewContainersClient creates a new instance of ContainersClient with the specified values.

  • subscriptionID - The subscription id (GUID) for this resource.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ContainersClient) Delete 

func (client *ContainersClient) Delete(ctx context.Context, resourceGroup string, fluidRelayServerName string, fluidRelayContainerName string, options *ContainersClientDeleteOptions) (ContainersClientDeleteResponse, error)

Delete - Delete a Fluid Relay container. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • fluidRelayContainerName - The Fluid Relay container resource name.
  • options - ContainersClientDeleteOptions contains the optional parameters for the ContainersClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayContainers_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewContainersClient().Delete(ctx, "myResourceGroup", "myFluidRelayServer", "myFluidRelayContainer", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ContainersClient) Get 

func (client *ContainersClient) Get(ctx context.Context, resourceGroup string, fluidRelayServerName string, fluidRelayContainerName string, options *ContainersClientGetOptions) (ContainersClientGetResponse, error)

Get - Get a Fluid Relay container. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • fluidRelayContainerName - The Fluid Relay container resource name.
  • options - ContainersClientGetOptions contains the optional parameters for the ContainersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayContainers_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewContainersClient().Get(ctx, "myResourceGroup", "myFluidRelayServer", "myFluidRelayContainer", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Container = armfluidrelay.Container{
	// 	Name: to.Ptr("myFluidRelayContainer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers/fluidRelayContainers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer/fluidRelayContainers/myFluidRelayContainer"),
	// 	Properties: &armfluidrelay.ContainerProperties{
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-21T02:17:01.164Z"); return t}()),
	// 		FrsContainerID: to.Ptr("xxxx-yyyy-xxxxx-yyyy"),
	// 		FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 		LastAccessTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-21T02:17:01.164Z"); return t}()),
	// 		ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 	},
	// }
}

Output:

func (*ContainersClient) NewListByFluidRelayServersPager 

func (client *ContainersClient) NewListByFluidRelayServersPager(resourceGroup string, fluidRelayServerName string, options *ContainersClientListByFluidRelayServersOptions) *runtime.Pager[ContainersClientListByFluidRelayServersResponse]

NewListByFluidRelayServersPager - List all Fluid Relay containers which are children of a given Fluid Relay server.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • options - ContainersClientListByFluidRelayServersOptions contains the optional parameters for the ContainersClient.NewListByFluidRelayServersPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayContainers_ListByFluidRelayServer.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewContainersClient().NewListByFluidRelayServersPager("myResourceGroup", "myFluidRelayServer", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ContainerList = armfluidrelay.ContainerList{
		// 	Value: []*armfluidrelay.Container{
		// 		{
		// 			Name: to.Ptr("myFluidRelayContainer"),
		// 			Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers/fluidRelayContainers"),
		// 			ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer/fluidRelayContainers/myFluidRelayContainer"),
		// 			Properties: &armfluidrelay.ContainerProperties{
		// 				CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-21T02:17:01.164Z"); return t}()),
		// 				FrsContainerID: to.Ptr("xxxx-yyyy-xxxxx-yyyy"),
		// 				FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
		// 				LastAccessTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-04-21T02:17:01.164Z"); return t}()),
		// 				ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
		// 			},
		// 	}},
		// }
	}
}

Output:

type ContainersClientDeleteOptions 

type ContainersClientDeleteOptions struct {
}

ContainersClientDeleteOptions contains the optional parameters for the ContainersClient.Delete method.

type ContainersClientDeleteResponse 

type ContainersClientDeleteResponse struct {
}

ContainersClientDeleteResponse contains the response from method ContainersClient.Delete.

type ContainersClientGetOptions 

type ContainersClientGetOptions struct {
}

ContainersClientGetOptions contains the optional parameters for the ContainersClient.Get method.

type ContainersClientGetResponse 

type ContainersClientGetResponse struct {
	// A FluidRelay Container.
	Container
}

ContainersClientGetResponse contains the response from method ContainersClient.Get.

type ContainersClientListByFluidRelayServersOptions 

type ContainersClientListByFluidRelayServersOptions struct {
}

ContainersClientListByFluidRelayServersOptions contains the optional parameters for the ContainersClient.NewListByFluidRelayServersPager method.

type ContainersClientListByFluidRelayServersResponse 

type ContainersClientListByFluidRelayServersResponse struct {
	// Paged response
	ContainerList
}

ContainersClientListByFluidRelayServersResponse contains the response from method ContainersClient.NewListByFluidRelayServersPager.

type CreatedByType 

type CreatedByType string

CreatedByType - The type of identity that created the resource. 

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

func PossibleCreatedByTypeValues 

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type CustomerManagedKeyEncryptionProperties 

type CustomerManagedKeyEncryptionProperties struct {
	// All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault.
	KeyEncryptionKeyIdentity *CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity

	// key encryption key Url, with or without a version. Ex: https://contosovault.vault.azure.net/keys/contosokek/562a4bb76b524a1493a6afe8e536ee78
	// or https://contosovault.vault.azure.net/keys/contosokek.
	// Key auto rotation is enabled by providing a key uri without version. Otherwise, customer is responsible for rotating the
	// key. The keyEncryptionKeyIdentity(either SystemAssigned or UserAssigned) should
	// have permission to access this key url.
	KeyEncryptionKeyURL *string
}

CustomerManagedKeyEncryptionProperties - All Customer-managed key encryption properties for the resource.

func (CustomerManagedKeyEncryptionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CustomerManagedKeyEncryptionProperties.

func (*CustomerManagedKeyEncryptionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CustomerManagedKeyEncryptionProperties.

type CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity 

type CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity struct {
	// Values can be SystemAssigned or UserAssigned
	IdentityType *CmkIdentityType

	// user assigned identity to use for accessing key encryption key Url. Ex: /subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/
	// /providers/Microsoft.ManagedIdentity/userAssignedIdentities/myId. Mutually exclusive with identityType systemAssignedIdentity.
	UserAssignedIdentityResourceID *string
}

CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity - All identity configuration for Customer-managed key settings defining which identity should be used to auth to Key Vault.

func (CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity.

func (*CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity.

type EncryptionProperties 

type EncryptionProperties struct {
	// All Customer-managed key encryption properties for the resource.
	CustomerManagedKeyEncryption *CustomerManagedKeyEncryptionProperties
}

EncryptionProperties - All encryption configuration for a resource.

func (EncryptionProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type EncryptionProperties.

func (*EncryptionProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type EncryptionProperties.

type Endpoints 

type Endpoints struct {
	// READ-ONLY; The Fluid Relay Orderer endpoints.
	OrdererEndpoints []*string

	// READ-ONLY; The Fluid Relay service endpoints.
	ServiceEndpoints []*string

	// READ-ONLY; The Fluid Relay storage endpoints.
	StorageEndpoints []*string
}

Endpoints - The Fluid Relay endpoints for this server

func (Endpoints) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Endpoints.

func (*Endpoints) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Endpoints.

type ErrorAdditionalInfo 

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

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

ErrorAdditionalInfo - The resource management error additional info.

func (ErrorAdditionalInfo) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorAdditionalInfo.

func (*ErrorAdditionalInfo) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorAdditionalInfo.

type ErrorDetail 

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

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

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

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

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

ErrorDetail - The error detail.

func (ErrorDetail) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorDetail.

func (*ErrorDetail) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorDetail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail
}

ErrorResponse - Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.).

func (ErrorResponse) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ErrorResponse.

func (*ErrorResponse) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.

type Identity 

type Identity struct {
	// The identity type.
	Type *ResourceIdentityType

	// The list of user identities associated with the resource.
	UserAssignedIdentities map[string]*UserAssignedIdentitiesValue

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

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

Identity for the resource.

func (Identity) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Identity.

func (*Identity) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Identity.

type KeyName 

type KeyName string

KeyName - The key to regenerate. 

const (
	KeyNameKey1 KeyName = "key1"
	KeyNameKey2 KeyName = "key2"
)

func PossibleKeyNameValues 

func PossibleKeyNameValues() []KeyName

PossibleKeyNameValues returns the possible values for the KeyName const type.

type OperationDisplay 

type OperationDisplay struct {
	// Description of the operation, e.g., 'Write confluent'.
	Description *string

	// Operation type, e.g., read, write, delete, etc.
	Operation *string

	// Service provider: Microsoft.FluidRelay
	Provider *string

	// Type on which the operation is performed, e.g., 'servers'.
	Resource *string
}

OperationDisplay - The object that represents the operation.

func (OperationDisplay) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationDisplay.

func (*OperationDisplay) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationDisplay.

type OperationListResult 

type OperationListResult struct {
	// URL to get the next set of operation list results if there are any.
	NextLink *string

	// List of FluidRelay operations supported by the Microsoft.FluidRelay provider.
	Value []*OperationResult
}

OperationListResult - Result of GET request to list FluidRelay operations.

func (OperationListResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationListResult.

func (*OperationListResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationListResult.

type OperationResult 

type OperationResult struct {
	// The object that represents the operation.
	Display *OperationDisplay

	// Indicates whether the operation is a data action
	IsDataAction *bool

	// Operation name: {provider}/{resource}/{operation}
	Name *string
}

OperationResult - A FluidRelay REST API operation.

func (OperationResult) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type OperationResult.

func (*OperationResult) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationResult.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

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

func (*OperationsClient) NewListPager 

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

NewListPager - List all operations provided by Microsoft.FluidRelay.

Generated from API version 2022-06-01

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

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServerOperations.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

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

Output:

type OperationsClientListOptions 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse 

type OperationsClientListResponse struct {
	// Result of GET request to list FluidRelay operations.
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - Provision states for FluidRelay RP 

const (
	ProvisioningStateCanceled  ProvisioningState = "Canceled"
	ProvisioningStateFailed    ProvisioningState = "Failed"
	ProvisioningStateSucceeded ProvisioningState = "Succeeded"
)

func PossibleProvisioningStateValues 

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type ProxyResource 

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

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

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

ProxyResource - The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location

func (ProxyResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ProxyResource.

func (*ProxyResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ProxyResource.

type RegenerateKeyRequest 

type RegenerateKeyRequest struct {
	// REQUIRED; The key to regenerate.
	KeyName *KeyName
}

RegenerateKeyRequest - Specifies which key should be generated.

func (RegenerateKeyRequest) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type RegenerateKeyRequest.

func (*RegenerateKeyRequest) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type RegenerateKeyRequest.

type Resource 

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

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

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

Resource - Common fields that are returned in the response for all Azure Resource Manager resources

func (Resource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Resource.

func (*Resource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Resource.

type ResourceIdentityType 

type ResourceIdentityType string

ResourceIdentityType - The identity type. 

const (
	ResourceIdentityTypeNone                       ResourceIdentityType = "None"
	ResourceIdentityTypeSystemAssigned             ResourceIdentityType = "SystemAssigned"
	ResourceIdentityTypeSystemAssignedUserAssigned ResourceIdentityType = "SystemAssigned, UserAssigned"
	ResourceIdentityTypeUserAssigned               ResourceIdentityType = "UserAssigned"
)

func PossibleResourceIdentityTypeValues 

func PossibleResourceIdentityTypeValues() []ResourceIdentityType

PossibleResourceIdentityTypeValues returns the possible values for the ResourceIdentityType const type.

type Server 

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

	// The type of identity used for the resource.
	Identity *Identity

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

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

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

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

	// READ-ONLY; System meta data for this resource, including creation and modification information.
	SystemData *SystemData

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

Server - A FluidRelay Server.

func (Server) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type Server.

func (*Server) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type Server.

type ServerKeys 

type ServerKeys struct {
	// READ-ONLY; The primary key for this server
	Key1 *string

	// READ-ONLY; The secondary key for this server
	Key2 *string
}

ServerKeys - The set of available keys for this server.

func (ServerKeys) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerKeys.

func (*ServerKeys) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerKeys.

type ServerList 

type ServerList struct {
	// REQUIRED; A sequence of FluidRelay servers.
	Value []*Server

	// A link to the next page of results, if any.
	NextLink *string
}

ServerList - Paged response

func (ServerList) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerList.

func (*ServerList) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerList.

type ServerProperties 

type ServerProperties struct {
	// All encryption configuration for a resource.
	Encryption *EncryptionProperties

	// Provision states for FluidRelay RP
	ProvisioningState *ProvisioningState

	// Sku of the storage associated with the resource
	Storagesku *StorageSKU

	// READ-ONLY; The Fluid Relay Service endpoints for this server.
	FluidRelayEndpoints *Endpoints

	// READ-ONLY; The Fluid tenantId for this server
	FrsTenantID *string
}

ServerProperties - The properties of a Fluid Relay Service resource.

func (ServerProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerProperties.

func (*ServerProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerProperties.

type ServerUpdate 

type ServerUpdate struct {
	// The type of identity used for the resource.
	Identity *Identity

	// The geo-location where the resource lives
	Location *string

	// The resource-specific properties that can be updated for this resource.
	Properties *ServerUpdateProperties

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

ServerUpdate - The updatable properties of a Fluid Relay server

func (ServerUpdate) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerUpdate.

func (*ServerUpdate) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerUpdate.

type ServerUpdateProperties 

type ServerUpdateProperties struct {
	// All encryption configuration for a resource.
	Encryption *EncryptionProperties
}

ServerUpdateProperties - The properties that can be provided when updating FluidRelayServer resource

func (ServerUpdateProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ServerUpdateProperties.

func (*ServerUpdateProperties) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type ServerUpdateProperties.

type ServersClient 

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

ServersClient contains the methods for the FluidRelayServers group. Don't use this type directly, use NewServersClient() instead.

func NewServersClient 

func NewServersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ServersClient, error)

NewServersClient creates a new instance of ServersClient with the specified values.

  • subscriptionID - The subscription id (GUID) for this resource.
  • credential - used to authorize requests. Usually a credential from azidentity.
  • options - pass nil to accept the default values.

func (*ServersClient) CreateOrUpdate 

func (client *ServersClient) CreateOrUpdate(ctx context.Context, resourceGroup string, fluidRelayServerName string, resource Server, options *ServersClientCreateOrUpdateOptions) (ServersClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create or Update a Fluid Relay server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • resource - The details of the Fluid Relay server resource.
  • options - ServersClientCreateOrUpdateOptions contains the optional parameters for the ServersClient.CreateOrUpdate method.
Example (CreateAFluidRelayServer)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_CreateOrUpdate.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/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().CreateOrUpdate(ctx, "myResourceGroup", "myFluidRelayServer", armfluidrelay.Server{
		Location: to.Ptr("west-us"),
		Tags: map[string]*string{
			"Category": to.Ptr("sales"),
		},
		Identity: &armfluidrelay.Identity{
			Type: to.Ptr(armfluidrelay.ResourceIdentityTypeSystemAssigned),
		},
		Properties: &armfluidrelay.ServerProperties{
			Storagesku: to.Ptr(armfluidrelay.StorageSKUBasic),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Server = armfluidrelay.Server{
	// 	Name: to.Ptr("myFluidRelayServer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
	// 	Location: to.Ptr("west-us"),
	// 	Identity: &armfluidrelay.Identity{
	// 		Type: to.Ptr(armfluidrelay.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 		TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 	},
	// 	Properties: &armfluidrelay.ServerProperties{
	// 		FluidRelayEndpoints: &armfluidrelay.Endpoints{
	// 			OrdererEndpoints: []*string{
	// 				to.Ptr("https://www.contoso.org/orderer")},
	// 				ServiceEndpoints: []*string{
	// 					to.Ptr("https://www.afd.contoso.org")},
	// 					StorageEndpoints: []*string{
	// 						to.Ptr("https://www.contoso.org/storage")},
	// 					},
	// 					FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 					ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 				},
	// 			}
}

Output:
Example (CreateAFluidRelayServerWithAmi)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_CreateWithAmi.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/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().CreateOrUpdate(ctx, "myResourceGroup", "myFluidRelayServer", armfluidrelay.Server{
		Location: to.Ptr("west-us"),
		Tags: map[string]*string{
			"Category": to.Ptr("sales"),
		},
		Identity: &armfluidrelay.Identity{
			Type: to.Ptr(armfluidrelay.ResourceIdentityTypeSystemAssignedUserAssigned),
			UserAssignedIdentities: map[string]*armfluidrelay.UserAssignedIdentitiesValue{
				"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {},
				"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": {},
			},
		},
		Properties: &armfluidrelay.ServerProperties{
			Storagesku: to.Ptr(armfluidrelay.StorageSKUBasic),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Server = armfluidrelay.Server{
	// 	Name: to.Ptr("myFluidRelayServer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
	// 	Location: to.Ptr("west-us"),
	// 	Identity: &armfluidrelay.Identity{
	// 		Type: to.Ptr(armfluidrelay.ResourceIdentityTypeSystemAssigned),
	// 		PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 		TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 		UserAssignedIdentities: map[string]*armfluidrelay.UserAssignedIdentitiesValue{
	// 			"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": &armfluidrelay.UserAssignedIdentitiesValue{
	// 				ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 			"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id2": &armfluidrelay.UserAssignedIdentitiesValue{
	// 				ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 		},
	// 	},
	// 	Properties: &armfluidrelay.ServerProperties{
	// 		FluidRelayEndpoints: &armfluidrelay.Endpoints{
	// 			OrdererEndpoints: []*string{
	// 				to.Ptr("https://www.contoso.org/orderer")},
	// 				ServiceEndpoints: []*string{
	// 					to.Ptr("https://www.afd.contoso.org")},
	// 					StorageEndpoints: []*string{
	// 						to.Ptr("https://www.contoso.org/storage")},
	// 					},
	// 					FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 					ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 				},
	// 			}
}

Output:
Example (CreateAFluidRelayServerWithCmk)

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_CreateWithCmk.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/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().CreateOrUpdate(ctx, "myResourceGroup", "myFluidRelayServer", armfluidrelay.Server{
		Location: to.Ptr("west-us"),
		Tags: map[string]*string{
			"Category": to.Ptr("sales"),
		},
		Identity: &armfluidrelay.Identity{
			Type: to.Ptr(armfluidrelay.ResourceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armfluidrelay.UserAssignedIdentitiesValue{
				"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identityForCMK": {},
			},
		},
		Properties: &armfluidrelay.ServerProperties{
			Encryption: &armfluidrelay.EncryptionProperties{
				CustomerManagedKeyEncryption: &armfluidrelay.CustomerManagedKeyEncryptionProperties{
					KeyEncryptionKeyIdentity: &armfluidrelay.CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity{
						IdentityType:                   to.Ptr(armfluidrelay.CmkIdentityTypeUserAssigned),
						UserAssignedIdentityResourceID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identityForCMK"),
					},
					KeyEncryptionKeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/contosokek"),
				},
			},
			Storagesku: to.Ptr(armfluidrelay.StorageSKUBasic),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Server = armfluidrelay.Server{
	// 	Name: to.Ptr("myFluidRelayServer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
	// 	Location: to.Ptr("west-us"),
	// 	Identity: &armfluidrelay.Identity{
	// 		Type: to.Ptr(armfluidrelay.ResourceIdentityTypeUserAssigned),
	// 		PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 		TenantID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 		UserAssignedIdentities: map[string]*armfluidrelay.UserAssignedIdentitiesValue{
	// 			"/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identityForCMK": &armfluidrelay.UserAssignedIdentitiesValue{
	// 				ClientID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 				PrincipalID: to.Ptr("00000000-0000-0000-0000-000000000000"),
	// 			},
	// 		},
	// 	},
	// 	Properties: &armfluidrelay.ServerProperties{
	// 		Encryption: &armfluidrelay.EncryptionProperties{
	// 			CustomerManagedKeyEncryption: &armfluidrelay.CustomerManagedKeyEncryptionProperties{
	// 				KeyEncryptionKeyIdentity: &armfluidrelay.CustomerManagedKeyEncryptionPropertiesKeyEncryptionKeyIdentity{
	// 					IdentityType: to.Ptr(armfluidrelay.CmkIdentityTypeUserAssigned),
	// 					UserAssignedIdentityResourceID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/identityForCMK"),
	// 				},
	// 				KeyEncryptionKeyURL: to.Ptr("https://contosovault.vault.azure.net/keys/contosokek"),
	// 			},
	// 		},
	// 		FluidRelayEndpoints: &armfluidrelay.Endpoints{
	// 			OrdererEndpoints: []*string{
	// 				to.Ptr("https://www.contoso.org/orderer")},
	// 				ServiceEndpoints: []*string{
	// 					to.Ptr("https://www.afd.contoso.org")},
	// 					StorageEndpoints: []*string{
	// 						to.Ptr("https://www.contoso.org/storage")},
	// 					},
	// 					FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 					ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 				},
	// 			}
}

Output:

func (*ServersClient) Delete 

func (client *ServersClient) Delete(ctx context.Context, resourceGroup string, fluidRelayServerName string, options *ServersClientDeleteOptions) (ServersClientDeleteResponse, error)

Delete - Delete a Fluid Relay server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • options - ServersClientDeleteOptions contains the optional parameters for the ServersClient.Delete method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_Delete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = clientFactory.NewServersClient().Delete(ctx, "myResourceGroup", "myFluidRelayServer", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*ServersClient) Get 

func (client *ServersClient) Get(ctx context.Context, resourceGroup string, fluidRelayServerName string, options *ServersClientGetOptions) (ServersClientGetResponse, error)

Get - Get a Fluid Relay server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • options - ServersClientGetOptions contains the optional parameters for the ServersClient.Get method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_Get.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().Get(ctx, "myResourceGroup", "myFluidRelayServer", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Server = armfluidrelay.Server{
	// 	Name: to.Ptr("myFluidRelayServer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
	// 	Location: to.Ptr("west-us"),
	// 	Properties: &armfluidrelay.ServerProperties{
	// 		FluidRelayEndpoints: &armfluidrelay.Endpoints{
	// 			OrdererEndpoints: []*string{
	// 				to.Ptr("https://www.contoso.org/orderer")},
	// 				ServiceEndpoints: []*string{
	// 					to.Ptr("https://www.afd.contoso.org")},
	// 					StorageEndpoints: []*string{
	// 						to.Ptr("https://www.contoso.org/storage")},
	// 					},
	// 					FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 					ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 				},
	// 			}
}

Output:

func (*ServersClient) ListKeys 

func (client *ServersClient) ListKeys(ctx context.Context, resourceGroup string, fluidRelayServerName string, options *ServersClientListKeysOptions) (ServersClientListKeysResponse, error)

ListKeys - Get primary and secondary key for this server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • options - ServersClientListKeysOptions contains the optional parameters for the ServersClient.ListKeys method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_ListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().ListKeys(ctx, "myResourceGroup", "myFluidRelayServer", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ServerKeys = armfluidrelay.ServerKeys{
	// 	Key1: to.Ptr("xxx-xxxx-xxxxx-xxxx"),
	// 	Key2: to.Ptr("yyy-yyyy-yyyyy-yyyy"),
	// }
}

Output:

func (*ServersClient) NewListByResourceGroupPager 

func (client *ServersClient) NewListByResourceGroupPager(resourceGroup string, options *ServersClientListByResourceGroupOptions) *runtime.Pager[ServersClientListByResourceGroupResponse]

NewListByResourceGroupPager - List all Fluid Relay servers in a resource group.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • options - ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_ListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewServersClient().NewListByResourceGroupPager("myResourceGroup", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ServerList = armfluidrelay.ServerList{
		// 	Value: []*armfluidrelay.Server{
		// 		{
		// 			Name: to.Ptr("myFluidRelayServer"),
		// 			Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
		// 			ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
		// 			Location: to.Ptr("west-us"),
		// 			Properties: &armfluidrelay.ServerProperties{
		// 				FluidRelayEndpoints: &armfluidrelay.Endpoints{
		// 					OrdererEndpoints: []*string{
		// 						to.Ptr("https://www.contoso.org/orderer")},
		// 						ServiceEndpoints: []*string{
		// 							to.Ptr("https://www.afd.contoso.org")},
		// 							StorageEndpoints: []*string{
		// 								to.Ptr("https://www.contoso.org/storage")},
		// 							},
		// 							FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
		// 							ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
		// 						},
		// 				}},
		// 			}
	}
}

Output:

func (*ServersClient) NewListBySubscriptionPager 

func (client *ServersClient) NewListBySubscriptionPager(options *ServersClientListBySubscriptionOptions) *runtime.Pager[ServersClientListBySubscriptionResponse]

NewListBySubscriptionPager - List all Fluid Relay servers in a subscription.

Generated from API version 2022-06-01

  • options - ServersClientListBySubscriptionOptions contains the optional parameters for the ServersClient.NewListBySubscriptionPager method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_ListBySubscription.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewServersClient().NewListBySubscriptionPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.ServerList = armfluidrelay.ServerList{
		// 	Value: []*armfluidrelay.Server{
		// 		{
		// 			Name: to.Ptr("myFluidRelayServer"),
		// 			Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
		// 			ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
		// 			Location: to.Ptr("west-us"),
		// 			Properties: &armfluidrelay.ServerProperties{
		// 				FluidRelayEndpoints: &armfluidrelay.Endpoints{
		// 					OrdererEndpoints: []*string{
		// 						to.Ptr("https://www.contoso.org/orderer")},
		// 						ServiceEndpoints: []*string{
		// 							to.Ptr("https://www.afd.contoso.org")},
		// 							StorageEndpoints: []*string{
		// 								to.Ptr("https://www.contoso.org/storage")},
		// 							},
		// 							FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
		// 							ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
		// 						},
		// 				}},
		// 			}
	}
}

Output:

func (*ServersClient) RegenerateKey 

func (client *ServersClient) RegenerateKey(ctx context.Context, resourceGroup string, fluidRelayServerName string, parameters RegenerateKeyRequest, options *ServersClientRegenerateKeyOptions) (ServersClientRegenerateKeyResponse, error)

RegenerateKey - Regenerate the primary or secondary key for this server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • parameters - The details of which keys to generate.
  • options - ServersClientRegenerateKeyOptions contains the optional parameters for the ServersClient.RegenerateKey method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_RegenerateKeys.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/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().RegenerateKey(ctx, "myResourceGroup", "myFluidRelayServer", armfluidrelay.RegenerateKeyRequest{
		KeyName: to.Ptr(armfluidrelay.KeyNameKey1),
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.ServerKeys = armfluidrelay.ServerKeys{
	// 	Key1: to.Ptr("xxx-xxxx-xxxxx-xxxx"),
	// 	Key2: to.Ptr("yyy-yyyy-yyyyy-yyyy"),
	// }
}

Output:

func (*ServersClient) Update 

func (client *ServersClient) Update(ctx context.Context, resourceGroup string, fluidRelayServerName string, resource ServerUpdate, options *ServersClientUpdateOptions) (ServersClientUpdateResponse, error)

Update - Update a Fluid Relay server. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2022-06-01

  • resourceGroup - The resource group containing the resource.
  • fluidRelayServerName - The Fluid Relay server resource name.
  • resource - The details of the Fluid Relay server resource included in update calls.
  • options - ServersClientUpdateOptions contains the optional parameters for the ServersClient.Update method.
Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/432872fac1d0f8edcae98a0e8504afc0ee302710/specification/fluidrelay/resource-manager/Microsoft.FluidRelay/stable/2022-06-01/examples/FluidRelayServers_Update.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/fluidrelay/armfluidrelay"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armfluidrelay.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewServersClient().Update(ctx, "myResourceGroup", "myFluidRelayServer", armfluidrelay.ServerUpdate{
		Tags: map[string]*string{
			"Category": to.Ptr("sales"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.Server = armfluidrelay.Server{
	// 	Name: to.Ptr("myFluidRelayServer"),
	// 	Type: to.Ptr("Microsoft.FluidRelay/fluidRelayServers"),
	// 	ID: to.Ptr("/subscriptions/xxxx-xxxx-xxxx-xxxx/resourceGroups/myResourceGroup/Microsoft.FluidRelay/fluidRelayServers/myFluidRelayServer"),
	// 	Location: to.Ptr("west-us"),
	// 	Tags: map[string]*string{
	// 		"Category": to.Ptr("sales"),
	// 	},
	// 	Properties: &armfluidrelay.ServerProperties{
	// 		FluidRelayEndpoints: &armfluidrelay.Endpoints{
	// 			OrdererEndpoints: []*string{
	// 				to.Ptr("https://www.contoso.org/orderer")},
	// 				ServiceEndpoints: []*string{
	// 					to.Ptr("https://www.afd.contoso.org")},
	// 					StorageEndpoints: []*string{
	// 						to.Ptr("https://www.contoso.org/storage")},
	// 					},
	// 					FrsTenantID: to.Ptr("yyyy-yyyy-yyyyy-yyyy"),
	// 					ProvisioningState: to.Ptr(armfluidrelay.ProvisioningStateSucceeded),
	// 				},
	// 			}
}

Output:

type ServersClientCreateOrUpdateOptions 

type ServersClientCreateOrUpdateOptions struct {
}

ServersClientCreateOrUpdateOptions contains the optional parameters for the ServersClient.CreateOrUpdate method.

type ServersClientCreateOrUpdateResponse 

type ServersClientCreateOrUpdateResponse struct {
	// A FluidRelay Server.
	Server
}

ServersClientCreateOrUpdateResponse contains the response from method ServersClient.CreateOrUpdate.

type ServersClientDeleteOptions 

type ServersClientDeleteOptions struct {
}

ServersClientDeleteOptions contains the optional parameters for the ServersClient.Delete method.

type ServersClientDeleteResponse 

type ServersClientDeleteResponse struct {
}

ServersClientDeleteResponse contains the response from method ServersClient.Delete.

type ServersClientGetOptions 

type ServersClientGetOptions struct {
}

ServersClientGetOptions contains the optional parameters for the ServersClient.Get method.

type ServersClientGetResponse 

type ServersClientGetResponse struct {
	// A FluidRelay Server.
	Server
}

ServersClientGetResponse contains the response from method ServersClient.Get.

type ServersClientListByResourceGroupOptions 

type ServersClientListByResourceGroupOptions struct {
}

ServersClientListByResourceGroupOptions contains the optional parameters for the ServersClient.NewListByResourceGroupPager method.

type ServersClientListByResourceGroupResponse 

type ServersClientListByResourceGroupResponse struct {
	// Paged response
	ServerList
}

ServersClientListByResourceGroupResponse contains the response from method ServersClient.NewListByResourceGroupPager.

type ServersClientListBySubscriptionOptions 

type ServersClientListBySubscriptionOptions struct {
}

ServersClientListBySubscriptionOptions contains the optional parameters for the ServersClient.NewListBySubscriptionPager method.

type ServersClientListBySubscriptionResponse 

type ServersClientListBySubscriptionResponse struct {
	// Paged response
	ServerList
}

ServersClientListBySubscriptionResponse contains the response from method ServersClient.NewListBySubscriptionPager.

type ServersClientListKeysOptions 

type ServersClientListKeysOptions struct {
}

ServersClientListKeysOptions contains the optional parameters for the ServersClient.ListKeys method.

type ServersClientListKeysResponse 

type ServersClientListKeysResponse struct {
	// The set of available keys for this server.
	ServerKeys
}

ServersClientListKeysResponse contains the response from method ServersClient.ListKeys.

type ServersClientRegenerateKeyOptions 

type ServersClientRegenerateKeyOptions struct {
}

ServersClientRegenerateKeyOptions contains the optional parameters for the ServersClient.RegenerateKey method.

type ServersClientRegenerateKeyResponse 

type ServersClientRegenerateKeyResponse struct {
	// The set of available keys for this server.
	ServerKeys
}

ServersClientRegenerateKeyResponse contains the response from method ServersClient.RegenerateKey.

type ServersClientUpdateOptions 

type ServersClientUpdateOptions struct {
}

ServersClientUpdateOptions contains the optional parameters for the ServersClient.Update method.

type ServersClientUpdateResponse 

type ServersClientUpdateResponse struct {
	// A FluidRelay Server.
	Server
}

ServersClientUpdateResponse contains the response from method ServersClient.Update.

type StorageSKU 

type StorageSKU string

StorageSKU - Sku of the storage associated with the resource 

const (
	StorageSKUBasic    StorageSKU = "basic"
	StorageSKUStandard StorageSKU = "standard"
)

func PossibleStorageSKUValues 

func PossibleStorageSKUValues() []StorageSKU

PossibleStorageSKUValues returns the possible values for the StorageSKU const type.

type SystemData 

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

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

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

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

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

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

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

func (SystemData) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type TrackedResource 

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

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

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

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

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

TrackedResource - The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'

func (TrackedResource) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type TrackedResource.

func (*TrackedResource) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type TrackedResource.

type UserAssignedIdentitiesValue 

type UserAssignedIdentitiesValue struct {
	// READ-ONLY; The client id of user assigned identity.
	ClientID *string

	// READ-ONLY; The principal id of user assigned identity.
	PrincipalID *string
}

func (UserAssignedIdentitiesValue) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentitiesValue.

func (*UserAssignedIdentitiesValue) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentitiesValue.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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