armredis

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: May 17, 2022 License: MIT Imports: 17 Imported by: 5

README

Azure Cache for Redis Module for Go

PkgGoDev

The armredis module provides operations for working with Azure Cache for Redis.

Source code

Getting started

Prerequisites

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure Cache for Redis module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure Cache for Redis. 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 Cache for Redis 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 := armredis.NewPrivateEndpointConnectionsClient(<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 := armredis.NewPrivateEndpointConnectionsClient(<subscription ID>, cred, &options)

More sample code

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the Cache for Redis 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 AccessKeys added in v0.3.0 

type AccessKeys struct {
	// READ-ONLY; The current primary key that clients can use to authenticate with Redis cache.
	PrimaryKey *string `json:"primaryKey,omitempty" azure:"ro"`

	// READ-ONLY; The current secondary key that clients can use to authenticate with Redis cache.
	SecondaryKey *string `json:"secondaryKey,omitempty" azure:"ro"`
}

AccessKeys - Redis cache access keys.

type AsyncOperationStatusClient added in v0.4.0 

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

AsyncOperationStatusClient contains the methods for the AsyncOperationStatus group. Don't use this type directly, use NewAsyncOperationStatusClient() instead.

func NewAsyncOperationStatusClient added in v0.4.0 

func NewAsyncOperationStatusClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*AsyncOperationStatusClient, error)

NewAsyncOperationStatusClient creates a new instance of AsyncOperationStatusClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*AsyncOperationStatusClient) Get added in v0.4.0 

func (client *AsyncOperationStatusClient) Get(ctx context.Context, location string, operationID string, options *AsyncOperationStatusClientGetOptions) (AsyncOperationStatusClientGetResponse, error)

Get - For checking the ongoing status of an operation If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 location - The location at which operation was triggered operationID - The ID of asynchronous operation options - AsyncOperationStatusClientGetOptions contains the optional parameters for the AsyncOperationStatusClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheAsyncOperationStatus.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewAsyncOperationStatusClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"East US",
		"c7ba2bf5-5939-4d79-b037-2964ccf097da",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

type AsyncOperationStatusClientGetOptions added in v0.4.0 

type AsyncOperationStatusClientGetOptions struct {
}

AsyncOperationStatusClientGetOptions contains the optional parameters for the AsyncOperationStatusClient.Get method.

type AsyncOperationStatusClientGetResponse added in v0.4.0 

type AsyncOperationStatusClientGetResponse struct {
	OperationStatus
}

AsyncOperationStatusClientGetResponse contains the response from method AsyncOperationStatusClient.Get.

type CheckNameAvailabilityParameters 

type CheckNameAvailabilityParameters struct {
	// REQUIRED; Resource name.
	Name *string `json:"name,omitempty"`

	// REQUIRED; Resource type. The only legal value of this property for checking redis cache name availability is 'Microsoft.Cache/redis'.
	Type *string `json:"type,omitempty"`
}

CheckNameAvailabilityParameters - Parameters body to pass for resource name availability check.

type Client added in v0.3.0 

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

Client contains the methods for the Redis group. Don't use this type directly, use NewClient() instead.

func NewClient added in v0.3.0 

func NewClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*Client, error)

NewClient creates a new instance of Client with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*Client) BeginCreate added in v0.3.0 

func (client *Client) BeginCreate(ctx context.Context, resourceGroupName string, name string, parameters CreateParameters, options *ClientBeginCreateOptions) (*runtime.Poller[ClientCreateResponse], error)

BeginCreate - Create or replace (overwrite/recreate, with potential downtime) an existing Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Parameters supplied to the Create Redis operation. options - ClientBeginCreateOptions contains the optional parameters for the Client.BeginCreate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheCreate.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreate(ctx,
		"rg1",
		"cache1",
		armredis.CreateParameters{
			Location: to.Ptr("West US"),
			Properties: &armredis.CreateProperties{
				EnableNonSSLPort:  to.Ptr(true),
				MinimumTLSVersion: to.Ptr(armredis.TLSVersionOne2),
				RedisConfiguration: &armredis.CommonPropertiesRedisConfiguration{
					MaxmemoryPolicy: to.Ptr("allkeys-lru"),
				},
				RedisVersion:       to.Ptr("4"),
				ReplicasPerPrimary: to.Ptr[int32](2),
				ShardCount:         to.Ptr[int32](2),
				SKU: &armredis.SKU{
					Name:     to.Ptr(armredis.SKUNamePremium),
					Capacity: to.Ptr[int32](1),
					Family:   to.Ptr(armredis.SKUFamilyP),
				},
				StaticIP: to.Ptr("192.168.0.5"),
				SubnetID: to.Ptr("/subscriptions/subid/resourceGroups/rg2/providers/Microsoft.Network/virtualNetworks/network1/subnets/subnet1"),
			},
			Zones: []*string{
				to.Ptr("1")},
		},
		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 (*Client) BeginDelete added in v0.3.0 

func (client *Client) BeginDelete(ctx context.Context, resourceGroupName string, name string, options *ClientBeginDeleteOptions) (*runtime.Poller[ClientDeleteResponse], error)

BeginDelete - Deletes a Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. options - ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginDelete(ctx,
		"rg1",
		"cache1",
		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 (*Client) BeginExportData added in v0.3.0 

func (client *Client) BeginExportData(ctx context.Context, resourceGroupName string, name string, parameters ExportRDBParameters, options *ClientBeginExportDataOptions) (*runtime.Poller[ClientExportDataResponse], error)

BeginExportData - Export data from the redis cache to blobs in a container. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Parameters for Redis export operation. options - ClientBeginExportDataOptions contains the optional parameters for the Client.BeginExportData method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheExport.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginExportData(ctx,
		"rg1",
		"cache1",
		armredis.ExportRDBParameters{
			Format:    to.Ptr("RDB"),
			Container: to.Ptr("https://contosostorage.blob.core.window.net/urltoBlobContainer?sasKeyParameters"),
			Prefix:    to.Ptr("datadump1"),
		},
		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 (*Client) BeginImportData added in v0.3.0 

func (client *Client) BeginImportData(ctx context.Context, resourceGroupName string, name string, parameters ImportRDBParameters, options *ClientBeginImportDataOptions) (*runtime.Poller[ClientImportDataResponse], error)

BeginImportData - Import data into Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Parameters for Redis import operation. options - ClientBeginImportDataOptions contains the optional parameters for the Client.BeginImportData method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheImport.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginImportData(ctx,
		"rg1",
		"cache1",
		armredis.ImportRDBParameters{
			Format: to.Ptr("RDB"),
			Files: []*string{
				to.Ptr("http://fileuris.contoso.com/pathtofile1")},
		},
		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 (*Client) CheckNameAvailability added in v0.3.0 

func (client *Client) CheckNameAvailability(ctx context.Context, parameters CheckNameAvailabilityParameters, options *ClientCheckNameAvailabilityOptions) (ClientCheckNameAvailabilityResponse, error)

CheckNameAvailability - Checks that the redis cache name is valid and is not already in use. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 parameters - Parameters supplied to the CheckNameAvailability Redis operation. The only supported resource type is 'Microsoft.Cache/redis' options - ClientCheckNameAvailabilityOptions contains the optional parameters for the Client.CheckNameAvailability method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheCheckNameAvailability.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.CheckNameAvailability(ctx,
		armredis.CheckNameAvailabilityParameters{
			Name: to.Ptr("cacheName"),
			Type: to.Ptr("Microsoft.Cache/Redis"),
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*Client) ForceReboot added in v0.3.0 

func (client *Client) ForceReboot(ctx context.Context, resourceGroupName string, name string, parameters RebootParameters, options *ClientForceRebootOptions) (ClientForceRebootResponse, error)

ForceReboot - Reboot specified Redis node(s). This operation requires write permission to the cache resource. There can be potential data loss. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Specifies which Redis node(s) to reboot. options - ClientForceRebootOptions contains the optional parameters for the Client.ForceReboot method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheForceReboot.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.ForceReboot(ctx,
		"rg1",
		"cache1",
		armredis.RebootParameters{
			Ports: []*int32{
				to.Ptr[int32](13000),
				to.Ptr[int32](15001)},
			RebootType: to.Ptr(armredis.RebootTypeAllNodes),
			ShardID:    to.Ptr[int32](0),
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*Client) Get added in v0.3.0 

func (client *Client) Get(ctx context.Context, resourceGroupName string, name string, options *ClientGetOptions) (ClientGetResponse, error)

Get - Gets a Redis cache (resource description). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. options - ClientGetOptions contains the optional parameters for the Client.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"cache1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*Client) ListKeys added in v0.3.0 

func (client *Client) ListKeys(ctx context.Context, resourceGroupName string, name string, options *ClientListKeysOptions) (ClientListKeysResponse, error)

ListKeys - Retrieve a Redis cache's access keys. This operation requires write permission to the cache resource. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. options - ClientListKeysOptions contains the optional parameters for the Client.ListKeys method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheListKeys.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.ListKeys(ctx,
		"rg1",
		"cache1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*Client) NewListByResourceGroupPager added in v0.5.0 

func (client *Client) NewListByResourceGroupPager(resourceGroupName string, options *ClientListByResourceGroupOptions) *runtime.Pager[ClientListByResourceGroupResponse]

NewListByResourceGroupPager - Lists all Redis caches in a resource group. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. options - ClientListByResourceGroupOptions contains the optional parameters for the Client.ListByResourceGroup method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheListByResourceGroup.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByResourceGroupPager("rg1",
		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 (*Client) NewListBySubscriptionPager added in v0.5.0 

func (client *Client) NewListBySubscriptionPager(options *ClientListBySubscriptionOptions) *runtime.Pager[ClientListBySubscriptionResponse]

NewListBySubscriptionPager - Gets all Redis caches in the specified subscription. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 options - ClientListBySubscriptionOptions contains the optional parameters for the Client.ListBySubscription method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListBySubscriptionPager(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 (*Client) NewListUpgradeNotificationsPager added in v0.5.0 

func (client *Client) NewListUpgradeNotificationsPager(resourceGroupName string, name string, history float64, options *ClientListUpgradeNotificationsOptions) *runtime.Pager[ClientListUpgradeNotificationsResponse]

NewListUpgradeNotificationsPager - Gets any upgrade notifications for a Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. history - how many minutes in past to look for upgrade notifications options - ClientListUpgradeNotificationsOptions contains the optional parameters for the Client.ListUpgradeNotifications method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheListUpgradeNotifications.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListUpgradeNotificationsPager("rg1",
		"cache1",
		5000,
		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 (*Client) RegenerateKey added in v0.3.0 

func (client *Client) RegenerateKey(ctx context.Context, resourceGroupName string, name string, parameters RegenerateKeyParameters, options *ClientRegenerateKeyOptions) (ClientRegenerateKeyResponse, error)

RegenerateKey - Regenerate Redis cache's access keys. This operation requires write permission to the cache resource. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Specifies which key to regenerate. options - ClientRegenerateKeyOptions contains the optional parameters for the Client.RegenerateKey method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheRegenerateKey.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.RegenerateKey(ctx,
		"rg1",
		"cache1",
		armredis.RegenerateKeyParameters{
			KeyType: to.Ptr(armredis.RedisKeyTypePrimary),
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*Client) Update added in v0.3.0 

func (client *Client) Update(ctx context.Context, resourceGroupName string, name string, parameters UpdateParameters, options *ClientUpdateOptions) (ClientUpdateResponse, error)

Update - Update an existing Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. parameters - Parameters supplied to the Update Redis operation. options - ClientUpdateOptions contains the optional parameters for the Client.Update method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheUpdate.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Update(ctx,
		"rg1",
		"cache1",
		armredis.UpdateParameters{
			Properties: &armredis.UpdateProperties{
				EnableNonSSLPort:   to.Ptr(true),
				ReplicasPerPrimary: to.Ptr[int32](2),
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

type ClientBeginCreateOptions added in v0.3.0 

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

ClientBeginCreateOptions contains the optional parameters for the Client.BeginCreate method.

type ClientBeginDeleteOptions added in v0.3.0 

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

ClientBeginDeleteOptions contains the optional parameters for the Client.BeginDelete method.

type ClientBeginExportDataOptions added in v0.3.0 

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

ClientBeginExportDataOptions contains the optional parameters for the Client.BeginExportData method.

type ClientBeginImportDataOptions added in v0.3.0 

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

ClientBeginImportDataOptions contains the optional parameters for the Client.BeginImportData method.

type ClientCheckNameAvailabilityOptions added in v0.3.0 

type ClientCheckNameAvailabilityOptions struct {
}

ClientCheckNameAvailabilityOptions contains the optional parameters for the Client.CheckNameAvailability method.

type ClientCheckNameAvailabilityResponse added in v0.3.0 

type ClientCheckNameAvailabilityResponse struct {
}

ClientCheckNameAvailabilityResponse contains the response from method Client.CheckNameAvailability.

type ClientCreateResponse added in v0.3.0 

type ClientCreateResponse struct {
	ResourceInfo
}

ClientCreateResponse contains the response from method Client.Create.

type ClientDeleteResponse added in v0.3.0 

type ClientDeleteResponse struct {
}

ClientDeleteResponse contains the response from method Client.Delete.

type ClientExportDataResponse added in v0.3.0 

type ClientExportDataResponse struct {
}

ClientExportDataResponse contains the response from method Client.ExportData.

type ClientForceRebootOptions added in v0.3.0 

type ClientForceRebootOptions struct {
}

ClientForceRebootOptions contains the optional parameters for the Client.ForceReboot method.

type ClientForceRebootResponse added in v0.3.0 

type ClientForceRebootResponse struct {
	ForceRebootResponse
}

ClientForceRebootResponse contains the response from method Client.ForceReboot.

type ClientGetOptions added in v0.3.0 

type ClientGetOptions struct {
}

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

type ClientGetResponse added in v0.3.0 

type ClientGetResponse struct {
	ResourceInfo
}

ClientGetResponse contains the response from method Client.Get.

type ClientImportDataResponse added in v0.3.0 

type ClientImportDataResponse struct {
}

ClientImportDataResponse contains the response from method Client.ImportData.

type ClientListByResourceGroupOptions added in v0.3.0 

type ClientListByResourceGroupOptions struct {
}

ClientListByResourceGroupOptions contains the optional parameters for the Client.ListByResourceGroup method.

type ClientListByResourceGroupResponse added in v0.3.0 

type ClientListByResourceGroupResponse struct {
	ListResult
}

ClientListByResourceGroupResponse contains the response from method Client.ListByResourceGroup.

type ClientListBySubscriptionOptions added in v0.3.0 

type ClientListBySubscriptionOptions struct {
}

ClientListBySubscriptionOptions contains the optional parameters for the Client.ListBySubscription method.

type ClientListBySubscriptionResponse added in v0.3.0 

type ClientListBySubscriptionResponse struct {
	ListResult
}

ClientListBySubscriptionResponse contains the response from method Client.ListBySubscription.

type ClientListKeysOptions added in v0.3.0 

type ClientListKeysOptions struct {
}

ClientListKeysOptions contains the optional parameters for the Client.ListKeys method.

type ClientListKeysResponse added in v0.3.0 

type ClientListKeysResponse struct {
	AccessKeys
}

ClientListKeysResponse contains the response from method Client.ListKeys.

type ClientListUpgradeNotificationsOptions added in v0.3.0 

type ClientListUpgradeNotificationsOptions struct {
}

ClientListUpgradeNotificationsOptions contains the optional parameters for the Client.ListUpgradeNotifications method.

type ClientListUpgradeNotificationsResponse added in v0.3.0 

type ClientListUpgradeNotificationsResponse struct {
	NotificationListResponse
}

ClientListUpgradeNotificationsResponse contains the response from method Client.ListUpgradeNotifications.

type ClientRegenerateKeyOptions added in v0.3.0 

type ClientRegenerateKeyOptions struct {
}

ClientRegenerateKeyOptions contains the optional parameters for the Client.RegenerateKey method.

type ClientRegenerateKeyResponse added in v0.3.0 

type ClientRegenerateKeyResponse struct {
	AccessKeys
}

ClientRegenerateKeyResponse contains the response from method Client.RegenerateKey.

type ClientUpdateOptions added in v0.3.0 

type ClientUpdateOptions struct {
}

ClientUpdateOptions contains the optional parameters for the Client.Update method.

type ClientUpdateResponse added in v0.3.0 

type ClientUpdateResponse struct {
	ResourceInfo
}

ClientUpdateResponse contains the response from method Client.Update.

type CommonProperties added in v0.3.0 

type CommonProperties struct {
	// Specifies whether the non-ssl Redis server port (6379) is enabled.
	EnableNonSSLPort *bool `json:"enableNonSslPort,omitempty"`

	// Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')
	MinimumTLSVersion *TLSVersion `json:"minimumTlsVersion,omitempty"`

	// Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled'
	// or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method.
	// Default value is 'Enabled'
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// All Redis Settings. Few possible keys:
	// rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
	// etc.
	RedisConfiguration *CommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`

	// Redis version. Only major version will be used in PUT/PATCH request with current valid values: (4, 6)
	RedisVersion *string `json:"redisVersion,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerMaster *int32 `json:"replicasPerMaster,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerPrimary *int32 `json:"replicasPerPrimary,omitempty"`

	// The number of shards to be created on a Premium Cluster Cache.
	ShardCount *int32 `json:"shardCount,omitempty"`

	// A dictionary of tenant settings
	TenantSettings map[string]*string `json:"tenantSettings,omitempty"`
}

CommonProperties - Create/Update/Get common properties of the redis cache.

func (CommonProperties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type CommonProperties.

type CommonPropertiesRedisConfiguration added in v0.3.0 

type CommonPropertiesRedisConfiguration struct {
	// OPTIONAL; Contains additional key/value pairs not defined in the schema.
	AdditionalProperties map[string]interface{}

	// First storage account connection string
	AofStorageConnectionString0 *string `json:"aof-storage-connection-string-0,omitempty"`

	// Second storage account connection string
	AofStorageConnectionString1 *string `json:"aof-storage-connection-string-1,omitempty"`

	// Value in megabytes reserved for fragmentation per shard
	MaxfragmentationmemoryReserved *string `json:"maxfragmentationmemory-reserved,omitempty"`

	// Value in megabytes reserved for non-cache usage per shard e.g. failover.
	MaxmemoryDelta *string `json:"maxmemory-delta,omitempty"`

	// The eviction strategy used when your data won't fit within its memory limit.
	MaxmemoryPolicy *string `json:"maxmemory-policy,omitempty"`

	// Value in megabytes reserved for non-cache usage per shard e.g. failover.
	MaxmemoryReserved *string `json:"maxmemory-reserved,omitempty"`

	// Specifies whether the rdb backup is enabled
	RdbBackupEnabled *string `json:"rdb-backup-enabled,omitempty"`

	// Specifies the frequency for creating rdb backup
	RdbBackupFrequency *string `json:"rdb-backup-frequency,omitempty"`

	// Specifies the maximum number of snapshots for rdb backup
	RdbBackupMaxSnapshotCount *string `json:"rdb-backup-max-snapshot-count,omitempty"`

	// The storage account connection string for storing rdb file
	RdbStorageConnectionString *string `json:"rdb-storage-connection-string,omitempty"`

	// READ-ONLY; The max clients config
	Maxclients *string `json:"maxclients,omitempty" azure:"ro"`

	// READ-ONLY; Preferred auth method to communicate to storage account used for data archive, specify SAS or ManagedIdentity,
	// default value is SAS
	PreferredDataArchiveAuthMethod *string `json:"preferred-data-archive-auth-method,omitempty" azure:"ro"`

	// READ-ONLY; Preferred auth method to communicate to storage account used for data persistence, specify SAS or ManagedIdentity,
	// default value is SAS
	PreferredDataPersistenceAuthMethod *string `json:"preferred-data-persistence-auth-method,omitempty" azure:"ro"`

	// READ-ONLY; Zonal Configuration
	ZonalConfiguration *string `json:"zonal-configuration,omitempty" azure:"ro"`
}

CommonPropertiesRedisConfiguration - All Redis Settings. Few possible keys: rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value etc.

func (CommonPropertiesRedisConfiguration) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type CommonPropertiesRedisConfiguration.

func (*CommonPropertiesRedisConfiguration) UnmarshalJSON added in v0.3.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type CommonPropertiesRedisConfiguration.

type CreateParameters added in v0.3.0 

type CreateParameters struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// REQUIRED; Redis cache properties.
	Properties *CreateProperties `json:"properties,omitempty"`

	// The identity of the resource.
	Identity *ManagedServiceIdentity `json:"identity,omitempty"`

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

	// A list of availability zones denoting where the resource needs to come from.
	Zones []*string `json:"zones,omitempty"`
}

CreateParameters - Parameters supplied to the Create Redis operation.

func (CreateParameters) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateParameters.

type CreateProperties added in v0.3.0 

type CreateProperties struct {
	// REQUIRED; The SKU of the Redis cache to deploy.
	SKU *SKU `json:"sku,omitempty"`

	// Specifies whether the non-ssl Redis server port (6379) is enabled.
	EnableNonSSLPort *bool `json:"enableNonSslPort,omitempty"`

	// Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')
	MinimumTLSVersion *TLSVersion `json:"minimumTlsVersion,omitempty"`

	// Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled'
	// or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method.
	// Default value is 'Enabled'
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// All Redis Settings. Few possible keys:
	// rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
	// etc.
	RedisConfiguration *CommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`

	// Redis version. Only major version will be used in PUT/PATCH request with current valid values: (4, 6)
	RedisVersion *string `json:"redisVersion,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerMaster *int32 `json:"replicasPerMaster,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerPrimary *int32 `json:"replicasPerPrimary,omitempty"`

	// The number of shards to be created on a Premium Cluster Cache.
	ShardCount *int32 `json:"shardCount,omitempty"`

	// Static IP address. Optionally, may be specified when deploying a Redis cache inside an existing Azure Virtual Network;
	// auto assigned by default.
	StaticIP *string `json:"staticIP,omitempty"`

	// The full resource ID of a subnet in a virtual network to deploy the Redis cache in. Example format:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
	SubnetID *string `json:"subnetId,omitempty"`

	// A dictionary of tenant settings
	TenantSettings map[string]*string `json:"tenantSettings,omitempty"`
}

CreateProperties - Properties supplied to Create Redis operation.

func (CreateProperties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type CreateProperties.

type DayOfWeek 

type DayOfWeek string

DayOfWeek - Day of the week when a cache can be patched. 

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

func PossibleDayOfWeekValues 

func PossibleDayOfWeekValues() []DayOfWeek

PossibleDayOfWeekValues returns the possible values for the DayOfWeek const type.

type DefaultName 

type DefaultName string
const (
	DefaultNameDefault DefaultName = "default"
)

func PossibleDefaultNameValues 

func PossibleDefaultNameValues() []DefaultName

PossibleDefaultNameValues returns the possible values for the DefaultName const type.

type ErrorAdditionalInfo 

type ErrorAdditionalInfo struct {
	// READ-ONLY; The additional info.
	Info interface{} `json:"info,omitempty" azure:"ro"`

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

ErrorAdditionalInfo - The resource management error additional info.

type ErrorDetail 

type ErrorDetail struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo `json:"additionalInfo,omitempty" azure:"ro"`

	// READ-ONLY; The error code.
	Code *string `json:"code,omitempty" azure:"ro"`

	// READ-ONLY; The error details.
	Details []*ErrorDetail `json:"details,omitempty" azure:"ro"`

	// READ-ONLY; The error message.
	Message *string `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; The error target.
	Target *string `json:"target,omitempty" azure:"ro"`
}

ErrorDetail - The error detail.

type ErrorDetailAutoGenerated added in v0.4.0 

type ErrorDetailAutoGenerated struct {
	// READ-ONLY; The error additional info.
	AdditionalInfo []*ErrorAdditionalInfo `json:"additionalInfo,omitempty" azure:"ro"`

	// READ-ONLY; The error code.
	Code *string `json:"code,omitempty" azure:"ro"`

	// READ-ONLY; The error details.
	Details []*ErrorDetailAutoGenerated `json:"details,omitempty" azure:"ro"`

	// READ-ONLY; The error message.
	Message *string `json:"message,omitempty" azure:"ro"`

	// READ-ONLY; The error target.
	Target *string `json:"target,omitempty" azure:"ro"`
}

ErrorDetailAutoGenerated - The error detail.

type ErrorResponse 

type ErrorResponse struct {
	// The error object.
	Error *ErrorDetail `json:"error,omitempty"`
}

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

type ExportRDBParameters 

type ExportRDBParameters struct {
	// REQUIRED; Container name to export to.
	Container *string `json:"container,omitempty"`

	// REQUIRED; Prefix to use for exported files.
	Prefix *string `json:"prefix,omitempty"`

	// File format.
	Format *string `json:"format,omitempty"`
}

ExportRDBParameters - Parameters for Redis export operation.

type FirewallRule added in v0.3.0 

type FirewallRule struct {
	// REQUIRED; redis cache firewall rule properties
	Properties *FirewallRuleProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

FirewallRule - A firewall rule on a redis cache has a name, and describes a contiguous range of IP addresses permitted to connect

type FirewallRuleCreateParameters added in v0.3.0 

type FirewallRuleCreateParameters struct {
	// REQUIRED; redis cache firewall rule properties
	Properties *FirewallRuleProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

FirewallRuleCreateParameters - Parameters required for creating a firewall rule on redis cache. (Note, you can just use the FirewallRule type instead now.)

type FirewallRuleListResult added in v0.3.0 

type FirewallRuleListResult struct {
	// Results of the list firewall rules operation.
	Value []*FirewallRule `json:"value,omitempty"`

	// READ-ONLY; Link for next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

FirewallRuleListResult - The response of list firewall rules Redis operation.

type FirewallRuleProperties added in v0.3.0 

type FirewallRuleProperties struct {
	// REQUIRED; highest IP address included in the range
	EndIP *string `json:"endIP,omitempty"`

	// REQUIRED; lowest IP address included in the range
	StartIP *string `json:"startIP,omitempty"`
}

FirewallRuleProperties - Specifies a range of IP addresses permitted to connect to the cache

type FirewallRulesClient 

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

FirewallRulesClient contains the methods for the FirewallRules group. Don't use this type directly, use NewFirewallRulesClient() instead.

func NewFirewallRulesClient 

func NewFirewallRulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*FirewallRulesClient, error)

NewFirewallRulesClient creates a new instance of FirewallRulesClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*FirewallRulesClient) CreateOrUpdate 

func (client *FirewallRulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, cacheName string, ruleName string, parameters FirewallRule, options *FirewallRulesClientCreateOrUpdateOptions) (FirewallRulesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create or update a redis cache firewall rule If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. ruleName - The name of the firewall rule. parameters - Parameters supplied to the create or update redis firewall rule operation. options - FirewallRulesClientCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.CreateOrUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheFirewallRuleCreate.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewFirewallRulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.CreateOrUpdate(ctx,
		"rg1",
		"cache1",
		"rule1",
		armredis.FirewallRule{
			Properties: &armredis.FirewallRuleProperties{
				EndIP:   to.Ptr("192.168.1.4"),
				StartIP: to.Ptr("192.168.1.1"),
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*FirewallRulesClient) Delete 

func (client *FirewallRulesClient) Delete(ctx context.Context, resourceGroupName string, cacheName string, ruleName string, options *FirewallRulesClientDeleteOptions) (FirewallRulesClientDeleteResponse, error)

Delete - Deletes a single firewall rule in a specified redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. ruleName - The name of the firewall rule. options - FirewallRulesClientDeleteOptions contains the optional parameters for the FirewallRulesClient.Delete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheFirewallRuleDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewFirewallRulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.Delete(ctx,
		"rg1",
		"cache1",
		"rule1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*FirewallRulesClient) Get 

func (client *FirewallRulesClient) Get(ctx context.Context, resourceGroupName string, cacheName string, ruleName string, options *FirewallRulesClientGetOptions) (FirewallRulesClientGetResponse, error)

Get - Gets a single firewall rule in a specified redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. ruleName - The name of the firewall rule. options - FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheFirewallRuleGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewFirewallRulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"cache1",
		"rule1",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*FirewallRulesClient) NewListPager added in v0.5.0 

func (client *FirewallRulesClient) NewListPager(resourceGroupName string, cacheName string, options *FirewallRulesClientListOptions) *runtime.Pager[FirewallRulesClientListResponse]

NewListPager - Gets all firewall rules in the specified redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. options - FirewallRulesClientListOptions contains the optional parameters for the FirewallRulesClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheFirewallRulesList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewFirewallRulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager("rg1",
		"cache1",
		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 FirewallRulesClientCreateOrUpdateOptions added in v0.3.0 

type FirewallRulesClientCreateOrUpdateOptions struct {
}

FirewallRulesClientCreateOrUpdateOptions contains the optional parameters for the FirewallRulesClient.CreateOrUpdate method.

type FirewallRulesClientCreateOrUpdateResponse added in v0.3.0 

type FirewallRulesClientCreateOrUpdateResponse struct {
	FirewallRule
}

FirewallRulesClientCreateOrUpdateResponse contains the response from method FirewallRulesClient.CreateOrUpdate.

type FirewallRulesClientDeleteOptions added in v0.3.0 

type FirewallRulesClientDeleteOptions struct {
}

FirewallRulesClientDeleteOptions contains the optional parameters for the FirewallRulesClient.Delete method.

type FirewallRulesClientDeleteResponse added in v0.3.0 

type FirewallRulesClientDeleteResponse struct {
}

FirewallRulesClientDeleteResponse contains the response from method FirewallRulesClient.Delete.

type FirewallRulesClientGetOptions added in v0.3.0 

type FirewallRulesClientGetOptions struct {
}

FirewallRulesClientGetOptions contains the optional parameters for the FirewallRulesClient.Get method.

type FirewallRulesClientGetResponse added in v0.3.0 

type FirewallRulesClientGetResponse struct {
	FirewallRule
}

FirewallRulesClientGetResponse contains the response from method FirewallRulesClient.Get.

type FirewallRulesClientListOptions added in v0.3.0 

type FirewallRulesClientListOptions struct {
}

FirewallRulesClientListOptions contains the optional parameters for the FirewallRulesClient.List method.

type FirewallRulesClientListResponse added in v0.3.0 

type FirewallRulesClientListResponse struct {
	FirewallRuleListResult
}

FirewallRulesClientListResponse contains the response from method FirewallRulesClient.List.

type ForceRebootResponse added in v0.3.0 

type ForceRebootResponse struct {
	// READ-ONLY; Status message
	Message *string `json:"message,omitempty" azure:"ro"`
}

ForceRebootResponse - Response to force reboot for Redis cache.

type ImportRDBParameters 

type ImportRDBParameters struct {
	// REQUIRED; files to import.
	Files []*string `json:"files,omitempty"`

	// File format.
	Format *string `json:"format,omitempty"`
}

ImportRDBParameters - Parameters for Redis import operation.

func (ImportRDBParameters) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ImportRDBParameters.

type InstanceDetails added in v0.3.0 

type InstanceDetails struct {
	// READ-ONLY; Specifies whether the instance is a primary node.
	IsMaster *bool `json:"isMaster,omitempty" azure:"ro"`

	// READ-ONLY; Specifies whether the instance is a primary node.
	IsPrimary *bool `json:"isPrimary,omitempty" azure:"ro"`

	// READ-ONLY; If enableNonSslPort is true, provides Redis instance Non-SSL port.
	NonSSLPort *int32 `json:"nonSslPort,omitempty" azure:"ro"`

	// READ-ONLY; Redis instance SSL port.
	SSLPort *int32 `json:"sslPort,omitempty" azure:"ro"`

	// READ-ONLY; If clustering is enabled, the Shard ID of Redis Instance
	ShardID *int32 `json:"shardId,omitempty" azure:"ro"`

	// READ-ONLY; If the Cache uses availability zones, specifies availability zone where this instance is located.
	Zone *string `json:"zone,omitempty" azure:"ro"`
}

InstanceDetails - Details of single instance of redis.

type LinkedServer added in v0.3.0 

type LinkedServer struct {
	// READ-ONLY; Linked server Id.
	ID *string `json:"id,omitempty" azure:"ro"`
}

LinkedServer - Linked server Id

type LinkedServerClient 

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

LinkedServerClient contains the methods for the LinkedServer group. Don't use this type directly, use NewLinkedServerClient() instead.

func NewLinkedServerClient 

func NewLinkedServerClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*LinkedServerClient, error)

NewLinkedServerClient creates a new instance of LinkedServerClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*LinkedServerClient) BeginCreate 

func (client *LinkedServerClient) BeginCreate(ctx context.Context, resourceGroupName string, name string, linkedServerName string, parameters LinkedServerCreateParameters, options *LinkedServerClientBeginCreateOptions) (*runtime.Poller[LinkedServerClientCreateResponse], error)

BeginCreate - Adds a linked server to the Redis cache (requires Premium SKU). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. linkedServerName - The name of the linked server that is being added to the Redis cache. parameters - Parameters supplied to the Create Linked server operation. options - LinkedServerClientBeginCreateOptions contains the optional parameters for the LinkedServerClient.BeginCreate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheLinkedServer_Create.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewLinkedServerClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginCreate(ctx,
		"rg1",
		"cache1",
		"cache2",
		armredis.LinkedServerCreateParameters{
			Properties: &armredis.LinkedServerCreateProperties{
				LinkedRedisCacheID:       to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.Cache/Redis/cache2"),
				LinkedRedisCacheLocation: to.Ptr("West US"),
				ServerRole:               to.Ptr(armredis.ReplicationRoleSecondary),
			},
		},
		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 (*LinkedServerClient) Delete 

func (client *LinkedServerClient) Delete(ctx context.Context, resourceGroupName string, name string, linkedServerName string, options *LinkedServerClientDeleteOptions) (LinkedServerClientDeleteResponse, error)

Delete - Deletes the linked server from a redis cache (requires Premium SKU). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the redis cache. linkedServerName - The name of the linked server that is being added to the Redis cache. options - LinkedServerClientDeleteOptions contains the optional parameters for the LinkedServerClient.Delete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheLinkedServer_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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewLinkedServerClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.Delete(ctx,
		"rg1",
		"cache1",
		"cache2",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*LinkedServerClient) Get 

func (client *LinkedServerClient) Get(ctx context.Context, resourceGroupName string, name string, linkedServerName string, options *LinkedServerClientGetOptions) (LinkedServerClientGetResponse, error)

Get - Gets the detailed information about a linked server of a redis cache (requires Premium SKU). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the redis cache. linkedServerName - The name of the linked server. options - LinkedServerClientGetOptions contains the optional parameters for the LinkedServerClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheLinkedServer_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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewLinkedServerClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"cache1",
		"cache2",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*LinkedServerClient) NewListPager added in v0.5.0 

func (client *LinkedServerClient) NewListPager(resourceGroupName string, name string, options *LinkedServerClientListOptions) *runtime.Pager[LinkedServerClientListResponse]

NewListPager - Gets the list of linked servers associated with this redis cache (requires Premium SKU). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the redis cache. options - LinkedServerClientListOptions contains the optional parameters for the LinkedServerClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheLinkedServer_List.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewLinkedServerClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager("rg1",
		"cache1",
		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 LinkedServerClientBeginCreateOptions added in v0.3.0 

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

LinkedServerClientBeginCreateOptions contains the optional parameters for the LinkedServerClient.BeginCreate method.

type LinkedServerClientCreateResponse added in v0.3.0 

type LinkedServerClientCreateResponse struct {
	LinkedServerWithProperties
}

LinkedServerClientCreateResponse contains the response from method LinkedServerClient.Create.

type LinkedServerClientDeleteOptions added in v0.3.0 

type LinkedServerClientDeleteOptions struct {
}

LinkedServerClientDeleteOptions contains the optional parameters for the LinkedServerClient.Delete method.

type LinkedServerClientDeleteResponse added in v0.3.0 

type LinkedServerClientDeleteResponse struct {
}

LinkedServerClientDeleteResponse contains the response from method LinkedServerClient.Delete.

type LinkedServerClientGetOptions added in v0.3.0 

type LinkedServerClientGetOptions struct {
}

LinkedServerClientGetOptions contains the optional parameters for the LinkedServerClient.Get method.

type LinkedServerClientGetResponse added in v0.3.0 

type LinkedServerClientGetResponse struct {
	LinkedServerWithProperties
}

LinkedServerClientGetResponse contains the response from method LinkedServerClient.Get.

type LinkedServerClientListOptions added in v0.3.0 

type LinkedServerClientListOptions struct {
}

LinkedServerClientListOptions contains the optional parameters for the LinkedServerClient.List method.

type LinkedServerClientListResponse added in v0.3.0 

type LinkedServerClientListResponse struct {
	LinkedServerWithPropertiesList
}

LinkedServerClientListResponse contains the response from method LinkedServerClient.List.

type LinkedServerCreateParameters added in v0.3.0 

type LinkedServerCreateParameters struct {
	// REQUIRED; Properties required to create a linked server.
	Properties *LinkedServerCreateProperties `json:"properties,omitempty"`
}

LinkedServerCreateParameters - Parameter required for creating a linked server to redis cache.

type LinkedServerCreateProperties added in v0.3.0 

type LinkedServerCreateProperties struct {
	// REQUIRED; Fully qualified resourceId of the linked redis cache.
	LinkedRedisCacheID *string `json:"linkedRedisCacheId,omitempty"`

	// REQUIRED; Location of the linked redis cache.
	LinkedRedisCacheLocation *string `json:"linkedRedisCacheLocation,omitempty"`

	// REQUIRED; Role of the linked server.
	ServerRole *ReplicationRole `json:"serverRole,omitempty"`
}

LinkedServerCreateProperties - Create properties for a linked server

type LinkedServerProperties added in v0.3.0 

type LinkedServerProperties struct {
	// REQUIRED; Fully qualified resourceId of the linked redis cache.
	LinkedRedisCacheID *string `json:"linkedRedisCacheId,omitempty"`

	// REQUIRED; Location of the linked redis cache.
	LinkedRedisCacheLocation *string `json:"linkedRedisCacheLocation,omitempty"`

	// REQUIRED; Role of the linked server.
	ServerRole *ReplicationRole `json:"serverRole,omitempty"`

	// READ-ONLY; Terminal state of the link between primary and secondary redis cache.
	ProvisioningState *string `json:"provisioningState,omitempty" azure:"ro"`
}

LinkedServerProperties - Properties of a linked server to be returned in get/put response

type LinkedServerWithProperties added in v0.3.0 

type LinkedServerWithProperties struct {
	// Properties of the linked server.
	Properties *LinkedServerProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

LinkedServerWithProperties - Response to put/get linked server (with properties) for Redis cache.

type LinkedServerWithPropertiesList added in v0.3.0 

type LinkedServerWithPropertiesList struct {
	// List of linked servers (with properties) of a Redis cache.
	Value []*LinkedServerWithProperties `json:"value,omitempty"`

	// READ-ONLY; Link for next set.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

LinkedServerWithPropertiesList - List of linked servers (with properties) of a Redis cache.

type ListResult added in v0.3.0 

type ListResult struct {
	// List of Redis cache instances.
	Value []*ResourceInfo `json:"value,omitempty"`

	// READ-ONLY; Link for next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

ListResult - The response of list Redis operation.

type ManagedServiceIdentity added in v0.3.0 

type ManagedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
	Type *ManagedServiceIdentityType `json:"type,omitempty"`

	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
	// resource ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
	// The dictionary values can be empty objects ({}) in
	// requests.
	UserAssignedIdentities map[string]*UserAssignedIdentity `json:"userAssignedIdentities,omitempty"`

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string `json:"tenantId,omitempty" azure:"ro"`
}

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

func (ManagedServiceIdentity) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType added in v0.3.0 

type ManagedServiceIdentityType string

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

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned, UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues added in v0.3.0 

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type NotificationListResponse 

type NotificationListResponse struct {
	// List of all notifications.
	Value []*UpgradeNotification `json:"value,omitempty"`

	// READ-ONLY; Link for next set of notifications.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

NotificationListResponse - The response of listUpgradeNotifications.

type Operation 

type Operation struct {
	// The object that describes the operation.
	Display *OperationDisplay `json:"display,omitempty"`

	// Operation name: {provider}/{resource}/{operation}
	Name *string `json:"name,omitempty"`
}

Operation - REST API operation

type OperationDisplay 

type OperationDisplay struct {
	// Friendly name of the operation
	Description *string `json:"description,omitempty"`

	// Operation type: read, write, delete, listKeys/action, etc.
	Operation *string `json:"operation,omitempty"`

	// Friendly name of the resource provider
	Provider *string `json:"provider,omitempty"`

	// Resource type on which the operation is performed.
	Resource *string `json:"resource,omitempty"`
}

OperationDisplay - The object that describes the operation.

type OperationListResult 

type OperationListResult struct {
	// List of operations supported by the resource provider.
	Value []*Operation `json:"value,omitempty"`

	// READ-ONLY; URL to get the next set of operation list results if there are any.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

OperationListResult - Result of the request to list REST API operations. It contains a list of operations and a URL nextLink to get the next set of results.

type OperationStatus added in v0.4.0 

type OperationStatus struct {
	// REQUIRED; Operation status.
	Status *string `json:"status,omitempty"`

	// The end time of the operation.
	EndTime *time.Time `json:"endTime,omitempty"`

	// If present, details of the operation error.
	Error *ErrorDetailAutoGenerated `json:"error,omitempty"`

	// Fully qualified ID for the async operation.
	ID *string `json:"id,omitempty"`

	// Name of the async operation.
	Name *string `json:"name,omitempty"`

	// The operations list.
	Operations []*OperationStatusResult `json:"operations,omitempty"`

	// Percent of the operation that is complete.
	PercentComplete *float32 `json:"percentComplete,omitempty"`

	// Additional properties from RP, only when operation is successful
	Properties map[string]interface{} `json:"properties,omitempty"`

	// The start time of the operation.
	StartTime *time.Time `json:"startTime,omitempty"`
}

OperationStatus - Asynchronous operation status

func (*OperationStatus) UnmarshalJSON added in v0.4.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationStatus.

type OperationStatusResult added in v0.4.0 

type OperationStatusResult struct {
	// REQUIRED; Operation status.
	Status *string `json:"status,omitempty"`

	// The end time of the operation.
	EndTime *time.Time `json:"endTime,omitempty"`

	// If present, details of the operation error.
	Error *ErrorDetailAutoGenerated `json:"error,omitempty"`

	// Fully qualified ID for the async operation.
	ID *string `json:"id,omitempty"`

	// Name of the async operation.
	Name *string `json:"name,omitempty"`

	// The operations list.
	Operations []*OperationStatusResult `json:"operations,omitempty"`

	// Percent of the operation that is complete.
	PercentComplete *float32 `json:"percentComplete,omitempty"`

	// The start time of the operation.
	StartTime *time.Time `json:"startTime,omitempty"`
}

OperationStatusResult - The current status of an async operation.

func (*OperationStatusResult) UnmarshalJSON added in v0.4.0 

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

UnmarshalJSON implements the json.Unmarshaller interface for type OperationStatusResult.

type OperationsClient 

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

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

func NewOperationsClient 

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

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

func (*OperationsClient) NewListPager added in v0.5.0 

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

NewListPager - Lists all of the available REST API operations of the Microsoft.Cache provider. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 options - OperationsClientListOptions contains the optional parameters for the OperationsClient.List method.

type OperationsClientListOptions added in v0.3.0 

type OperationsClientListOptions struct {
}

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

type OperationsClientListResponse added in v0.3.0 

type OperationsClientListResponse struct {
	OperationListResult
}

OperationsClientListResponse contains the response from method OperationsClient.List.

type PatchSchedule added in v0.3.0 

type PatchSchedule struct {
	// REQUIRED; List of patch schedules for a Redis cache.
	Properties *ScheduleEntries `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The geo-location where the resource lives
	Location *string `json:"location,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

PatchSchedule - Response to put/get patch schedules for Redis cache.

type PatchScheduleListResult added in v0.3.0 

type PatchScheduleListResult struct {
	// Results of the list patch schedules operation.
	Value []*PatchSchedule `json:"value,omitempty"`

	// READ-ONLY; Link for next page of results.
	NextLink *string `json:"nextLink,omitempty" azure:"ro"`
}

PatchScheduleListResult - The response of list patch schedules Redis operation.

type PatchSchedulesClient 

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

PatchSchedulesClient contains the methods for the PatchSchedules group. Don't use this type directly, use NewPatchSchedulesClient() instead.

func NewPatchSchedulesClient 

func NewPatchSchedulesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PatchSchedulesClient, error)

NewPatchSchedulesClient creates a new instance of PatchSchedulesClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*PatchSchedulesClient) CreateOrUpdate 

func (client *PatchSchedulesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, name string, defaultParam DefaultName, parameters PatchSchedule, options *PatchSchedulesClientCreateOrUpdateOptions) (PatchSchedulesClientCreateOrUpdateResponse, error)

CreateOrUpdate - Create or replace the patching schedule for Redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the Redis cache. defaultParam - Default string modeled as parameter for auto generation to work correctly. parameters - Parameters to set the patching schedule for Redis cache. options - PatchSchedulesClientCreateOrUpdateOptions contains the optional parameters for the PatchSchedulesClient.CreateOrUpdate method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCachePatchSchedulesCreateOrUpdate.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPatchSchedulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.CreateOrUpdate(ctx,
		"rg1",
		"cache1",
		armredis.DefaultNameDefault,
		armredis.PatchSchedule{
			Properties: &armredis.ScheduleEntries{
				ScheduleEntries: []*armredis.ScheduleEntry{
					{
						DayOfWeek:         to.Ptr(armredis.DayOfWeekMonday),
						MaintenanceWindow: to.Ptr("PT5H"),
						StartHourUTC:      to.Ptr[int32](12),
					},
					{
						DayOfWeek:    to.Ptr(armredis.DayOfWeekTuesday),
						StartHourUTC: to.Ptr[int32](12),
					}},
			},
		},
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*PatchSchedulesClient) Delete 

func (client *PatchSchedulesClient) Delete(ctx context.Context, resourceGroupName string, name string, defaultParam DefaultName, options *PatchSchedulesClientDeleteOptions) (PatchSchedulesClientDeleteResponse, error)

Delete - Deletes the patching schedule of a redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the redis cache. defaultParam - Default string modeled as parameter for auto generation to work correctly. options - PatchSchedulesClientDeleteOptions contains the optional parameters for the PatchSchedulesClient.Delete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCachePatchSchedulesDelete.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPatchSchedulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.Delete(ctx,
		"rg1",
		"cache1",
		armredis.DefaultNameDefault,
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*PatchSchedulesClient) Get 

func (client *PatchSchedulesClient) Get(ctx context.Context, resourceGroupName string, name string, defaultParam DefaultName, options *PatchSchedulesClientGetOptions) (PatchSchedulesClientGetResponse, error)

Get - Gets the patching schedule of a redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. name - The name of the redis cache. defaultParam - Default string modeled as parameter for auto generation to work correctly. options - PatchSchedulesClientGetOptions contains the optional parameters for the PatchSchedulesClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCachePatchSchedulesGet.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPatchSchedulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rg1",
		"cache1",
		armredis.DefaultNameDefault,
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*PatchSchedulesClient) NewListByRedisResourcePager added in v0.5.0 

func (client *PatchSchedulesClient) NewListByRedisResourcePager(resourceGroupName string, cacheName string, options *PatchSchedulesClientListByRedisResourceOptions) *runtime.Pager[PatchSchedulesClientListByRedisResourceResponse]

NewListByRedisResourcePager - Gets all patch schedules in the specified redis cache (there is only one). If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. options - PatchSchedulesClientListByRedisResourceOptions contains the optional parameters for the PatchSchedulesClient.ListByRedisResource method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCachePatchSchedulesList.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPatchSchedulesClient("subid", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByRedisResourcePager("rg1",
		"cache1",
		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 PatchSchedulesClientCreateOrUpdateOptions added in v0.3.0 

type PatchSchedulesClientCreateOrUpdateOptions struct {
}

PatchSchedulesClientCreateOrUpdateOptions contains the optional parameters for the PatchSchedulesClient.CreateOrUpdate method.

type PatchSchedulesClientCreateOrUpdateResponse added in v0.3.0 

type PatchSchedulesClientCreateOrUpdateResponse struct {
	PatchSchedule
}

PatchSchedulesClientCreateOrUpdateResponse contains the response from method PatchSchedulesClient.CreateOrUpdate.

type PatchSchedulesClientDeleteOptions added in v0.3.0 

type PatchSchedulesClientDeleteOptions struct {
}

PatchSchedulesClientDeleteOptions contains the optional parameters for the PatchSchedulesClient.Delete method.

type PatchSchedulesClientDeleteResponse added in v0.3.0 

type PatchSchedulesClientDeleteResponse struct {
}

PatchSchedulesClientDeleteResponse contains the response from method PatchSchedulesClient.Delete.

type PatchSchedulesClientGetOptions added in v0.3.0 

type PatchSchedulesClientGetOptions struct {
}

PatchSchedulesClientGetOptions contains the optional parameters for the PatchSchedulesClient.Get method.

type PatchSchedulesClientGetResponse added in v0.3.0 

type PatchSchedulesClientGetResponse struct {
	PatchSchedule
}

PatchSchedulesClientGetResponse contains the response from method PatchSchedulesClient.Get.

type PatchSchedulesClientListByRedisResourceOptions added in v0.3.0 

type PatchSchedulesClientListByRedisResourceOptions struct {
}

PatchSchedulesClientListByRedisResourceOptions contains the optional parameters for the PatchSchedulesClient.ListByRedisResource method.

type PatchSchedulesClientListByRedisResourceResponse added in v0.3.0 

type PatchSchedulesClientListByRedisResourceResponse struct {
	PatchScheduleListResult
}

PatchSchedulesClientListByRedisResourceResponse contains the response from method PatchSchedulesClient.ListByRedisResource.

type PrivateEndpoint 

type PrivateEndpoint struct {
	// READ-ONLY; The ARM identifier for Private Endpoint
	ID *string `json:"id,omitempty" azure:"ro"`
}

PrivateEndpoint - The Private Endpoint resource.

type PrivateEndpointConnection 

type PrivateEndpointConnection struct {
	// Resource properties.
	Properties *PrivateEndpointConnectionProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

PrivateEndpointConnection - The Private Endpoint Connection resource.

type PrivateEndpointConnectionListResult 

type PrivateEndpointConnectionListResult struct {
	// Array of private endpoint connections
	Value []*PrivateEndpointConnection `json:"value,omitempty"`
}

PrivateEndpointConnectionListResult - List of private endpoint connection associated with the specified storage account

type PrivateEndpointConnectionProperties 

type PrivateEndpointConnectionProperties struct {
	// REQUIRED; A collection of information about the state of the connection between service consumer and provider.
	PrivateLinkServiceConnectionState *PrivateLinkServiceConnectionState `json:"privateLinkServiceConnectionState,omitempty"`

	// The resource of private end point.
	PrivateEndpoint *PrivateEndpoint `json:"privateEndpoint,omitempty"`

	// READ-ONLY; The provisioning state of the private endpoint connection resource.
	ProvisioningState *PrivateEndpointConnectionProvisioningState `json:"provisioningState,omitempty" azure:"ro"`
}

PrivateEndpointConnectionProperties - Properties of the PrivateEndpointConnectProperties.

type PrivateEndpointConnectionProvisioningState 

type PrivateEndpointConnectionProvisioningState string

PrivateEndpointConnectionProvisioningState - The current provisioning state. 

const (
	PrivateEndpointConnectionProvisioningStateCreating  PrivateEndpointConnectionProvisioningState = "Creating"
	PrivateEndpointConnectionProvisioningStateDeleting  PrivateEndpointConnectionProvisioningState = "Deleting"
	PrivateEndpointConnectionProvisioningStateFailed    PrivateEndpointConnectionProvisioningState = "Failed"
	PrivateEndpointConnectionProvisioningStateSucceeded PrivateEndpointConnectionProvisioningState = "Succeeded"
)

func PossiblePrivateEndpointConnectionProvisioningStateValues 

func PossiblePrivateEndpointConnectionProvisioningStateValues() []PrivateEndpointConnectionProvisioningState

PossiblePrivateEndpointConnectionProvisioningStateValues returns the possible values for the PrivateEndpointConnectionProvisioningState const type.

type PrivateEndpointConnectionsClient 

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

PrivateEndpointConnectionsClient contains the methods for the PrivateEndpointConnections group. Don't use this type directly, use NewPrivateEndpointConnectionsClient() instead.

func NewPrivateEndpointConnectionsClient 

func NewPrivateEndpointConnectionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateEndpointConnectionsClient, error)

NewPrivateEndpointConnectionsClient creates a new instance of PrivateEndpointConnectionsClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*PrivateEndpointConnectionsClient) BeginPut 

func (client *PrivateEndpointConnectionsClient) BeginPut(ctx context.Context, resourceGroupName string, cacheName string, privateEndpointConnectionName string, properties PrivateEndpointConnection, options *PrivateEndpointConnectionsClientBeginPutOptions) (*runtime.Poller[PrivateEndpointConnectionsClientPutResponse], error)

BeginPut - Update the state of specified private endpoint connection associated with the redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource properties - The private endpoint connection properties. options - PrivateEndpointConnectionsClientBeginPutOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginPut method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCachePutPrivateEndpointConnection.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/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPrivateEndpointConnectionsClient("{subscriptionId}", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := client.BeginPut(ctx,
		"rgtest01",
		"cachetest01",
		"pectest01",
		armredis.PrivateEndpointConnection{
			Properties: &armredis.PrivateEndpointConnectionProperties{
				PrivateLinkServiceConnectionState: &armredis.PrivateLinkServiceConnectionState{
					Description: to.Ptr("Auto-Approved"),
					Status:      to.Ptr(armredis.PrivateEndpointServiceConnectionStatusApproved),
				},
			},
		},
		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 (*PrivateEndpointConnectionsClient) Delete 

func (client *PrivateEndpointConnectionsClient) Delete(ctx context.Context, resourceGroupName string, cacheName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientDeleteOptions) (PrivateEndpointConnectionsClientDeleteResponse, error)

Delete - Deletes the specified private endpoint connection associated with the redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource options - PrivateEndpointConnectionsClientDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Delete method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheDeletePrivateEndpointConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPrivateEndpointConnectionsClient("{subscriptionId}", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	_, err = client.Delete(ctx,
		"rgtest01",
		"cachetest01",
		"pectest01",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
}

Output:

func (*PrivateEndpointConnectionsClient) Get 

func (client *PrivateEndpointConnectionsClient) Get(ctx context.Context, resourceGroupName string, cacheName string, privateEndpointConnectionName string, options *PrivateEndpointConnectionsClientGetOptions) (PrivateEndpointConnectionsClientGetResponse, error)

Get - Gets the specified private endpoint connection associated with the redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. privateEndpointConnectionName - The name of the private endpoint connection associated with the Azure resource options - PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheGetPrivateEndpointConnection.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPrivateEndpointConnectionsClient("{subscriptionId}", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := client.Get(ctx,
		"rgtest01",
		"cachetest01",
		"pectest01",
		nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// TODO: use response item
	_ = res
}

Output:

func (*PrivateEndpointConnectionsClient) NewListPager added in v0.5.0 

func (client *PrivateEndpointConnectionsClient) NewListPager(resourceGroupName string, cacheName string, options *PrivateEndpointConnectionsClientListOptions) *runtime.Pager[PrivateEndpointConnectionsClientListResponse]

NewListPager - List all the private endpoint connections associated with the redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. options - PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.List method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheListPrivateEndpointConnections.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPrivateEndpointConnectionsClient("{subscriptionId}", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListPager("rgtest01",
		"cachetest01",
		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 PrivateEndpointConnectionsClientBeginPutOptions added in v0.3.0 

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

PrivateEndpointConnectionsClientBeginPutOptions contains the optional parameters for the PrivateEndpointConnectionsClient.BeginPut method.

type PrivateEndpointConnectionsClientDeleteOptions added in v0.3.0 

type PrivateEndpointConnectionsClientDeleteOptions struct {
}

PrivateEndpointConnectionsClientDeleteOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Delete method.

type PrivateEndpointConnectionsClientDeleteResponse added in v0.3.0 

type PrivateEndpointConnectionsClientDeleteResponse struct {
}

PrivateEndpointConnectionsClientDeleteResponse contains the response from method PrivateEndpointConnectionsClient.Delete.

type PrivateEndpointConnectionsClientGetOptions added in v0.3.0 

type PrivateEndpointConnectionsClientGetOptions struct {
}

PrivateEndpointConnectionsClientGetOptions contains the optional parameters for the PrivateEndpointConnectionsClient.Get method.

type PrivateEndpointConnectionsClientGetResponse added in v0.3.0 

type PrivateEndpointConnectionsClientGetResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientGetResponse contains the response from method PrivateEndpointConnectionsClient.Get.

type PrivateEndpointConnectionsClientListOptions added in v0.3.0 

type PrivateEndpointConnectionsClientListOptions struct {
}

PrivateEndpointConnectionsClientListOptions contains the optional parameters for the PrivateEndpointConnectionsClient.List method.

type PrivateEndpointConnectionsClientListResponse added in v0.3.0 

type PrivateEndpointConnectionsClientListResponse struct {
	PrivateEndpointConnectionListResult
}

PrivateEndpointConnectionsClientListResponse contains the response from method PrivateEndpointConnectionsClient.List.

type PrivateEndpointConnectionsClientPutResponse added in v0.3.0 

type PrivateEndpointConnectionsClientPutResponse struct {
	PrivateEndpointConnection
}

PrivateEndpointConnectionsClientPutResponse contains the response from method PrivateEndpointConnectionsClient.Put.

type PrivateEndpointServiceConnectionStatus 

type PrivateEndpointServiceConnectionStatus string

PrivateEndpointServiceConnectionStatus - The private endpoint connection status. 

const (
	PrivateEndpointServiceConnectionStatusApproved PrivateEndpointServiceConnectionStatus = "Approved"
	PrivateEndpointServiceConnectionStatusPending  PrivateEndpointServiceConnectionStatus = "Pending"
	PrivateEndpointServiceConnectionStatusRejected PrivateEndpointServiceConnectionStatus = "Rejected"
)

func PossiblePrivateEndpointServiceConnectionStatusValues 

func PossiblePrivateEndpointServiceConnectionStatusValues() []PrivateEndpointServiceConnectionStatus

PossiblePrivateEndpointServiceConnectionStatusValues returns the possible values for the PrivateEndpointServiceConnectionStatus const type.

type PrivateLinkResource 

type PrivateLinkResource struct {
	// Resource properties.
	Properties *PrivateLinkResourceProperties `json:"properties,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

PrivateLinkResource - A private link resource

type PrivateLinkResourceListResult 

type PrivateLinkResourceListResult struct {
	// Array of private link resources
	Value []*PrivateLinkResource `json:"value,omitempty"`
}

PrivateLinkResourceListResult - A list of private link resources

type PrivateLinkResourceProperties 

type PrivateLinkResourceProperties struct {
	// The private link resource Private link DNS zone name.
	RequiredZoneNames []*string `json:"requiredZoneNames,omitempty"`

	// READ-ONLY; The private link resource group id.
	GroupID *string `json:"groupId,omitempty" azure:"ro"`

	// READ-ONLY; The private link resource required member names.
	RequiredMembers []*string `json:"requiredMembers,omitempty" azure:"ro"`
}

PrivateLinkResourceProperties - Properties of a private link resource.

func (PrivateLinkResourceProperties) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type PrivateLinkResourceProperties.

type PrivateLinkResourcesClient 

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

PrivateLinkResourcesClient contains the methods for the PrivateLinkResources group. Don't use this type directly, use NewPrivateLinkResourcesClient() instead.

func NewPrivateLinkResourcesClient 

func NewPrivateLinkResourcesClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PrivateLinkResourcesClient, error)

NewPrivateLinkResourcesClient creates a new instance of PrivateLinkResourcesClient with the specified values. subscriptionID - Gets subscription credentials which uniquely identify the Microsoft Azure subscription. The subscription ID forms part of the URI for every service call. credential - used to authorize requests. Usually a credential from azidentity. options - pass nil to accept the default values.

func (*PrivateLinkResourcesClient) NewListByRedisCachePager added in v0.5.0 

func (client *PrivateLinkResourcesClient) NewListByRedisCachePager(resourceGroupName string, cacheName string, options *PrivateLinkResourcesClientListByRedisCacheOptions) *runtime.Pager[PrivateLinkResourcesClientListByRedisCacheResponse]

NewListByRedisCachePager - Gets the private link resources that need to be created for a redis cache. If the operation fails it returns an *azcore.ResponseError type. Generated from API version 2021-06-01 resourceGroupName - The name of the resource group. cacheName - The name of the Redis cache. options - PrivateLinkResourcesClientListByRedisCacheOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByRedisCache method.

Example

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/tree/main/specification/redis/resource-manager/Microsoft.Cache/stable/2021-06-01/examples/RedisCacheListPrivateLinkResources.json 

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redis/armredis"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	client, err := armredis.NewPrivateLinkResourcesClient("{subscription-id}", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := client.NewListByRedisCachePager("rgtest01",
		"cacheTest01",
		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 PrivateLinkResourcesClientListByRedisCacheOptions added in v0.3.0 

type PrivateLinkResourcesClientListByRedisCacheOptions struct {
}

PrivateLinkResourcesClientListByRedisCacheOptions contains the optional parameters for the PrivateLinkResourcesClient.ListByRedisCache method.

type PrivateLinkResourcesClientListByRedisCacheResponse added in v0.3.0 

type PrivateLinkResourcesClientListByRedisCacheResponse struct {
	PrivateLinkResourceListResult
}

PrivateLinkResourcesClientListByRedisCacheResponse contains the response from method PrivateLinkResourcesClient.ListByRedisCache.

type PrivateLinkServiceConnectionState 

type PrivateLinkServiceConnectionState struct {
	// A message indicating if changes on the service provider require any updates on the consumer.
	ActionsRequired *string `json:"actionsRequired,omitempty"`

	// The reason for approval/rejection of the connection.
	Description *string `json:"description,omitempty"`

	// Indicates whether the connection has been Approved/Rejected/Removed by the owner of the service.
	Status *PrivateEndpointServiceConnectionStatus `json:"status,omitempty"`
}

PrivateLinkServiceConnectionState - A collection of information about the state of the connection between service consumer and provider.

type Properties added in v0.3.0 

type Properties struct {
	// REQUIRED; The SKU of the Redis cache to deploy.
	SKU *SKU `json:"sku,omitempty"`

	// Specifies whether the non-ssl Redis server port (6379) is enabled.
	EnableNonSSLPort *bool `json:"enableNonSslPort,omitempty"`

	// Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')
	MinimumTLSVersion *TLSVersion `json:"minimumTlsVersion,omitempty"`

	// Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled'
	// or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method.
	// Default value is 'Enabled'
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// All Redis Settings. Few possible keys:
	// rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
	// etc.
	RedisConfiguration *CommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`

	// Redis version. Only major version will be used in PUT/PATCH request with current valid values: (4, 6)
	RedisVersion *string `json:"redisVersion,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerMaster *int32 `json:"replicasPerMaster,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerPrimary *int32 `json:"replicasPerPrimary,omitempty"`

	// The number of shards to be created on a Premium Cluster Cache.
	ShardCount *int32 `json:"shardCount,omitempty"`

	// Static IP address. Optionally, may be specified when deploying a Redis cache inside an existing Azure Virtual Network;
	// auto assigned by default.
	StaticIP *string `json:"staticIP,omitempty"`

	// The full resource ID of a subnet in a virtual network to deploy the Redis cache in. Example format:
	// /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Microsoft.{Network|ClassicNetwork}/VirtualNetworks/vnet1/subnets/subnet1
	SubnetID *string `json:"subnetId,omitempty"`

	// A dictionary of tenant settings
	TenantSettings map[string]*string `json:"tenantSettings,omitempty"`

	// READ-ONLY; The keys of the Redis cache - not set if this object is not the response to Create or Update redis cache
	AccessKeys *AccessKeys `json:"accessKeys,omitempty" azure:"ro"`

	// READ-ONLY; Redis host name.
	HostName *string `json:"hostName,omitempty" azure:"ro"`

	// READ-ONLY; List of the Redis instances associated with the cache
	Instances []*InstanceDetails `json:"instances,omitempty" azure:"ro"`

	// READ-ONLY; List of the linked servers associated with the cache
	LinkedServers []*LinkedServer `json:"linkedServers,omitempty" azure:"ro"`

	// READ-ONLY; Redis non-SSL port.
	Port *int32 `json:"port,omitempty" azure:"ro"`

	// READ-ONLY; List of private endpoint connection associated with the specified redis cache
	PrivateEndpointConnections []*PrivateEndpointConnection `json:"privateEndpointConnections,omitempty" azure:"ro"`

	// READ-ONLY; Redis instance provisioning status.
	ProvisioningState *ProvisioningState `json:"provisioningState,omitempty" azure:"ro"`

	// READ-ONLY; Redis SSL port.
	SSLPort *int32 `json:"sslPort,omitempty" azure:"ro"`
}

Properties of the redis cache.

func (Properties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type Properties.

type ProvisioningState 

type ProvisioningState string

ProvisioningState - Redis instance provisioning status. 

const (
	ProvisioningStateCreating               ProvisioningState = "Creating"
	ProvisioningStateDeleting               ProvisioningState = "Deleting"
	ProvisioningStateDisabled               ProvisioningState = "Disabled"
	ProvisioningStateFailed                 ProvisioningState = "Failed"
	ProvisioningStateLinking                ProvisioningState = "Linking"
	ProvisioningStateProvisioning           ProvisioningState = "Provisioning"
	ProvisioningStateRecoveringScaleFailure ProvisioningState = "RecoveringScaleFailure"
	ProvisioningStateScaling                ProvisioningState = "Scaling"
	ProvisioningStateSucceeded              ProvisioningState = "Succeeded"
	ProvisioningStateUnlinking              ProvisioningState = "Unlinking"
	ProvisioningStateUnprovisioning         ProvisioningState = "Unprovisioning"
	ProvisioningStateUpdating               ProvisioningState = "Updating"
)

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 `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

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

type PublicNetworkAccess 

type PublicNetworkAccess string

PublicNetworkAccess - Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled' or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method. Default value is 'Enabled' 

const (
	PublicNetworkAccessDisabled PublicNetworkAccess = "Disabled"
	PublicNetworkAccessEnabled  PublicNetworkAccess = "Enabled"
)

func PossiblePublicNetworkAccessValues 

func PossiblePublicNetworkAccessValues() []PublicNetworkAccess

PossiblePublicNetworkAccessValues returns the possible values for the PublicNetworkAccess const type.

type RebootParameters added in v0.3.0 

type RebootParameters struct {
	// A list of redis instances to reboot, specified by per-instance SSL ports or non-SSL ports.
	Ports []*int32 `json:"ports,omitempty"`

	// Which Redis node(s) to reboot. Depending on this value data loss is possible.
	RebootType *RebootType `json:"rebootType,omitempty"`

	// If clustering is enabled, the ID of the shard to be rebooted.
	ShardID *int32 `json:"shardId,omitempty"`
}

RebootParameters - Specifies which Redis node(s) to reboot.

func (RebootParameters) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type RebootParameters.

type RebootType 

type RebootType string

RebootType - Which Redis node(s) to reboot. Depending on this value data loss is possible. 

const (
	RebootTypeAllNodes      RebootType = "AllNodes"
	RebootTypePrimaryNode   RebootType = "PrimaryNode"
	RebootTypeSecondaryNode RebootType = "SecondaryNode"
)

func PossibleRebootTypeValues 

func PossibleRebootTypeValues() []RebootType

PossibleRebootTypeValues returns the possible values for the RebootType const type.

type RedisKeyType 

type RedisKeyType string

RedisKeyType - The Redis access key to regenerate. 

const (
	RedisKeyTypePrimary   RedisKeyType = "Primary"
	RedisKeyTypeSecondary RedisKeyType = "Secondary"
)

func PossibleRedisKeyTypeValues 

func PossibleRedisKeyTypeValues() []RedisKeyType

PossibleRedisKeyTypeValues returns the possible values for the RedisKeyType const type.

type RegenerateKeyParameters added in v0.3.0 

type RegenerateKeyParameters struct {
	// REQUIRED; The Redis access key to regenerate.
	KeyType *RedisKeyType `json:"keyType,omitempty"`
}

RegenerateKeyParameters - Specifies which Redis access keys to reset.

type ReplicationRole 

type ReplicationRole string

ReplicationRole - Role of the linked server. 

const (
	ReplicationRolePrimary   ReplicationRole = "Primary"
	ReplicationRoleSecondary ReplicationRole = "Secondary"
)

func PossibleReplicationRoleValues 

func PossibleReplicationRoleValues() []ReplicationRole

PossibleReplicationRoleValues returns the possible values for the ReplicationRole const type.

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 `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

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

type ResourceInfo added in v0.3.0 

type ResourceInfo struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

	// REQUIRED; Redis cache properties.
	Properties *Properties `json:"properties,omitempty"`

	// The identity of the resource.
	Identity *ManagedServiceIdentity `json:"identity,omitempty"`

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

	// A list of availability zones denoting where the resource needs to come from.
	Zones []*string `json:"zones,omitempty"`

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

ResourceInfo - A single Redis item in List or Get Operation.

func (ResourceInfo) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type ResourceInfo.

type SKU 

type SKU struct {
	// REQUIRED; The size of the Redis cache to deploy. Valid values: for C (Basic/Standard) family (0, 1, 2, 3, 4, 5, 6), for
	// P (Premium) family (1, 2, 3, 4).
	Capacity *int32 `json:"capacity,omitempty"`

	// REQUIRED; The SKU family to use. Valid values: (C, P). (C = Basic/Standard, P = Premium).
	Family *SKUFamily `json:"family,omitempty"`

	// REQUIRED; The type of Redis cache to deploy. Valid values: (Basic, Standard, Premium)
	Name *SKUName `json:"name,omitempty"`
}

SKU parameters supplied to the create Redis operation.

type SKUFamily 

type SKUFamily string

SKUFamily - The SKU family to use. Valid values: (C, P). (C = Basic/Standard, P = Premium). 

const (
	SKUFamilyC SKUFamily = "C"
	SKUFamilyP SKUFamily = "P"
)

func PossibleSKUFamilyValues 

func PossibleSKUFamilyValues() []SKUFamily

PossibleSKUFamilyValues returns the possible values for the SKUFamily const type.

type SKUName 

type SKUName string

SKUName - The type of Redis cache to deploy. Valid values: (Basic, Standard, Premium) 

const (
	SKUNameBasic    SKUName = "Basic"
	SKUNamePremium  SKUName = "Premium"
	SKUNameStandard SKUName = "Standard"
)

func PossibleSKUNameValues 

func PossibleSKUNameValues() []SKUName

PossibleSKUNameValues returns the possible values for the SKUName const type.

type ScheduleEntries 

type ScheduleEntries struct {
	// REQUIRED; List of patch schedules for a Redis cache.
	ScheduleEntries []*ScheduleEntry `json:"scheduleEntries,omitempty"`
}

ScheduleEntries - List of patch schedules for a Redis cache.

func (ScheduleEntries) MarshalJSON 

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

MarshalJSON implements the json.Marshaller interface for type ScheduleEntries.

type ScheduleEntry 

type ScheduleEntry struct {
	// REQUIRED; Day of the week when a cache can be patched.
	DayOfWeek *DayOfWeek `json:"dayOfWeek,omitempty"`

	// REQUIRED; Start hour after which cache patching can start.
	StartHourUTC *int32 `json:"startHourUtc,omitempty"`

	// ISO8601 timespan specifying how much time cache patching can take.
	MaintenanceWindow *string `json:"maintenanceWindow,omitempty"`
}

ScheduleEntry - Patch schedule entry for a Premium Redis Cache.

type TLSVersion 

type TLSVersion string

TLSVersion - Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2') 

const (
	TLSVersionOne0 TLSVersion = "1.0"
	TLSVersionOne1 TLSVersion = "1.1"
	TLSVersionOne2 TLSVersion = "1.2"
)

func PossibleTLSVersionValues 

func PossibleTLSVersionValues() []TLSVersion

PossibleTLSVersionValues returns the possible values for the TLSVersion const type.

type TrackedResource 

type TrackedResource struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string `json:"location,omitempty"`

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

	// READ-ONLY; Fully qualified resource ID for the resource. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
	ID *string `json:"id,omitempty" azure:"ro"`

	// READ-ONLY; The name of the resource
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string `json:"type,omitempty" azure:"ro"`
}

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.

type UpdateParameters added in v0.3.0 

type UpdateParameters struct {
	// The identity of the resource.
	Identity *ManagedServiceIdentity `json:"identity,omitempty"`

	// Redis cache properties.
	Properties *UpdateProperties `json:"properties,omitempty"`

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

UpdateParameters - Parameters supplied to the Update Redis operation.

func (UpdateParameters) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateParameters.

type UpdateProperties added in v0.3.0 

type UpdateProperties struct {
	// Specifies whether the non-ssl Redis server port (6379) is enabled.
	EnableNonSSLPort *bool `json:"enableNonSslPort,omitempty"`

	// Optional: requires clients to use a specified TLS version (or higher) to connect (e,g, '1.0', '1.1', '1.2')
	MinimumTLSVersion *TLSVersion `json:"minimumTlsVersion,omitempty"`

	// Whether or not public endpoint access is allowed for this cache. Value is optional but if passed in, must be 'Enabled'
	// or 'Disabled'. If 'Disabled', private endpoints are the exclusive access method.
	// Default value is 'Enabled'
	PublicNetworkAccess *PublicNetworkAccess `json:"publicNetworkAccess,omitempty"`

	// All Redis Settings. Few possible keys:
	// rdb-backup-enabled,rdb-storage-connection-string,rdb-backup-frequency,maxmemory-delta,maxmemory-policy,notify-keyspace-events,maxmemory-samples,slowlog-log-slower-than,slowlog-max-len,list-max-ziplist-entries,list-max-ziplist-value,hash-max-ziplist-entries,hash-max-ziplist-value,set-max-intset-entries,zset-max-ziplist-entries,zset-max-ziplist-value
	// etc.
	RedisConfiguration *CommonPropertiesRedisConfiguration `json:"redisConfiguration,omitempty"`

	// Redis version. Only major version will be used in PUT/PATCH request with current valid values: (4, 6)
	RedisVersion *string `json:"redisVersion,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerMaster *int32 `json:"replicasPerMaster,omitempty"`

	// The number of replicas to be created per primary.
	ReplicasPerPrimary *int32 `json:"replicasPerPrimary,omitempty"`

	// The SKU of the Redis cache to deploy.
	SKU *SKU `json:"sku,omitempty"`

	// The number of shards to be created on a Premium Cluster Cache.
	ShardCount *int32 `json:"shardCount,omitempty"`

	// A dictionary of tenant settings
	TenantSettings map[string]*string `json:"tenantSettings,omitempty"`
}

UpdateProperties - Patchable properties of the redis cache.

func (UpdateProperties) MarshalJSON added in v0.3.0 

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

MarshalJSON implements the json.Marshaller interface for type UpdateProperties.

type UpgradeNotification 

type UpgradeNotification struct {
	// READ-ONLY; Name of upgrade notification.
	Name *string `json:"name,omitempty" azure:"ro"`

	// READ-ONLY; Timestamp when upgrade notification occurred.
	Timestamp *time.Time `json:"timestamp,omitempty" azure:"ro"`

	// READ-ONLY; Details about this upgrade notification
	UpsellNotification map[string]*string `json:"upsellNotification,omitempty" azure:"ro"`
}

UpgradeNotification - Properties of upgrade notification.

func (*UpgradeNotification) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaller interface for type UpgradeNotification.

type UserAssignedIdentity added in v0.3.0 

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string `json:"clientId,omitempty" azure:"ro"`

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string `json:"principalId,omitempty" azure:"ro"`
}

UserAssignedIdentity - User assigned identity properties

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.