com.pulumi.azure.redis.kotlin.LinkedServerArgs.kt Maven / Gradle / Ivy
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.azure.redis.kotlin
import com.pulumi.azure.redis.LinkedServerArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import kotlin.String
import kotlin.Suppress
import kotlin.jvm.JvmName
/**
* Manages a Redis Linked Server (ie Geo Location)
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as azure from "@pulumi/azure";
* const example_primary = new azure.core.ResourceGroup("example-primary", {
* name: "example-resources-primary",
* location: "East US",
* });
* const example_primaryCache = new azure.redis.Cache("example-primary", {
* name: "example-cache1",
* location: example_primary.location,
* resourceGroupName: example_primary.name,
* capacity: 1,
* family: "P",
* skuName: "Premium",
* enableNonSslPort: false,
* redisConfiguration: {
* maxmemoryReserved: 2,
* maxmemoryDelta: 2,
* maxmemoryPolicy: "allkeys-lru",
* },
* });
* const example_secondary = new azure.core.ResourceGroup("example-secondary", {
* name: "example-resources-secondary",
* location: "West US",
* });
* const example_secondaryCache = new azure.redis.Cache("example-secondary", {
* name: "example-cache2",
* location: example_secondary.location,
* resourceGroupName: example_secondary.name,
* capacity: 1,
* family: "P",
* skuName: "Premium",
* enableNonSslPort: false,
* redisConfiguration: {
* maxmemoryReserved: 2,
* maxmemoryDelta: 2,
* maxmemoryPolicy: "allkeys-lru",
* },
* });
* const example_link = new azure.redis.LinkedServer("example-link", {
* targetRedisCacheName: example_primaryCache.name,
* resourceGroupName: example_primaryCache.resourceGroupName,
* linkedRedisCacheId: example_secondaryCache.id,
* linkedRedisCacheLocation: example_secondaryCache.location,
* serverRole: "Secondary",
* });
* ```
* ```python
* import pulumi
* import pulumi_azure as azure
* example_primary = azure.core.ResourceGroup("example-primary",
* name="example-resources-primary",
* location="East US")
* example_primary_cache = azure.redis.Cache("example-primary",
* name="example-cache1",
* location=example_primary.location,
* resource_group_name=example_primary.name,
* capacity=1,
* family="P",
* sku_name="Premium",
* enable_non_ssl_port=False,
* redis_configuration=azure.redis.CacheRedisConfigurationArgs(
* maxmemory_reserved=2,
* maxmemory_delta=2,
* maxmemory_policy="allkeys-lru",
* ))
* example_secondary = azure.core.ResourceGroup("example-secondary",
* name="example-resources-secondary",
* location="West US")
* example_secondary_cache = azure.redis.Cache("example-secondary",
* name="example-cache2",
* location=example_secondary.location,
* resource_group_name=example_secondary.name,
* capacity=1,
* family="P",
* sku_name="Premium",
* enable_non_ssl_port=False,
* redis_configuration=azure.redis.CacheRedisConfigurationArgs(
* maxmemory_reserved=2,
* maxmemory_delta=2,
* maxmemory_policy="allkeys-lru",
* ))
* example_link = azure.redis.LinkedServer("example-link",
* target_redis_cache_name=example_primary_cache.name,
* resource_group_name=example_primary_cache.resource_group_name,
* linked_redis_cache_id=example_secondary_cache.id,
* linked_redis_cache_location=example_secondary_cache.location,
* server_role="Secondary")
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Azure = Pulumi.Azure;
* return await Deployment.RunAsync(() =>
* {
* var example_primary = new Azure.Core.ResourceGroup("example-primary", new()
* {
* Name = "example-resources-primary",
* Location = "East US",
* });
* var example_primaryCache = new Azure.Redis.Cache("example-primary", new()
* {
* Name = "example-cache1",
* Location = example_primary.Location,
* ResourceGroupName = example_primary.Name,
* Capacity = 1,
* Family = "P",
* SkuName = "Premium",
* EnableNonSslPort = false,
* RedisConfiguration = new Azure.Redis.Inputs.CacheRedisConfigurationArgs
* {
* MaxmemoryReserved = 2,
* MaxmemoryDelta = 2,
* MaxmemoryPolicy = "allkeys-lru",
* },
* });
* var example_secondary = new Azure.Core.ResourceGroup("example-secondary", new()
* {
* Name = "example-resources-secondary",
* Location = "West US",
* });
* var example_secondaryCache = new Azure.Redis.Cache("example-secondary", new()
* {
* Name = "example-cache2",
* Location = example_secondary.Location,
* ResourceGroupName = example_secondary.Name,
* Capacity = 1,
* Family = "P",
* SkuName = "Premium",
* EnableNonSslPort = false,
* RedisConfiguration = new Azure.Redis.Inputs.CacheRedisConfigurationArgs
* {
* MaxmemoryReserved = 2,
* MaxmemoryDelta = 2,
* MaxmemoryPolicy = "allkeys-lru",
* },
* });
* var example_link = new Azure.Redis.LinkedServer("example-link", new()
* {
* TargetRedisCacheName = example_primaryCache.Name,
* ResourceGroupName = example_primaryCache.ResourceGroupName,
* LinkedRedisCacheId = example_secondaryCache.Id,
* LinkedRedisCacheLocation = example_secondaryCache.Location,
* ServerRole = "Secondary",
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/redis"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* _, err := core.NewResourceGroup(ctx, "example-primary", &core.ResourceGroupArgs{
* Name: pulumi.String("example-resources-primary"),
* Location: pulumi.String("East US"),
* })
* if err != nil {
* return err
* }
* _, err = redis.NewCache(ctx, "example-primary", &redis.CacheArgs{
* Name: pulumi.String("example-cache1"),
* Location: example_primary.Location,
* ResourceGroupName: example_primary.Name,
* Capacity: pulumi.Int(1),
* Family: pulumi.String("P"),
* SkuName: pulumi.String("Premium"),
* EnableNonSslPort: pulumi.Bool(false),
* RedisConfiguration: &redis.CacheRedisConfigurationArgs{
* MaxmemoryReserved: pulumi.Int(2),
* MaxmemoryDelta: pulumi.Int(2),
* MaxmemoryPolicy: pulumi.String("allkeys-lru"),
* },
* })
* if err != nil {
* return err
* }
* _, err = core.NewResourceGroup(ctx, "example-secondary", &core.ResourceGroupArgs{
* Name: pulumi.String("example-resources-secondary"),
* Location: pulumi.String("West US"),
* })
* if err != nil {
* return err
* }
* _, err = redis.NewCache(ctx, "example-secondary", &redis.CacheArgs{
* Name: pulumi.String("example-cache2"),
* Location: example_secondary.Location,
* ResourceGroupName: example_secondary.Name,
* Capacity: pulumi.Int(1),
* Family: pulumi.String("P"),
* SkuName: pulumi.String("Premium"),
* EnableNonSslPort: pulumi.Bool(false),
* RedisConfiguration: &redis.CacheRedisConfigurationArgs{
* MaxmemoryReserved: pulumi.Int(2),
* MaxmemoryDelta: pulumi.Int(2),
* MaxmemoryPolicy: pulumi.String("allkeys-lru"),
* },
* })
* if err != nil {
* return err
* }
* _, err = redis.NewLinkedServer(ctx, "example-link", &redis.LinkedServerArgs{
* TargetRedisCacheName: example_primaryCache.Name,
* ResourceGroupName: example_primaryCache.ResourceGroupName,
* LinkedRedisCacheId: example_secondaryCache.ID(),
* LinkedRedisCacheLocation: example_secondaryCache.Location,
* ServerRole: pulumi.String("Secondary"),
* })
* if err != nil {
* return err
* }
* return nil
* })
* }
* ```
* ```java
* package generated_program;
* import com.pulumi.Context;
* import com.pulumi.Pulumi;
* import com.pulumi.core.Output;
* import com.pulumi.azure.core.ResourceGroup;
* import com.pulumi.azure.core.ResourceGroupArgs;
* import com.pulumi.azure.redis.Cache;
* import com.pulumi.azure.redis.CacheArgs;
* import com.pulumi.azure.redis.inputs.CacheRedisConfigurationArgs;
* import com.pulumi.azure.redis.LinkedServer;
* import com.pulumi.azure.redis.LinkedServerArgs;
* import java.util.List;
* import java.util.ArrayList;
* import java.util.Map;
* import java.io.File;
* import java.nio.file.Files;
* import java.nio.file.Paths;
* public class App {
* public static void main(String[] args) {
* Pulumi.run(App::stack);
* }
* public static void stack(Context ctx) {
* var example_primary = new ResourceGroup("example-primary", ResourceGroupArgs.builder()
* .name("example-resources-primary")
* .location("East US")
* .build());
* var example_primaryCache = new Cache("example-primaryCache", CacheArgs.builder()
* .name("example-cache1")
* .location(example_primary.location())
* .resourceGroupName(example_primary.name())
* .capacity(1)
* .family("P")
* .skuName("Premium")
* .enableNonSslPort(false)
* .redisConfiguration(CacheRedisConfigurationArgs.builder()
* .maxmemoryReserved(2)
* .maxmemoryDelta(2)
* .maxmemoryPolicy("allkeys-lru")
* .build())
* .build());
* var example_secondary = new ResourceGroup("example-secondary", ResourceGroupArgs.builder()
* .name("example-resources-secondary")
* .location("West US")
* .build());
* var example_secondaryCache = new Cache("example-secondaryCache", CacheArgs.builder()
* .name("example-cache2")
* .location(example_secondary.location())
* .resourceGroupName(example_secondary.name())
* .capacity(1)
* .family("P")
* .skuName("Premium")
* .enableNonSslPort(false)
* .redisConfiguration(CacheRedisConfigurationArgs.builder()
* .maxmemoryReserved(2)
* .maxmemoryDelta(2)
* .maxmemoryPolicy("allkeys-lru")
* .build())
* .build());
* var example_link = new LinkedServer("example-link", LinkedServerArgs.builder()
* .targetRedisCacheName(example_primaryCache.name())
* .resourceGroupName(example_primaryCache.resourceGroupName())
* .linkedRedisCacheId(example_secondaryCache.id())
* .linkedRedisCacheLocation(example_secondaryCache.location())
* .serverRole("Secondary")
* .build());
* }
* }
* ```
* ```yaml
* resources:
* example-primary:
* type: azure:core:ResourceGroup
* properties:
* name: example-resources-primary
* location: East US
* example-primaryCache:
* type: azure:redis:Cache
* name: example-primary
* properties:
* name: example-cache1
* location: ${["example-primary"].location}
* resourceGroupName: ${["example-primary"].name}
* capacity: 1
* family: P
* skuName: Premium
* enableNonSslPort: false
* redisConfiguration:
* maxmemoryReserved: 2
* maxmemoryDelta: 2
* maxmemoryPolicy: allkeys-lru
* example-secondary:
* type: azure:core:ResourceGroup
* properties:
* name: example-resources-secondary
* location: West US
* example-secondaryCache:
* type: azure:redis:Cache
* name: example-secondary
* properties:
* name: example-cache2
* location: ${["example-secondary"].location}
* resourceGroupName: ${["example-secondary"].name}
* capacity: 1
* family: P
* skuName: Premium
* enableNonSslPort: false
* redisConfiguration:
* maxmemoryReserved: 2
* maxmemoryDelta: 2
* maxmemoryPolicy: allkeys-lru
* example-link:
* type: azure:redis:LinkedServer
* properties:
* targetRedisCacheName: ${["example-primaryCache"].name}
* resourceGroupName: ${["example-primaryCache"].resourceGroupName}
* linkedRedisCacheId: ${["example-secondaryCache"].id}
* linkedRedisCacheLocation: ${["example-secondaryCache"].location}
* serverRole: Secondary
* ```
*
* ## Import
* Redis can be imported using the `resource id`, e.g.
* ```sh
* $ pulumi import azure:redis/linkedServer:LinkedServer example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Cache/redis/cache1/linkedServers/cache2
* ```
* @property linkedRedisCacheId The ID of the linked Redis cache. Changing this forces a new Redis to be created.
* @property linkedRedisCacheLocation The location of the linked Redis cache. Changing this forces a new Redis to be created.
* @property resourceGroupName The name of the Resource Group where the Redis caches exists. Changing this forces a new Redis to be created.
* @property serverRole The role of the linked Redis cache (eg "Secondary"). Changing this forces a new Redis to be created. Possible values are `Primary` and `Secondary`.
* @property targetRedisCacheName The name of Redis cache to link with. Changing this forces a new Redis to be created. (eg The primary role)
*/
public data class LinkedServerArgs(
public val linkedRedisCacheId: Output? = null,
public val linkedRedisCacheLocation: Output? = null,
public val resourceGroupName: Output? = null,
public val serverRole: Output? = null,
public val targetRedisCacheName: Output? = null,
) : ConvertibleToJava {
override fun toJava(): com.pulumi.azure.redis.LinkedServerArgs =
com.pulumi.azure.redis.LinkedServerArgs.builder()
.linkedRedisCacheId(linkedRedisCacheId?.applyValue({ args0 -> args0 }))
.linkedRedisCacheLocation(linkedRedisCacheLocation?.applyValue({ args0 -> args0 }))
.resourceGroupName(resourceGroupName?.applyValue({ args0 -> args0 }))
.serverRole(serverRole?.applyValue({ args0 -> args0 }))
.targetRedisCacheName(targetRedisCacheName?.applyValue({ args0 -> args0 })).build()
}
/**
* Builder for [LinkedServerArgs].
*/
@PulumiTagMarker
public class LinkedServerArgsBuilder internal constructor() {
private var linkedRedisCacheId: Output? = null
private var linkedRedisCacheLocation: Output? = null
private var resourceGroupName: Output? = null
private var serverRole: Output? = null
private var targetRedisCacheName: Output? = null
/**
* @param value The ID of the linked Redis cache. Changing this forces a new Redis to be created.
*/
@JvmName("rtcvnxqyokwktdrh")
public suspend fun linkedRedisCacheId(`value`: Output) {
this.linkedRedisCacheId = value
}
/**
* @param value The location of the linked Redis cache. Changing this forces a new Redis to be created.
*/
@JvmName("ygnmmcocdqvskpdd")
public suspend fun linkedRedisCacheLocation(`value`: Output) {
this.linkedRedisCacheLocation = value
}
/**
* @param value The name of the Resource Group where the Redis caches exists. Changing this forces a new Redis to be created.
*/
@JvmName("csfixmkmbwjljeyc")
public suspend fun resourceGroupName(`value`: Output) {
this.resourceGroupName = value
}
/**
* @param value The role of the linked Redis cache (eg "Secondary"). Changing this forces a new Redis to be created. Possible values are `Primary` and `Secondary`.
*/
@JvmName("knjwdcfntasawmck")
public suspend fun serverRole(`value`: Output) {
this.serverRole = value
}
/**
* @param value The name of Redis cache to link with. Changing this forces a new Redis to be created. (eg The primary role)
*/
@JvmName("sxisqenbonqfputa")
public suspend fun targetRedisCacheName(`value`: Output) {
this.targetRedisCacheName = value
}
/**
* @param value The ID of the linked Redis cache. Changing this forces a new Redis to be created.
*/
@JvmName("vddcxrjmjgaeqeym")
public suspend fun linkedRedisCacheId(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.linkedRedisCacheId = mapped
}
/**
* @param value The location of the linked Redis cache. Changing this forces a new Redis to be created.
*/
@JvmName("aedbxleyyisvmlno")
public suspend fun linkedRedisCacheLocation(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.linkedRedisCacheLocation = mapped
}
/**
* @param value The name of the Resource Group where the Redis caches exists. Changing this forces a new Redis to be created.
*/
@JvmName("mdpjukhtvokhmaoe")
public suspend fun resourceGroupName(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.resourceGroupName = mapped
}
/**
* @param value The role of the linked Redis cache (eg "Secondary"). Changing this forces a new Redis to be created. Possible values are `Primary` and `Secondary`.
*/
@JvmName("nwiwrkhupnjkjrqn")
public suspend fun serverRole(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.serverRole = mapped
}
/**
* @param value The name of Redis cache to link with. Changing this forces a new Redis to be created. (eg The primary role)
*/
@JvmName("kfojcqfbmssmgmry")
public suspend fun targetRedisCacheName(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.targetRedisCacheName = mapped
}
internal fun build(): LinkedServerArgs = LinkedServerArgs(
linkedRedisCacheId = linkedRedisCacheId,
linkedRedisCacheLocation = linkedRedisCacheLocation,
resourceGroupName = resourceGroupName,
serverRole = serverRole,
targetRedisCacheName = targetRedisCacheName,
)
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy