azure.keyvault.ManagedStorageAccountSasTokenDefinition

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var exampleClientConfig = Azure.Core.GetClientConfig.Invoke();

    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var exampleAccount = new Azure.Storage.Account("exampleAccount", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        AccountTier = "Standard",
        AccountReplicationType = "LRS",
    });

    var exampleAccountSAS = Azure.Storage.GetAccountSAS.Invoke(new()
    {
        ConnectionString = exampleAccount.PrimaryConnectionString,
        HttpsOnly = true,
        ResourceTypes = new Azure.Storage.Inputs.GetAccountSASResourceTypesInputArgs
        {
            Service = true,
            Container = false,
            Object = false,
        },
        Services = new Azure.Storage.Inputs.GetAccountSASServicesInputArgs
        {
            Blob = true,
            Queue = false,
            Table = false,
            File = false,
        },
        Start = "2021-04-30T00:00:00Z",
        Expiry = "2023-04-30T00:00:00Z",
        Permissions = new Azure.Storage.Inputs.GetAccountSASPermissionsInputArgs
        {
            Read = true,
            Write = true,
            Delete = false,
            List = false,
            Add = true,
            Create = true,
            Update = false,
            Process = false,
            Tag = false,
            Filter = false,
        },
    });

    var exampleKeyVault = new Azure.KeyVault.KeyVault("exampleKeyVault", new()
    {
        Location = exampleResourceGroup.Location,
        ResourceGroupName = exampleResourceGroup.Name,
        TenantId = exampleClientConfig.Apply(getClientConfigResult => getClientConfigResult.TenantId),
        SkuName = "standard",
        AccessPolicies = new[]
        {
            new Azure.KeyVault.Inputs.KeyVaultAccessPolicyArgs
            {
                TenantId = exampleClientConfig.Apply(getClientConfigResult => getClientConfigResult.TenantId),
                ObjectId = exampleClientConfig.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
                SecretPermissions = new[]
                {
                    "Get",
                    "Delete",
                },
                StoragePermissions = new[]
                {
                    "Get",
                    "List",
                    "Set",
                    "SetSAS",
                    "GetSAS",
                    "DeleteSAS",
                    "Update",
                    "RegenerateKey",
                },
            },
        },
    });

    var exampleManagedStorageAccount = new Azure.KeyVault.ManagedStorageAccount("exampleManagedStorageAccount", new()
    {
        KeyVaultId = exampleKeyVault.Id,
        StorageAccountId = exampleAccount.Id,
        StorageAccountKey = "key1",
        RegenerateKeyAutomatically = false,
        RegenerationPeriod = "P1D",
    });

    var exampleManagedStorageAccountSasTokenDefinition = new Azure.KeyVault.ManagedStorageAccountSasTokenDefinition("exampleManagedStorageAccountSasTokenDefinition", new()
    {
        ValidityPeriod = "P1D",
        ManagedStorageAccountId = exampleManagedStorageAccount.Id,
        SasTemplateUri = exampleAccountSAS.Apply(getAccountSASResult => getAccountSASResult.Sas),
        SasType = "account",
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/keyvault"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleClientConfig, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			ResourceGroupName:      exampleResourceGroup.Name,
			Location:               exampleResourceGroup.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleAccountSAS := storage.GetAccountSASOutput(ctx, storage.GetAccountSASOutputArgs{
			ConnectionString: exampleAccount.PrimaryConnectionString,
			HttpsOnly:        pulumi.Bool(true),
			ResourceTypes: &storage.GetAccountSASResourceTypesArgs{
				Service:   pulumi.Bool(true),
				Container: pulumi.Bool(false),
				Object:    pulumi.Bool(false),
			},
			Services: &storage.GetAccountSASServicesArgs{
				Blob:  pulumi.Bool(true),
				Queue: pulumi.Bool(false),
				Table: pulumi.Bool(false),
				File:  pulumi.Bool(false),
			},
			Start:  pulumi.String("2021-04-30T00:00:00Z"),
			Expiry: pulumi.String("2023-04-30T00:00:00Z"),
			Permissions: &storage.GetAccountSASPermissionsArgs{
				Read:    pulumi.Bool(true),
				Write:   pulumi.Bool(true),
				Delete:  pulumi.Bool(false),
				List:    pulumi.Bool(false),
				Add:     pulumi.Bool(true),
				Create:  pulumi.Bool(true),
				Update:  pulumi.Bool(false),
				Process: pulumi.Bool(false),
				Tag:     pulumi.Bool(false),
				Filter:  pulumi.Bool(false),
			},
		}, nil)
		exampleKeyVault, err := keyvault.NewKeyVault(ctx, "exampleKeyVault", &keyvault.KeyVaultArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			TenantId:          *pulumi.String(exampleClientConfig.TenantId),
			SkuName:           pulumi.String("standard"),
			AccessPolicies: keyvault.KeyVaultAccessPolicyArray{
				&keyvault.KeyVaultAccessPolicyArgs{
					TenantId: *pulumi.String(exampleClientConfig.TenantId),
					ObjectId: *pulumi.String(exampleClientConfig.ObjectId),
					SecretPermissions: pulumi.StringArray{
						pulumi.String("Get"),
						pulumi.String("Delete"),
					},
					StoragePermissions: pulumi.StringArray{
						pulumi.String("Get"),
						pulumi.String("List"),
						pulumi.String("Set"),
						pulumi.String("SetSAS"),
						pulumi.String("GetSAS"),
						pulumi.String("DeleteSAS"),
						pulumi.String("Update"),
						pulumi.String("RegenerateKey"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleManagedStorageAccount, err := keyvault.NewManagedStorageAccount(ctx, "exampleManagedStorageAccount", &keyvault.ManagedStorageAccountArgs{
			KeyVaultId:                 exampleKeyVault.ID(),
			StorageAccountId:           exampleAccount.ID(),
			StorageAccountKey:          pulumi.String("key1"),
			RegenerateKeyAutomatically: pulumi.Bool(false),
			RegenerationPeriod:         pulumi.String("P1D"),
		})
		if err != nil {
			return err
		}
		_, err = keyvault.NewManagedStorageAccountSasTokenDefinition(ctx, "exampleManagedStorageAccountSasTokenDefinition", &keyvault.ManagedStorageAccountSasTokenDefinitionArgs{
			ValidityPeriod:          pulumi.String("P1D"),
			ManagedStorageAccountId: exampleManagedStorageAccount.ID(),
			SasTemplateUri: exampleAccountSAS.ApplyT(func(exampleAccountSAS storage.GetAccountSASResult) (*string, error) {
				return &exampleAccountSAS.Sas, nil
			}).(pulumi.StringPtrOutput),
			SasType: pulumi.String("account"),
		})
		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.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.storage.StorageFunctions;
import com.pulumi.azure.storage.inputs.GetAccountSASArgs;
import com.pulumi.azure.storage.inputs.GetAccountSASResourceTypesArgs;
import com.pulumi.azure.storage.inputs.GetAccountSASServicesArgs;
import com.pulumi.azure.storage.inputs.GetAccountSASPermissionsArgs;
import com.pulumi.azure.keyvault.KeyVault;
import com.pulumi.azure.keyvault.KeyVaultArgs;
import com.pulumi.azure.keyvault.inputs.KeyVaultAccessPolicyArgs;
import com.pulumi.azure.keyvault.ManagedStorageAccount;
import com.pulumi.azure.keyvault.ManagedStorageAccountArgs;
import com.pulumi.azure.keyvault.ManagedStorageAccountSasTokenDefinition;
import com.pulumi.azure.keyvault.ManagedStorageAccountSasTokenDefinitionArgs;
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 exampleClientConfig = CoreFunctions.getClientConfig();

        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .accountTier("Standard")
            .accountReplicationType("LRS")
            .build());

        final var exampleAccountSAS = StorageFunctions.getAccountSAS(GetAccountSASArgs.builder()
            .connectionString(exampleAccount.primaryConnectionString())
            .httpsOnly(true)
            .resourceTypes(GetAccountSASResourceTypesArgs.builder()
                .service(true)
                .container(false)
                .object(false)
                .build())
            .services(GetAccountSASServicesArgs.builder()
                .blob(true)
                .queue(false)
                .table(false)
                .file(false)
                .build())
            .start("2021-04-30T00:00:00Z")
            .expiry("2023-04-30T00:00:00Z")
            .permissions(GetAccountSASPermissionsArgs.builder()
                .read(true)
                .write(true)
                .delete(false)
                .list(false)
                .add(true)
                .create(true)
                .update(false)
                .process(false)
                .tag(false)
                .filter(false)
                .build())
            .build());

        var exampleKeyVault = new KeyVault("exampleKeyVault", KeyVaultArgs.builder()        
            .location(exampleResourceGroup.location())
            .resourceGroupName(exampleResourceGroup.name())
            .tenantId(exampleClientConfig.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
            .skuName("standard")
            .accessPolicies(KeyVaultAccessPolicyArgs.builder()
                .tenantId(exampleClientConfig.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
                .objectId(exampleClientConfig.applyValue(getClientConfigResult -> getClientConfigResult.objectId()))
                .secretPermissions(                
                    "Get",
                    "Delete")
                .storagePermissions(                
                    "Get",
                    "List",
                    "Set",
                    "SetSAS",
                    "GetSAS",
                    "DeleteSAS",
                    "Update",
                    "RegenerateKey")
                .build())
            .build());

        var exampleManagedStorageAccount = new ManagedStorageAccount("exampleManagedStorageAccount", ManagedStorageAccountArgs.builder()        
            .keyVaultId(exampleKeyVault.id())
            .storageAccountId(exampleAccount.id())
            .storageAccountKey("key1")
            .regenerateKeyAutomatically(false)
            .regenerationPeriod("P1D")
            .build());

        var exampleManagedStorageAccountSasTokenDefinition = new ManagedStorageAccountSasTokenDefinition("exampleManagedStorageAccountSasTokenDefinition", ManagedStorageAccountSasTokenDefinitionArgs.builder()        
            .validityPeriod("P1D")
            .managedStorageAccountId(exampleManagedStorageAccount.id())
            .sasTemplateUri(exampleAccountSAS.applyValue(getAccountSASResult -> getAccountSASResult).applyValue(exampleAccountSAS -> exampleAccountSAS.applyValue(getAccountSASResult -> getAccountSASResult.sas())))
            .sasType("account")
            .build());

    }
}

import pulumi
import pulumi_azure as azure

example_client_config = azure.core.get_client_config()
example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_account = azure.storage.Account("exampleAccount",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    account_tier="Standard",
    account_replication_type="LRS")
example_account_sas = azure.storage.get_account_sas_output(connection_string=example_account.primary_connection_string,
    https_only=True,
    resource_types=azure.storage.GetAccountSASResourceTypesArgs(
        service=True,
        container=False,
        object=False,
    ),
    services=azure.storage.GetAccountSASServicesArgs(
        blob=True,
        queue=False,
        table=False,
        file=False,
    ),
    start="2021-04-30T00:00:00Z",
    expiry="2023-04-30T00:00:00Z",
    permissions=azure.storage.GetAccountSASPermissionsArgs(
        read=True,
        write=True,
        delete=False,
        list=False,
        add=True,
        create=True,
        update=False,
        process=False,
        tag=False,
        filter=False,
    ))
example_key_vault = azure.keyvault.KeyVault("exampleKeyVault",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    tenant_id=example_client_config.tenant_id,
    sku_name="standard",
    access_policies=[azure.keyvault.KeyVaultAccessPolicyArgs(
        tenant_id=example_client_config.tenant_id,
        object_id=example_client_config.object_id,
        secret_permissions=[
            "Get",
            "Delete",
        ],
        storage_permissions=[
            "Get",
            "List",
            "Set",
            "SetSAS",
            "GetSAS",
            "DeleteSAS",
            "Update",
            "RegenerateKey",
        ],
    )])
example_managed_storage_account = azure.keyvault.ManagedStorageAccount("exampleManagedStorageAccount",
    key_vault_id=example_key_vault.id,
    storage_account_id=example_account.id,
    storage_account_key="key1",
    regenerate_key_automatically=False,
    regeneration_period="P1D")
example_managed_storage_account_sas_token_definition = azure.keyvault.ManagedStorageAccountSasTokenDefinition("exampleManagedStorageAccountSasTokenDefinition",
    validity_period="P1D",
    managed_storage_account_id=example_managed_storage_account.id,
    sas_template_uri=example_account_sas.sas,
    sas_type="account")

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleClientConfig = azure.core.getClientConfig({});
const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleAccountSAS = azure.storage.getAccountSASOutput({
    connectionString: exampleAccount.primaryConnectionString,
    httpsOnly: true,
    resourceTypes: {
        service: true,
        container: false,
        object: false,
    },
    services: {
        blob: true,
        queue: false,
        table: false,
        file: false,
    },
    start: "2021-04-30T00:00:00Z",
    expiry: "2023-04-30T00:00:00Z",
    permissions: {
        read: true,
        write: true,
        "delete": false,
        list: false,
        add: true,
        create: true,
        update: false,
        process: false,
        tag: false,
        filter: false,
    },
});
const exampleKeyVault = new azure.keyvault.KeyVault("exampleKeyVault", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    tenantId: exampleClientConfig.then(exampleClientConfig => exampleClientConfig.tenantId),
    skuName: "standard",
    accessPolicies: [{
        tenantId: exampleClientConfig.then(exampleClientConfig => exampleClientConfig.tenantId),
        objectId: exampleClientConfig.then(exampleClientConfig => exampleClientConfig.objectId),
        secretPermissions: [
            "Get",
            "Delete",
        ],
        storagePermissions: [
            "Get",
            "List",
            "Set",
            "SetSAS",
            "GetSAS",
            "DeleteSAS",
            "Update",
            "RegenerateKey",
        ],
    }],
});
const exampleManagedStorageAccount = new azure.keyvault.ManagedStorageAccount("exampleManagedStorageAccount", {
    keyVaultId: exampleKeyVault.id,
    storageAccountId: exampleAccount.id,
    storageAccountKey: "key1",
    regenerateKeyAutomatically: false,
    regenerationPeriod: "P1D",
});
const exampleManagedStorageAccountSasTokenDefinition = new azure.keyvault.ManagedStorageAccountSasTokenDefinition("exampleManagedStorageAccountSasTokenDefinition", {
    validityPeriod: "P1D",
    managedStorageAccountId: exampleManagedStorageAccount.id,
    sasTemplateUri: exampleAccountSAS.apply(exampleAccountSAS => exampleAccountSAS.sas),
    sasType: "account",
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
  exampleAccount:
    type: azure:storage:Account
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
      accountTier: Standard
      accountReplicationType: LRS
  exampleKeyVault:
    type: azure:keyvault:KeyVault
    properties:
      location: ${exampleResourceGroup.location}
      resourceGroupName: ${exampleResourceGroup.name}
      tenantId: ${exampleClientConfig.tenantId}
      skuName: standard
      accessPolicies:
        - tenantId: ${exampleClientConfig.tenantId}
          objectId: ${exampleClientConfig.objectId}
          secretPermissions:
            - Get
            - Delete
          storagePermissions:
            - Get
            - List
            - Set
            - SetSAS
            - GetSAS
            - DeleteSAS
            - Update
            - RegenerateKey
  exampleManagedStorageAccount:
    type: azure:keyvault:ManagedStorageAccount
    properties:
      keyVaultId: ${exampleKeyVault.id}
      storageAccountId: ${exampleAccount.id}
      storageAccountKey: key1
      regenerateKeyAutomatically: false
      regenerationPeriod: P1D
  exampleManagedStorageAccountSasTokenDefinition:
    type: azure:keyvault:ManagedStorageAccountSasTokenDefinition
    properties:
      validityPeriod: P1D
      managedStorageAccountId: ${exampleManagedStorageAccount.id}
      sasTemplateUri: ${exampleAccountSAS.sas}
      sasType: account
variables:
  exampleClientConfig:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}
  exampleAccountSAS:
    fn::invoke:
      Function: azure:storage:getAccountSAS
      Arguments:
        connectionString: ${exampleAccount.primaryConnectionString}
        httpsOnly: true
        resourceTypes:
          service: true
          container: false
          object: false
        services:
          blob: true
          queue: false
          table: false
          file: false
        start: 2021-04-30T00:00:00Z
        expiry: 2023-04-30T00:00:00Z
        permissions:
          read: true
          write: true
          delete: false
          list: false
          add: true
          create: true
          update: false
          process: false
          tag: false
          filter: false