pulumi-azure-kotlin/com.pulumi.azure.redis.kotlin/CacheAccessPolicyAssignment

CacheAccessPolicyAssignment

class CacheAccessPolicyAssignment : KotlinCustomResource

Manages a Redis Cache Access Policy Assignment

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const test = azure.core.getClientConfig({});
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "East US",
});
const exampleCache = new azure.redis.Cache("example", {
    name: "example",
    location: example.location,
    resourceGroupName: example.name,
    capacity: 1,
    family: "P",
    skuName: "Premium",
    enableNonSslPort: false,
    redisConfiguration: {
        maxmemoryReserved: 2,
        maxmemoryDelta: 2,
        maxmemoryPolicy: "allkeys-lru",
    },
});
const exampleCacheAccessPolicyAssignment = new azure.redis.CacheAccessPolicyAssignment("example", {
    name: "example",
    redisCacheId: exampleCache.id,
    accessPolicyName: "Data Contributor",
    objectId: test.then(test => test.objectId),
    objectIdAlias: "ServicePrincipal",
});

import pulumi
import pulumi_azure as azure
test = azure.core.get_client_config()
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="East US")
example_cache = azure.redis.Cache("example",
    name="example",
    location=example.location,
    resource_group_name=example.name,
    capacity=1,
    family="P",
    sku_name="Premium",
    enable_non_ssl_port=False,
    redis_configuration={
        "maxmemory_reserved": 2,
        "maxmemory_delta": 2,
        "maxmemory_policy": "allkeys-lru",
    })
example_cache_access_policy_assignment = azure.redis.CacheAccessPolicyAssignment("example",
    name="example",
    redis_cache_id=example_cache.id,
    access_policy_name="Data Contributor",
    object_id=test.object_id,
    object_id_alias="ServicePrincipal")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var test = Azure.Core.GetClientConfig.Invoke();
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "East US",
    });
    var exampleCache = new Azure.Redis.Cache("example", new()
    {
        Name = "example",
        Location = example.Location,
        ResourceGroupName = example.Name,
        Capacity = 1,
        Family = "P",
        SkuName = "Premium",
        EnableNonSslPort = false,
        RedisConfiguration = new Azure.Redis.Inputs.CacheRedisConfigurationArgs
        {
            MaxmemoryReserved = 2,
            MaxmemoryDelta = 2,
            MaxmemoryPolicy = "allkeys-lru",
        },
    });
    var exampleCacheAccessPolicyAssignment = new Azure.Redis.CacheAccessPolicyAssignment("example", new()
    {
        Name = "example",
        RedisCacheId = exampleCache.Id,
        AccessPolicyName = "Data Contributor",
        ObjectId = test.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
        ObjectIdAlias = "ServicePrincipal",
    });
});

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 {
		test, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("East US"),
		})
		if err != nil {
			return err
		}
		exampleCache, err := redis.NewCache(ctx, "example", &redis.CacheArgs{
			Name:              pulumi.String("example"),
			Location:          example.Location,
			ResourceGroupName: example.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.NewCacheAccessPolicyAssignment(ctx, "example", &redis.CacheAccessPolicyAssignmentArgs{
			Name:             pulumi.String("example"),
			RedisCacheId:     exampleCache.ID(),
			AccessPolicyName: pulumi.String("Data Contributor"),
			ObjectId:         pulumi.String(test.ObjectId),
			ObjectIdAlias:    pulumi.String("ServicePrincipal"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
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.CacheAccessPolicyAssignment;
import com.pulumi.azure.redis.CacheAccessPolicyAssignmentArgs;
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) {
        final var test = CoreFunctions.getClientConfig();
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("East US")
            .build());
        var exampleCache = new Cache("exampleCache", CacheArgs.builder()
            .name("example")
            .location(example.location())
            .resourceGroupName(example.name())
            .capacity(1)
            .family("P")
            .skuName("Premium")
            .enableNonSslPort(false)
            .redisConfiguration(CacheRedisConfigurationArgs.builder()
                .maxmemoryReserved(2)
                .maxmemoryDelta(2)
                .maxmemoryPolicy("allkeys-lru")
                .build())
            .build());
        var exampleCacheAccessPolicyAssignment = new CacheAccessPolicyAssignment("exampleCacheAccessPolicyAssignment", CacheAccessPolicyAssignmentArgs.builder()
            .name("example")
            .redisCacheId(exampleCache.id())
            .accessPolicyName("Data Contributor")
            .objectId(test.applyValue(getClientConfigResult -> getClientConfigResult.objectId()))
            .objectIdAlias("ServicePrincipal")
            .build());
    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: East US
  exampleCache:
    type: azure:redis:Cache
    name: example
    properties:
      name: example
      location: ${example.location}
      resourceGroupName: ${example.name}
      capacity: 1
      family: P
      skuName: Premium
      enableNonSslPort: false
      redisConfiguration:
        maxmemoryReserved: 2
        maxmemoryDelta: 2
        maxmemoryPolicy: allkeys-lru
  exampleCacheAccessPolicyAssignment:
    type: azure:redis:CacheAccessPolicyAssignment
    name: example
    properties:
      name: example
      redisCacheId: ${exampleCache.id}
      accessPolicyName: Data Contributor
      objectId: ${test.objectId}
      objectIdAlias: ServicePrincipal
variables:
  test:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}

Import

Redis Cache Policy Assignment can be imported using the resource id, e.g.

$ pulumi import azure:redis/cacheAccessPolicyAssignment:CacheAccessPolicyAssignment example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Cache/redis/cache1/accessPolicyAssignments/assignment1

Properties

accessPolicyName

val accessPolicyName: Output<String>

The name of the Access Policy to be assigned. Changing this forces a new Redis Cache Access Policy Assignment to be created.

val id: Output<String>

name

val name: Output<String>

The name of the Redis Cache Access Policy Assignment. Changing this forces a new Redis Cache Access Policy Assignment to be created.

objectId

val objectId: Output<String>

The principal ID to be assigned the Access Policy. Changing this forces a new Redis Cache Access Policy Assignment to be created.

objectIdAlias

val objectIdAlias: Output<String>

The alias of the principal ID. User-friendly name for object ID. Also represents username for token based authentication. Changing this forces a new Redis Cache Access Policy Assignment to be created.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

redisCacheId

val redisCacheId: Output<String>

The ID of the Redis Cache. Changing this forces a new Redis Cache Access Policy Assignment to be created.

urn

val urn: Output<String>