pulumi-azure-native-kotlin/com.pulumi.azurenative.storage.kotlin/StorageAccount

StorageAccount

class StorageAccount : KotlinCustomResource

The storage account. Azure REST API version: 2022-09-01. Prior API version in Azure Native 1.x: 2021-02-01. Other available API versions: 2015-05-01-preview, 2015-06-15, 2018-11-01, 2023-01-01.

Example Usage

NfsV3AccountCreate

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        EnableHttpsTrafficOnly = false,
        EnableNfsV3 = true,
        IsHnsEnabled = true,
        Kind = "BlockBlobStorage",
        Location = "eastus",
        NetworkRuleSet = new AzureNative.Storage.Inputs.NetworkRuleSetArgs
        {
            Bypass = "AzureServices",
            DefaultAction = AzureNative.Storage.DefaultAction.Allow,
            IpRules = new() { },
            VirtualNetworkRules = new[]
            {
                new AzureNative.Storage.Inputs.VirtualNetworkRuleArgs
                {
                    VirtualNetworkResourceId = "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12",
                },
            },
        },
        ResourceGroupName = "res9101",
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Premium_LRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
			AccountName:            pulumi.String("sto4445"),
			EnableHttpsTrafficOnly: pulumi.Bool(false),
			EnableNfsV3:            pulumi.Bool(true),
			IsHnsEnabled:           pulumi.Bool(true),
			Kind:                   pulumi.String("BlockBlobStorage"),
			Location:               pulumi.String("eastus"),
			NetworkRuleSet: storage.NetworkRuleSetResponse{
				Bypass:        pulumi.String("AzureServices"),
				DefaultAction: storage.DefaultActionAllow,
				IpRules:       storage.IPRuleArray{},
				VirtualNetworkRules: storage.VirtualNetworkRuleArray{
					&storage.VirtualNetworkRuleArgs{
						VirtualNetworkResourceId: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"),
					},
				},
			},
			ResourceGroupName: pulumi.String("res9101"),
			Sku: &storage.SkuArgs{
				Name: pulumi.String("Premium_LRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .enableHttpsTrafficOnly(false)
            .enableNfsV3(true)
            .isHnsEnabled(true)
            .kind("BlockBlobStorage")
            .location("eastus")
            .networkRuleSet(Map.ofEntries(
                Map.entry("bypass", "AzureServices"),
                Map.entry("defaultAction", "Allow"),
                Map.entry("ipRules", ),
                Map.entry("virtualNetworkRules", Map.of("virtualNetworkResourceId", "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"))
            ))
            .resourceGroupName("res9101")
            .sku(Map.of("name", "Premium_LRS"))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreate

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        DefaultToOAuthAuthentication = false,
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        IsHnsEnabled = true,
        IsSftpEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
DefaultToOAuthAuthentication: pulumi.Bool(false),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
ExtendedLocation: &storage.ExtendedLocationArgs{
Name: pulumi.String("losangeles001"),
Type: pulumi.String("EdgeZone"),
},
IsHnsEnabled: pulumi.Bool(true),
IsSftpEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .defaultToOAuthAuthentication(false)
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .isHnsEnabled(true)
            .isSftpEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateAllowedCopyScopeToAAD

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        AllowedCopyScope = "AAD",
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        IsHnsEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
AllowedCopyScope: pulumi.String("AAD"),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
IsHnsEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .allowedCopyScope("AAD")
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .isHnsEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateAllowedCopyScopeToPrivateLink

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        AllowedCopyScope = "PrivateLink",
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        IsHnsEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
AllowedCopyScope: pulumi.String("PrivateLink"),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
IsHnsEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .allowedCopyScope("PrivateLink")
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .isHnsEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateDisallowPublicNetworkAccess

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        IsHnsEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        PublicNetworkAccess = "Disabled",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
ExtendedLocation: &storage.ExtendedLocationArgs{
Name: pulumi.String("losangeles001"),
Type: pulumi.String("EdgeZone"),
},
IsHnsEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
PublicNetworkAccess: pulumi.String("Disabled"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .isHnsEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .publicNetworkAccess("Disabled")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateDnsEndpointTypeToAzureDnsZone

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        DefaultToOAuthAuthentication = false,
        DnsEndpointType = "AzureDnsZone",
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        IsHnsEnabled = true,
        IsSftpEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
DefaultToOAuthAuthentication: pulumi.Bool(false),
DnsEndpointType: pulumi.String("AzureDnsZone"),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
ExtendedLocation: &storage.ExtendedLocationArgs{
Name: pulumi.String("losangeles001"),
Type: pulumi.String("EdgeZone"),
},
IsHnsEnabled: pulumi.Bool(true),
IsSftpEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .defaultToOAuthAuthentication(false)
            .dnsEndpointType("AzureDnsZone")
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .isHnsEnabled(true)
            .isSftpEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateDnsEndpointTypeToStandard

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        DefaultToOAuthAuthentication = false,
        DnsEndpointType = "Standard",
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        IsHnsEnabled = true,
        IsSftpEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
DefaultToOAuthAuthentication: pulumi.Bool(false),
DnsEndpointType: pulumi.String("Standard"),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
ExtendedLocation: &storage.ExtendedLocationArgs{
Name: pulumi.String("losangeles001"),
Type: pulumi.String("EdgeZone"),
},
IsHnsEnabled: pulumi.Bool(true),
IsSftpEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .defaultToOAuthAuthentication(false)
            .dnsEndpointType("Standard")
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .isHnsEnabled(true)
            .isSftpEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateEnablePublicNetworkAccess

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowBlobPublicAccess = false,
        AllowSharedKeyAccess = true,
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        IsHnsEnabled = true,
        KeyPolicy = new AzureNative.Storage.Inputs.KeyPolicyArgs
        {
            KeyExpirationPeriodInDays = 20,
        },
        Kind = "Storage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        PublicNetworkAccess = "Enabled",
        ResourceGroupName = "res9101",
        RoutingPreference = new AzureNative.Storage.Inputs.RoutingPreferenceArgs
        {
            PublishInternetEndpoints = true,
            PublishMicrosoftEndpoints = true,
            RoutingChoice = "MicrosoftRouting",
        },
        SasPolicy = new AzureNative.Storage.Inputs.SasPolicyArgs
        {
            ExpirationAction = "Log",
            SasExpirationPeriod = "1.15:59:59",
        },
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowBlobPublicAccess: pulumi.Bool(false),
AllowSharedKeyAccess: pulumi.Bool(true),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
ExtendedLocation: &storage.ExtendedLocationArgs{
Name: pulumi.String("losangeles001"),
Type: pulumi.String("EdgeZone"),
},
IsHnsEnabled: pulumi.Bool(true),
KeyPolicy: &storage.KeyPolicyArgs{
KeyExpirationPeriodInDays: pulumi.Int(20),
},
Kind: pulumi.String("Storage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
PublicNetworkAccess: pulumi.String("Enabled"),
ResourceGroupName: pulumi.String("res9101"),
RoutingPreference: &storage.RoutingPreferenceArgs{
PublishInternetEndpoints: pulumi.Bool(true),
PublishMicrosoftEndpoints: pulumi.Bool(true),
RoutingChoice: pulumi.String("MicrosoftRouting"),
},
SasPolicy: &storage.SasPolicyArgs{
ExpirationAction: pulumi.String("Log"),
SasExpirationPeriod: pulumi.String("1.15:59:59"),
},
Sku: &storage.SkuArgs{
Name: pulumi.String("Standard_GRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowBlobPublicAccess(false)
            .allowSharedKeyAccess(true)
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .isHnsEnabled(true)
            .keyPolicy(Map.of("keyExpirationPeriodInDays", 20))
            .kind("Storage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .publicNetworkAccess("Enabled")
            .resourceGroupName("res9101")
            .routingPreference(Map.ofEntries(
                Map.entry("publishInternetEndpoints", true),
                Map.entry("publishMicrosoftEndpoints", true),
                Map.entry("routingChoice", "MicrosoftRouting")
            ))
            .sasPolicy(Map.ofEntries(
                Map.entry("expirationAction", "Log"),
                Map.entry("sasExpirationPeriod", "1.15:59:59")
            ))
            .sku(Map.of("name", "Standard_GRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreatePremiumBlockBlobStorage

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        AllowSharedKeyAccess = true,
        Encryption = new AzureNative.Storage.Inputs.EncryptionArgs
        {
            KeySource = "Microsoft.Storage",
            RequireInfrastructureEncryption = false,
            Services = new AzureNative.Storage.Inputs.EncryptionServicesArgs
            {
                Blob = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
                File = new AzureNative.Storage.Inputs.EncryptionServiceArgs
                {
                    Enabled = true,
                    KeyType = "Account",
                },
            },
        },
        Kind = "BlockBlobStorage",
        Location = "eastus",
        MinimumTlsVersion = "TLS1_2",
        ResourceGroupName = "res9101",
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Premium_LRS",
        },
        Tags =
        {
            { "key1", "value1" },
            { "key2", "value2" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
AccountName: pulumi.String("sto4445"),
AllowSharedKeyAccess: pulumi.Bool(true),
Encryption: storage.EncryptionResponse{
KeySource: pulumi.String("Microsoft.Storage"),
RequireInfrastructureEncryption: pulumi.Bool(false),
Services: interface{}{
Blob: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
File: &storage.EncryptionServiceArgs{
Enabled: pulumi.Bool(true),
KeyType: pulumi.String("Account"),
},
},
},
Kind: pulumi.String("BlockBlobStorage"),
Location: pulumi.String("eastus"),
MinimumTlsVersion: pulumi.String("TLS1_2"),
ResourceGroupName: pulumi.String("res9101"),
Sku: &storage.SkuArgs{
Name: pulumi.String("Premium_LRS"),
},
Tags: pulumi.StringMap{
"key1": pulumi.String("value1"),
"key2": pulumi.String("value2"),
},
})
if err != nil {
return err
}
return nil
})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .allowSharedKeyAccess(true)
            .encryption(Map.ofEntries(
                Map.entry("keySource", "Microsoft.Storage"),
                Map.entry("requireInfrastructureEncryption", false),
                Map.entry("services", Map.ofEntries(
                    Map.entry("blob", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    )),
                    Map.entry("file", Map.ofEntries(
                        Map.entry("enabled", true),
                        Map.entry("keyType", "Account")
                    ))
                ))
            ))
            .kind("BlockBlobStorage")
            .location("eastus")
            .minimumTlsVersion("TLS1_2")
            .resourceGroupName("res9101")
            .sku(Map.of("name", "Premium_LRS"))
            .tags(Map.ofEntries(
                Map.entry("key1", "value1"),
                Map.entry("key2", "value2")
            ))
            .build());
    }
}
Content copied to clipboard

StorageAccountCreateWithImmutabilityPolicy

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var storageAccount = new AzureNative.Storage.StorageAccount("storageAccount", new()
    {
        AccountName = "sto4445",
        ExtendedLocation = new AzureNative.Storage.Inputs.ExtendedLocationArgs
        {
            Name = "losangeles001",
            Type = "EdgeZone",
        },
        ImmutableStorageWithVersioning = new AzureNative.Storage.Inputs.ImmutableStorageAccountArgs
        {
            Enabled = true,
            ImmutabilityPolicy = new AzureNative.Storage.Inputs.AccountImmutabilityPolicyPropertiesArgs
            {
                AllowProtectedAppendWrites = true,
                ImmutabilityPeriodSinceCreationInDays = 15,
                State = "Unlocked",
            },
        },
        Kind = "Storage",
        Location = "eastus",
        ResourceGroupName = "res9101",
        Sku = new AzureNative.Storage.Inputs.SkuArgs
        {
            Name = "Standard_GRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/storage/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewStorageAccount(ctx, "storageAccount", &storage.StorageAccountArgs{
			AccountName: pulumi.String("sto4445"),
			ExtendedLocation: &storage.ExtendedLocationArgs{
				Name: pulumi.String("losangeles001"),
				Type: pulumi.String("EdgeZone"),
			},
			ImmutableStorageWithVersioning: storage.ImmutableStorageAccountResponse{
				Enabled: pulumi.Bool(true),
				ImmutabilityPolicy: &storage.AccountImmutabilityPolicyPropertiesArgs{
					AllowProtectedAppendWrites:            pulumi.Bool(true),
					ImmutabilityPeriodSinceCreationInDays: pulumi.Int(15),
					State:                                 pulumi.String("Unlocked"),
				},
			},
			Kind:              pulumi.String("Storage"),
			Location:          pulumi.String("eastus"),
			ResourceGroupName: pulumi.String("res9101"),
			Sku: &storage.SkuArgs{
				Name: pulumi.String("Standard_GRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.storage.StorageAccount;
import com.pulumi.azurenative.storage.StorageAccountArgs;
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 storageAccount = new StorageAccount("storageAccount", StorageAccountArgs.builder()
            .accountName("sto4445")
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "losangeles001"),
                Map.entry("type", "EdgeZone")
            ))
            .immutableStorageWithVersioning(Map.ofEntries(
                Map.entry("enabled", true),
                Map.entry("immutabilityPolicy", Map.ofEntries(
                    Map.entry("allowProtectedAppendWrites", true),
                    Map.entry("immutabilityPeriodSinceCreationInDays", 15),
                    Map.entry("state", "Unlocked")
                ))
            ))
            .kind("Storage")
            .location("eastus")
            .resourceGroupName("res9101")
            .sku(Map.of("name", "Standard_GRS"))
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:storage:StorageAccount sto4445 /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}
Content copied to clipboard

Properties

Link copied to clipboard
val accessTier: Output<String>

Required for storage accounts where kind = BlobStorage. The access tier is used for billing. The 'Premium' access tier is the default value for premium block blobs storage account type and it cannot be changed for the premium block blobs storage account type.

Link copied to clipboard
val allowBlobPublicAccess: Output<Boolean>?

Allow or disallow public access to all blobs or containers in the storage account. The default interpretation is true for this property.

Link copied to clipboard
val allowCrossTenantReplication: Output<Boolean>?

Allow or disallow cross AAD tenant object replication. The default interpretation is true for this property.

Link copied to clipboard
val allowedCopyScope: Output<String>?

Restrict copy to and from Storage Accounts within an AAD tenant or with Private Links to the same VNet.

Link copied to clipboard
val allowSharedKeyAccess: Output<Boolean>?

Indicates whether the storage account permits requests to be authorized with the account access key via Shared Key. If false, then all requests, including shared access signatures, must be authorized with Azure Active Directory (Azure AD). The default value is null, which is equivalent to true.

Link copied to clipboard
val azureFilesIdentityBasedAuthentication: Output<AzureFilesIdentityBasedAuthenticationResponse>?

Provides the identity based authentication settings for Azure Files.

Link copied to clipboard
val blobRestoreStatus: Output<BlobRestoreStatusResponse>

Blob restore status

Link copied to clipboard
val creationTime: Output<String>

Gets the creation date and time of the storage account in UTC.

Link copied to clipboard
val customDomain: Output<CustomDomainResponse>

Gets the custom domain the user assigned to this storage account.

Link copied to clipboard
val defaultToOAuthAuthentication: Output<Boolean>?

A boolean flag which indicates whether the default authentication is OAuth or not. The default interpretation is false for this property.

Link copied to clipboard
val dnsEndpointType: Output<String>?

Allows you to specify the type of endpoint. Set this to AzureDNSZone to create a large number of accounts in a single subscription, which creates accounts in an Azure DNS Zone and the endpoint URL will have an alphanumeric DNS Zone identifier.

Link copied to clipboard
val enableHttpsTrafficOnly: Output<Boolean>?

Allows https traffic only to storage service if sets to true.

Link copied to clipboard
val enableNfsV3: Output<Boolean>?

NFS 3.0 protocol support enabled if set to true.

Link copied to clipboard
val encryption: Output<EncryptionResponse>

Encryption settings to be used for server-side encryption for the storage account.

Link copied to clipboard
val extendedLocation: Output<ExtendedLocationResponse>?

The extendedLocation of the resource.

Link copied to clipboard
val failoverInProgress: Output<Boolean>

If the failover is in progress, the value will be true, otherwise, it will be null.

Link copied to clipboard
val geoReplicationStats: Output<GeoReplicationStatsResponse>

Geo Replication Stats

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val identity: Output<IdentityResponse>?

The identity of the resource.

Link copied to clipboard
val immutableStorageWithVersioning: Output<ImmutableStorageAccountResponse>?

The property is immutable and can only be set to true at the account creation time. When set to true, it enables object level immutability for all the containers in the account by default.

Link copied to clipboard
val isHnsEnabled: Output<Boolean>?

Account HierarchicalNamespace enabled if sets to true.

Link copied to clipboard
val isLocalUserEnabled: Output<Boolean>?

Enables local users feature, if set to true

Link copied to clipboard
val isSftpEnabled: Output<Boolean>?

Enables Secure File Transfer Protocol, if set to true

Link copied to clipboard
val keyCreationTime: Output<KeyCreationTimeResponse>

Storage account keys creation time.

Link copied to clipboard
val keyPolicy: Output<KeyPolicyResponse>

KeyPolicy assigned to the storage account.

Link copied to clipboard
val kind: Output<String>

Gets the Kind.

Link copied to clipboard
val largeFileSharesState: Output<String>?

Allow large file shares if sets to Enabled. It cannot be disabled once it is enabled.

Link copied to clipboard
val lastGeoFailoverTime: Output<String>

Gets the timestamp of the most recent instance of a failover to the secondary location. Only the most recent timestamp is retained. This element is not returned if there has never been a failover instance. Only available if the accountType is Standard_GRS or Standard_RAGRS.

Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

Link copied to clipboard
val minimumTlsVersion: Output<String>?

Set the minimum TLS version to be permitted on requests to storage. The default interpretation is TLS 1.0 for this property.

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val networkRuleSet: Output<NetworkRuleSetResponse>

Network rule set

Link copied to clipboard
val primaryEndpoints: Output<EndpointsResponse>

Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object. Note that Standard_ZRS and Premium_LRS accounts only return the blob endpoint.

Link copied to clipboard
val primaryLocation: Output<String>

Gets the location of the primary data center for the storage account.

Link copied to clipboard
val privateEndpointConnections: Output<List<PrivateEndpointConnectionResponse>>

List of private endpoint connection associated with the specified storage account

Link copied to clipboard
val provisioningState: Output<String>

Gets the status of the storage account at the time the operation was called.

Link copied to clipboard
val publicNetworkAccess: Output<String>?

Allow or disallow public network access to Storage Account. Value is optional but if passed in, must be 'Enabled' or 'Disabled'.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val routingPreference: Output<RoutingPreferenceResponse>?

Maintains information about the network routing choice opted by the user for data transfer

Link copied to clipboard
val sasPolicy: Output<SasPolicyResponse>

SasPolicy assigned to the storage account.

Link copied to clipboard
val secondaryEndpoints: Output<EndpointsResponse>

Gets the URLs that are used to perform a retrieval of a public blob, queue, or table object from the secondary location of the storage account. Only available if the SKU name is Standard_RAGRS.

Link copied to clipboard
val secondaryLocation: Output<String>

Gets the location of the geo-replicated secondary for the storage account. Only available if the accountType is Standard_GRS or Standard_RAGRS.

Link copied to clipboard
val sku: Output<SkuResponse>

Gets the SKU.

Link copied to clipboard
val statusOfPrimary: Output<String>

Gets the status indicating whether the primary location of the storage account is available or unavailable.

Link copied to clipboard
val statusOfSecondary: Output<String>

Gets the status indicating whether the secondary location of the storage account is available or unavailable. Only available if the SKU name is Standard_GRS or Standard_RAGRS.

Link copied to clipboard
val storageAccountSkuConversionStatus: Output<StorageAccountSkuConversionStatusResponse>?

This property is readOnly and is set by server during asynchronous storage account sku conversion operations.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val urn: Output<String>