Storage Accounts - Create

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "kind": "BlockBlobStorage",
  "location": "eastus",
  "properties": {
    "enableExtendedGroups": true,
    "isHnsEnabled": true,
    "isNfsV3Enabled": true,
    "networkAcls": {
      "bypass": "AzureServices",
      "defaultAction": "Allow",
      "ipRules": [],
      "virtualNetworkRules": [
        {
          "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"
        }
      ]
    },
    "supportsHttpsTrafficOnly": false
  },
  "sku": {
    "name": "Premium_LRS"
  }
}

import com.azure.resourcemanager.storage.models.Bypass;
import com.azure.resourcemanager.storage.models.DefaultAction;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.NetworkRuleSet;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.VirtualNetworkRule;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/NfsV3AccountCreate.json
     */
    /**
     * Sample code: NfsV3AccountCreate.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void nfsV3AccountCreate(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res9101", "sto4445", new StorageAccountCreateParameters()
            .withSku(new Sku().withName(SkuName.PREMIUM_LRS)).withKind(Kind.BLOCK_BLOB_STORAGE).withLocation("eastus")
            .withNetworkRuleSet(new NetworkRuleSet().withBypass(Bypass.AZURE_SERVICES)
                .withVirtualNetworkRules(Arrays.asList(new VirtualNetworkRule().withVirtualNetworkResourceId(
                    "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12")))
                .withIpRules(Arrays.asList()).withDefaultAction(DefaultAction.ALLOW))
            .withEnableHttpsTrafficOnly(false).withEnableExtendedGroups(true).withIsHnsEnabled(true)
            .withEnableNfsV3(true), com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python nfs_v3_account_create.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "kind": "BlockBlobStorage",
            "location": "eastus",
            "properties": {
                "enableExtendedGroups": True,
                "isHnsEnabled": True,
                "isNfsV3Enabled": True,
                "networkAcls": {
                    "bypass": "AzureServices",
                    "defaultAction": "Allow",
                    "ipRules": [],
                    "virtualNetworkRules": [
                        {
                            "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"
                        }
                    ],
                },
                "supportsHttpsTrafficOnly": False,
            },
            "sku": {"name": "Premium_LRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/NfsV3AccountCreate.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/NfsV3AccountCreate.json
func ExampleAccountsClient_BeginCreate_nfsV3AccountCreate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindBlockBlobStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			EnableExtendedGroups: to.Ptr(true),
			IsHnsEnabled:         to.Ptr(true),
			EnableNfsV3:          to.Ptr(true),
			NetworkRuleSet: &armstorage.NetworkRuleSet{
				Bypass:        to.Ptr(armstorage.BypassAzureServices),
				DefaultAction: to.Ptr(armstorage.DefaultActionAllow),
				IPRules:       []*armstorage.IPRule{},
				VirtualNetworkRules: []*armstorage.VirtualNetworkRule{
					{
						VirtualNetworkResourceID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"),
					},
				},
			},
			EnableHTTPSTrafficOnly: to.Ptr(false),
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNamePremiumLRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindBlockBlobStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			EnableExtendedGroups: to.Ptr(true),
	// 			IsHnsEnabled: to.Ptr(true),
	// 			EnableNfsV3: to.Ptr(true),
	// 			NetworkRuleSet: &armstorage.NetworkRuleSet{
	// 				Bypass: to.Ptr(armstorage.BypassAzureServices),
	// 				DefaultAction: to.Ptr(armstorage.DefaultActionAllow),
	// 				IPRules: []*armstorage.IPRule{
	// 				},
	// 				VirtualNetworkRules: []*armstorage.VirtualNetworkRule{
	// 					{
	// 						VirtualNetworkResourceID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12"),
	// 					},
	// 				},
	// 			},
	// 			EnableHTTPSTrafficOnly: to.Ptr(false),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNamePremiumLRS),
	// 			Tier: to.Ptr(armstorage.SKUTierPremium),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/NfsV3AccountCreate.json
 */
async function nfsV3AccountCreate() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    kind: "BlockBlobStorage",
    location: "eastus",
    enableExtendedGroups: true,
    isHnsEnabled: true,
    enableNfsV3: true,
    networkRuleSet: {
      bypass: "AzureServices",
      defaultAction: "Allow",
      ipRules: [],
      virtualNetworkRules: [
        {
          virtualNetworkResourceId:
            "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12",
        },
      ],
    },
    enableHttpsTrafficOnly: false,
    sku: { name: "Premium_LRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/a3f7c2b9-4e1d-4c8a-9d6f-8b2a5e41c7f3/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59",
      "requireUserBoundUserDelegationSas": true,
      "requireUserBoundUserDelegationSasAction": "Block"
    },
    "geoPriorityReplicationStatus": {
      "isBlobEnabled": true
    },
    "allowSharedKeyAccessForServices": {
      "blob": {
        "enabled": true
      },
      "file": {
        "enabled": false
      },
      "queue": {
        "enabled": true
      },
      "table": {
        "enabled": false
      }
    },
    "allowCrossTenantDelegationSas": false
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.GeoPriorityReplicationStatus;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.PolicyViolationAction;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.ServiceSharedKeyAccessProperties;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.StorageAccountSharedKeyAccessProperties;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreate.json
     */
    /**
     * Sample code: StorageAccountCreate.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreate(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod("1.15:59:59").withExpirationAction(ExpirationAction.LOG)
                            .withRequireUserBoundUserDelegationSas(true).withRequireUserBoundUserDelegationSasAction(
                                PolicyViolationAction.BLOCK))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false)
                    .withGeoPriorityReplicationStatus(new GeoPriorityReplicationStatus().withIsBlobEnabled(true))
                    .withAllowSharedKeyAccessForServices(new StorageAccountSharedKeyAccessProperties()
                        .withBlob(new ServiceSharedKeyAccessProperties().withEnabled(true))
                        .withFile(new ServiceSharedKeyAccessProperties().withEnabled(false))
                        .withTable(new ServiceSharedKeyAccessProperties().withEnabled(false))
                        .withQueue(new ServiceSharedKeyAccessProperties().withEnabled(true)))
                    .withAllowCrossTenantDelegationSas(false),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowCrossTenantDelegationSas": False,
                "allowSharedKeyAccess": True,
                "allowSharedKeyAccessForServices": {
                    "blob": {"enabled": True},
                    "file": {"enabled": False},
                    "queue": {"enabled": True},
                    "table": {"enabled": False},
                },
                "defaultToOAuthAuthentication": False,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "geoPriorityReplicationStatus": {"isBlobEnabled": True},
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {
                    "expirationAction": "Log",
                    "requireUserBoundUserDelegationSas": True,
                    "requireUserBoundUserDelegationSasAction": "Block",
                    "sasExpirationPeriod": "1.15:59:59",
                },
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreate.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreate.json
func ExampleAccountsClient_BeginCreate_storageAccountCreate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("a3f7c2b9-4e1d-4c8a-9d6f-8b2a5e41c7f3", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:                        to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod:                     to.Ptr("1.15:59:59"),
				RequireUserBoundUserDelegationSas:       to.Ptr(true),
				RequireUserBoundUserDelegationSasAction: to.Ptr(armstorage.PolicyViolationActionBlock),
			},
			GeoPriorityReplicationStatus: &armstorage.GeoPriorityReplicationStatus{
				IsBlobEnabled: to.Ptr(true),
			},
			AllowSharedKeyAccessForServices: &armstorage.AccountSharedKeyAccessProperties{
				Blob: &armstorage.ServiceSharedKeyAccessProperties{
					Enabled: to.Ptr(true),
				},
				File: &armstorage.ServiceSharedKeyAccessProperties{
					Enabled: to.Ptr(false),
				},
				Queue: &armstorage.ServiceSharedKeyAccessProperties{
					Enabled: to.Ptr(true),
				},
				Table: &armstorage.ServiceSharedKeyAccessProperties{
					Enabled: to.Ptr(false),
				},
			},
			AllowCrossTenantDelegationSas: to.Ptr(false),
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 				RequireUserBoundUserDelegationSas: to.Ptr(true),
	// 				RequireUserBoundUserDelegationSasAction: to.Ptr(armstorage.PolicyViolationActionBlock),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 			GeoPriorityReplicationStatus: &armstorage.GeoPriorityReplicationStatus{
	// 				IsBlobEnabled: to.Ptr(true),
	// 			},
	// 			AllowSharedKeyAccessForServices: &armstorage.AccountSharedKeyAccessProperties{
	// 				Blob: &armstorage.ServiceSharedKeyAccessProperties{
	// 					Enabled: to.Ptr(true),
	// 				},
	// 				File: &armstorage.ServiceSharedKeyAccessProperties{
	// 					Enabled: to.Ptr(false),
	// 				},
	// 				Queue: &armstorage.ServiceSharedKeyAccessProperties{
	// 					Enabled: to.Ptr(true),
	// 				},
	// 				Table: &armstorage.ServiceSharedKeyAccessProperties{
	// 					Enabled: to.Ptr(false),
	// 				},
	// 			},
	// 			AllowCrossTenantDelegationSas: to.Ptr(false),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreate.json
 */
async function storageAccountCreate() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "a3f7c2b9-4e1d-4c8a-9d6f-8b2a5e41c7f3";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: {
      expirationAction: "Log",
      sasExpirationPeriod: "1.15:59:59",
      requireUserBoundUserDelegationSas: true,
      requireUserBoundUserDelegationSasAction: "Block",
    },
    geoPriorityReplicationStatus: { isBlobEnabled: true },
    allowSharedKeyAccessForServices: {
      blob: { enabled: true },
      file: { enabled: false },
      queue: { enabled: true },
      table: { enabled: false },
    },
    allowCrossTenantDelegationSas: false,
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "placement": {
    "zonePlacementPolicy": "Any"
  },
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.Placement;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.ZonePlacementPolicy;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreate_placement.json
     */
    /**
     * Sample code: StorageAccountCreate_placement.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreatePlacement(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withPlacement(new Placement().withZonePlacementPolicy(ZonePlacementPolicy.ANY))
                    .withTags(
                        mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_placement.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "placement": {"zonePlacementPolicy": "Any"},
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "defaultToOAuthAuthentication": False,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreate_placement.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreate_placement.json
func ExampleAccountsClient_BeginCreate_storageAccountCreatePlacement() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Placement: &armstorage.Placement{
			ZonePlacementPolicy: to.Ptr(armstorage.ZonePlacementPolicyAny),
		},
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Placement: &armstorage.Placement{
	// 			ZonePlacementPolicy: to.Ptr(armstorage.ZonePlacementPolicyAny),
	// 		},
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreate_placement.json
 */
async function storageAccountCreatePlacement() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    placement: { zonePlacementPolicy: "Any" },
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "zones": [
    "1"
  ]
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreate_zones.json
     */
    /**
     * Sample code: StorageAccountCreate_zones.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreateZones(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withZones(Arrays.asList("1"))
                    .withTags(
                        mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_zones.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "defaultToOAuthAuthentication": False,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
            "zones": ["1"],
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreate_zones.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreate_zones.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateZones() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
		Zones: []*string{
			to.Ptr("1"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 		Zones: []*string{
	// 			to.Ptr("1"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreate_zones.json
 */
async function storageAccountCreateZones() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
    zones: ["1"],
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "allowedCopyScope": "AAD",
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.AllowedCopyScope;
import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToAAD.json
     */
    /**
     * Sample code: StorageAccountCreateAllowedCopyScopeToAAD.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateAllowedCopyScopeToAAD(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withAllowedCopyScope(
                        AllowedCopyScope.AAD)
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_allowed_copy_scope_to_aad.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "allowedCopyScope": "AAD",
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToAAD.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateAllowedCopyScopeToAAD.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateAllowedCopyScopeToAad() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess: to.Ptr(false),
			AllowSharedKeyAccess:  to.Ptr(true),
			AllowedCopyScope:      to.Ptr(armstorage.AllowedCopyScopeAAD),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			AllowedCopyScope: to.Ptr(armstorage.AllowedCopyScopeAAD),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToAAD.json
 */
async function storageAccountCreateAllowedCopyScopeToAAD() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    allowedCopyScope: "AAD",
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "allowedCopyScope": "PrivateLink",
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.AllowedCopyScope;
import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
     */
    /**
     * Sample code: StorageAccountCreateAllowedCopyScopeToPrivateLink.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateAllowedCopyScopeToPrivateLink(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withAllowedCopyScope(
                        AllowedCopyScope.PRIVATE_LINK)
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_allowed_copy_scope_to_private_link.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "allowedCopyScope": "PrivateLink",
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateAllowedCopyScopeToPrivateLink() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess: to.Ptr(false),
			AllowSharedKeyAccess:  to.Ptr(true),
			AllowedCopyScope:      to.Ptr(armstorage.AllowedCopyScopePrivateLink),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			AllowedCopyScope: to.Ptr(armstorage.AllowedCopyScopePrivateLink),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
 */
async function storageAccountCreateAllowedCopyScopeToPrivateLink() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    allowedCopyScope: "PrivateLink",
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "publicNetworkAccess": "Disabled",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.PublicNetworkAccess;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateDisallowPublicNetworkAccess.json
     */
    /**
     * Sample code: StorageAccountCreateDisallowPublicNetworkAccess.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateDisallowPublicNetworkAccess(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withPublicNetworkAccess(
                        PublicNetworkAccess.DISABLED)
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_disallow_public_network_access.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "publicNetworkAccess": "Disabled",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateDisallowPublicNetworkAccess.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateDisallowPublicNetworkAccess.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateDisallowPublicNetworkAccess() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess: to.Ptr(false),
			AllowSharedKeyAccess:  to.Ptr(true),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion:   to.Ptr(armstorage.MinimumTLSVersionTLS12),
			PublicNetworkAccess: to.Ptr(armstorage.PublicNetworkAccessDisabled),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			PublicNetworkAccess: to.Ptr(armstorage.PublicNetworkAccessDisabled),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateDisallowPublicNetworkAccess.json
 */
async function storageAccountCreateDisallowPublicNetworkAccess() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    publicNetworkAccess: "Disabled",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "dnsEndpointType": "AzureDnsZone",
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.DnsEndpointType;
import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
     */
    /**
     * Sample code: StorageAccountCreateDnsEndpointTypeToAzureDnsZone.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateDnsEndpointTypeToAzureDnsZone(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(
                        mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false)
                    .withDnsEndpointType(DnsEndpointType.AZURE_DNS_ZONE),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_dns_endpoint_type_to_azure_dns_zone.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "defaultToOAuthAuthentication": False,
                "dnsEndpointType": "AzureDnsZone",
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateDnsEndpointTypeToAzureDnsZone() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			DNSEndpointType:              to.Ptr(armstorage.DNSEndpointTypeAzureDNSZone),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			DNSEndpointType: to.Ptr(armstorage.DNSEndpointTypeAzureDNSZone),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.z24.blob.storage.azure.net/"),
	// 				Dfs: to.Ptr("https://sto4445.z24.dfs.storage.azure.net/"),
	// 				File: to.Ptr("https://sto4445.z24.file.storage.azure.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.z24.blob.storage.azure.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.z24.dfs.storage.azure.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.z24.file.storage.azure.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.z24.web.storage.azure.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.z24.blob.storage.azure.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.z24.dfs.storage.azure.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.z24.file.storage.azure.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.z24.queue.storage.azure.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.z24.table.storage.azure.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.z24.web.storage.azure.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.z24.queue.storage.azure.net/"),
	// 				Table: to.Ptr("https://sto4445.z24.table.storage.azure.net/"),
	// 				Web: to.Ptr("https://sto4445.z24.web.storage.azure.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
 */
async function storageAccountCreateDnsEndpointTypeToAzureDnsZone() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    dnsEndpointType: "AzureDnsZone",
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "dnsEndpointType": "Standard",
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.DnsEndpointType;
import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToStandard.json
     */
    /**
     * Sample code: StorageAccountCreateDnsEndpointTypeToStandard.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateDnsEndpointTypeToStandard(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(
                        mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false)
                    .withDnsEndpointType(DnsEndpointType.STANDARD),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_dns_endpoint_type_to_standard.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "defaultToOAuthAuthentication": False,
                "dnsEndpointType": "Standard",
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToStandard.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateDnsEndpointTypeToStandard.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateDnsEndpointTypeToStandard() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			DNSEndpointType:              to.Ptr(armstorage.DNSEndpointTypeStandard),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			DNSEndpointType: to.Ptr(armstorage.DNSEndpointTypeStandard),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateDnsEndpointTypeToStandard.json
 */
async function storageAccountCreateDnsEndpointTypeToStandard() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    dnsEndpointType: "Standard",
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "publicNetworkAccess": "Enabled",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.PublicNetworkAccess;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateEnablePublicNetworkAccess.json
     */
    /**
     * Sample code: StorageAccountCreateEnablePublicNetworkAccess.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateEnablePublicNetworkAccess(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withPublicNetworkAccess(
                        PublicNetworkAccess.ENABLED)
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_enable_public_network_access.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "isHnsEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "publicNetworkAccess": "Enabled",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateEnablePublicNetworkAccess.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateEnablePublicNetworkAccess.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateEnablePublicNetworkAccess() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowBlobPublicAccess: to.Ptr(false),
			AllowSharedKeyAccess:  to.Ptr(true),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion:   to.Ptr(armstorage.MinimumTLSVersionTLS12),
			PublicNetworkAccess: to.Ptr(armstorage.PublicNetworkAccessEnabled),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			PublicNetworkAccess: to.Ptr(armstorage.PublicNetworkAccessEnabled),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateEnablePublicNetworkAccess.json
 */
async function storageAccountCreateEnablePublicNetworkAccess() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    publicNetworkAccess: "Enabled",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "kind": "BlockBlobStorage",
  "location": "eastus",
  "properties": {
    "allowSharedKeyAccess": true,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "minimumTlsVersion": "TLS1_2"
  },
  "sku": {
    "name": "Premium_LRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreatePremiumBlockBlobStorage.json
     */
    /**
     * Sample code: StorageAccountCreatePremiumBlockBlobStorage.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreatePremiumBlockBlobStorage(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res9101", "sto4445",
            new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.PREMIUM_LRS))
                .withKind(Kind.BLOCK_BLOB_STORAGE).withLocation("eastus")
                .withTags(mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                .withEncryption(new Encryption()
                    .withServices(new EncryptionServices()
                        .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                        .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                    .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                .withMinimumTlsVersion(MinimumTlsVersion.TLS1_2).withAllowSharedKeyAccess(true),
            com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_premium_block_blob_storage.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "kind": "BlockBlobStorage",
            "location": "eastus",
            "properties": {
                "allowSharedKeyAccess": True,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "minimumTlsVersion": "TLS1_2",
            },
            "sku": {"name": "Premium_LRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreatePremiumBlockBlobStorage.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreatePremiumBlockBlobStorage.json
func ExampleAccountsClient_BeginCreate_storageAccountCreatePremiumBlockBlobStorage() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindBlockBlobStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AllowSharedKeyAccess: to.Ptr(true),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNamePremiumLRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AccessTier: to.Ptr(armstorage.AccessTierPremium),
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNamePremiumLRS),
	// 			Tier: to.Ptr(armstorage.SKUTierPremium),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreatePremiumBlockBlobStorage.json
 */
async function storageAccountCreatePremiumBlockBlobStorage() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    kind: "BlockBlobStorage",
    location: "eastus",
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    minimumTlsVersion: "TLS1_2",
    sku: { name: "Premium_LRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {}
    }
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "encryption": {
      "identity": {
        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"
      },
      "keySource": "Microsoft.Keyvault",
      "keyvaultproperties": {
        "keyname": "wrappingKey",
        "keyvaulturi": "https://myvault8569.vault.azure.net",
        "keyversion": ""
      },
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    }
  },
  "sku": {
    "name": "Standard_LRS"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionIdentity;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.Identity;
import com.azure.resourcemanager.storage.models.IdentityType;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.KeyVaultProperties;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.UserAssignedIdentity;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
     */
    /**
     * Sample code: StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreateUserAssignedEncryptionIdentityWithCMK(
        com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res9101", "sto4445", new StorageAccountCreateParameters()
            .withSku(new Sku().withName(SkuName.STANDARD_LRS)).withKind(Kind.STORAGE).withLocation("eastus")
            .withIdentity(new Identity().withType(IdentityType.USER_ASSIGNED).withUserAssignedIdentities(mapOf(
                "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
                new UserAssignedIdentity())))
            .withEncryption(new Encryption()
                .withServices(new EncryptionServices()
                    .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                    .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                .withKeySource(KeySource.MICROSOFT_KEYVAULT)
                .withKeyVaultProperties(new KeyVaultProperties().withKeyName("fakeTokenPlaceholder")
                    .withKeyVersion("fakeTokenPlaceholder").withKeyVaultUri("fakeTokenPlaceholder"))
                .withEncryptionIdentity(new EncryptionIdentity().withEncryptionUserAssignedIdentity(
                    "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"))),
            com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_user_assigned_encryption_identity_with_cmk.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {}
                },
            },
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "encryption": {
                    "identity": {
                        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"
                    },
                    "keySource": "Microsoft.Keyvault",
                    "keyvaultproperties": {
                        "keyname": "wrappingKey",
                        "keyvaulturi": "https://myvault8569.vault.azure.net",
                        "keyversion": "",
                    },
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                }
            },
            "sku": {"name": "Standard_LRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateUserAssignedEncryptionIdentityWithCmk() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Identity: &armstorage.Identity{
			Type: to.Ptr(armstorage.IdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armstorage.UserAssignedIdentity{
				"/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {},
			},
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			Encryption: &armstorage.Encryption{
				EncryptionIdentity: &armstorage.EncryptionIdentity{
					EncryptionUserAssignedIdentity: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"),
				},
				KeySource: to.Ptr(armstorage.KeySourceMicrosoftKeyvault),
				KeyVaultProperties: &armstorage.KeyVaultProperties{
					KeyName:     to.Ptr("wrappingKey"),
					KeyVaultURI: to.Ptr("https://myvault8569.vault.azure.net"),
					KeyVersion:  to.Ptr(""),
				},
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardLRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Identity: &armstorage.Identity{
	// 			Type: to.Ptr(armstorage.IdentityTypeUserAssigned),
	// 			UserAssignedIdentities: map[string]*armstorage.UserAssignedIdentity{
	// 				"/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": &armstorage.UserAssignedIdentity{
	// 					ClientID: to.Ptr("fbaa6278-1ecc-415c-819f-6e2058d3acb5"),
	// 					PrincipalID: to.Ptr("8d823284-1060-42a5-9ec4-ed3d831e24d7"),
	// 				},
	// 			},
	// 		},
	// 		Kind: to.Ptr(armstorage.KindStorageV2),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AccessTier: to.Ptr(armstorage.AccessTierHot),
	// 			CreationTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 83909300, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				EncryptionIdentity: &armstorage.EncryptionIdentity{
	// 					EncryptionUserAssignedIdentity: to.Ptr("/subscriptions/{subscription-id}/resourcegroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"),
	// 				},
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftKeyvault),
	// 				KeyVaultProperties: &armstorage.KeyVaultProperties{
	// 					CurrentVersionedKeyIdentifier: to.Ptr("https://myvault8569.vault.azure.net/keys/wrappingKey/0682afdd9c104f4285df20107e956cad"),
	// 					KeyName: to.Ptr("wrappingKey"),
	// 					KeyVaultURI: to.Ptr("https://myvault8569.vault.azure.net"),
	// 					KeyVersion: to.Ptr(""),
	// 					LastKeyRotationTimestamp: to.Ptr(time.Date(2019, time.December, 13, 20, 36, 23, 702329000, time.UTC)),
	// 				},
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 173958700, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 173958700, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			NetworkRuleSet: &armstorage.NetworkRuleSet{
	// 				Bypass: to.Ptr(armstorage.BypassAzureServices),
	// 				DefaultAction: to.Ptr(armstorage.DefaultActionAllow),
	// 				IPRules: []*armstorage.IPRule{
	// 				},
	// 				VirtualNetworkRules: []*armstorage.VirtualNetworkRule{
	// 				},
	// 			},
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus"),
	// 			PrivateEndpointConnections: []*armstorage.PrivateEndpointConnection{
	// 			},
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardLRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
 */
async function storageAccountCreateUserAssignedEncryptionIdentityWithCMK() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}":
          {},
      },
    },
    kind: "Storage",
    location: "eastus",
    encryption: {
      encryptionIdentity: {
        encryptionUserAssignedIdentity:
          "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
      },
      keySource: "Microsoft.Keyvault",
      keyVaultProperties: {
        keyName: "wrappingKey",
        keyVaultUri: "https://myvault8569.vault.azure.net",
        keyVersion: "",
      },
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    sku: { name: "Standard_LRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res131918/providers/Microsoft.Storage/storageAccounts/sto131918?api-version=2026-09-01

{
  "identity": {
    "type": "UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {}
    }
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "encryption": {
      "identity": {
        "federatedIdentityClientId": "f83c6b1b-4d34-47e4-bb34-9d83df58b540",
        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"
      },
      "keySource": "Microsoft.Keyvault",
      "keyvaultproperties": {
        "keyname": "wrappingKey",
        "keyvaulturi": "https://myvault8569.vault.azure.net",
        "keyversion": ""
      },
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    }
  },
  "sku": {
    "name": "Standard_LRS"
  }
}

import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionIdentity;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.Identity;
import com.azure.resourcemanager.storage.models.IdentityType;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.KeyVaultProperties;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.UserAssignedIdentity;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
     */
    /**
     * Sample code: StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId(
        com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res131918", "sto131918",
            new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_LRS))
                .withKind(Kind.STORAGE).withLocation("eastus")
                .withIdentity(new Identity().withType(IdentityType.USER_ASSIGNED).withUserAssignedIdentities(mapOf(
                    "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
                    new UserAssignedIdentity())))
                .withEncryption(new Encryption()
                    .withServices(new EncryptionServices()
                        .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                        .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                    .withKeySource(KeySource.MICROSOFT_KEYVAULT)
                    .withKeyVaultProperties(new KeyVaultProperties().withKeyName("fakeTokenPlaceholder")
                        .withKeyVersion("fakeTokenPlaceholder").withKeyVaultUri("fakeTokenPlaceholder"))
                    .withEncryptionIdentity(new EncryptionIdentity().withEncryptionUserAssignedIdentity(
                        "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}")
                        .withEncryptionFederatedIdentityClientId("f83c6b1b-4d34-47e4-bb34-9d83df58b540"))),
            com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_user_assigned_identity_with_federated_identity_client_id.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res131918",
        account_name="sto131918",
        parameters={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {}
                },
            },
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "encryption": {
                    "identity": {
                        "federatedIdentityClientId": "f83c6b1b-4d34-47e4-bb34-9d83df58b540",
                        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
                    },
                    "keySource": "Microsoft.Keyvault",
                    "keyvaultproperties": {
                        "keyname": "wrappingKey",
                        "keyvaulturi": "https://myvault8569.vault.azure.net",
                        "keyversion": "",
                    },
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                }
            },
            "sku": {"name": "Standard_LRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res131918", "sto131918", armstorage.AccountCreateParameters{
		Identity: &armstorage.Identity{
			Type: to.Ptr(armstorage.IdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armstorage.UserAssignedIdentity{
				"/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {},
			},
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			Encryption: &armstorage.Encryption{
				EncryptionIdentity: &armstorage.EncryptionIdentity{
					EncryptionFederatedIdentityClientID: to.Ptr("f83c6b1b-4d34-47e4-bb34-9d83df58b540"),
					EncryptionUserAssignedIdentity:      to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"),
				},
				KeySource: to.Ptr(armstorage.KeySourceMicrosoftKeyvault),
				KeyVaultProperties: &armstorage.KeyVaultProperties{
					KeyName:     to.Ptr("wrappingKey"),
					KeyVaultURI: to.Ptr("https://myvault8569.vault.azure.net"),
					KeyVersion:  to.Ptr(""),
				},
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardLRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Identity: &armstorage.Identity{
	// 			Type: to.Ptr(armstorage.IdentityTypeUserAssigned),
	// 			UserAssignedIdentities: map[string]*armstorage.UserAssignedIdentity{
	// 				"/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": &armstorage.UserAssignedIdentity{
	// 					ClientID: to.Ptr("fbaa6278-1ecc-415c-819f-6e2058d3acb5"),
	// 					PrincipalID: to.Ptr("8d823284-1060-42a5-9ec4-ed3d831e24d7"),
	// 				},
	// 			},
	// 		},
	// 		Kind: to.Ptr(armstorage.KindStorageV2),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AccessTier: to.Ptr(armstorage.AccessTierHot),
	// 			CreationTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 83909300, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				EncryptionIdentity: &armstorage.EncryptionIdentity{
	// 					EncryptionFederatedIdentityClientID: to.Ptr("f83c6b1b-4d34-47e4-bb34-9d83df58b540"),
	// 					EncryptionUserAssignedIdentity: to.Ptr("/subscriptions/{subscription-id}/resourcegroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"),
	// 				},
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftKeyvault),
	// 				KeyVaultProperties: &armstorage.KeyVaultProperties{
	// 					CurrentVersionedKeyIdentifier: to.Ptr("https://myvault8569.vault.azure.net/keys/wrappingKey/0682afdd9c104f4285df20107e956cad"),
	// 					KeyName: to.Ptr("wrappingKey"),
	// 					KeyVaultURI: to.Ptr("https://myvault8569.vault.azure.net"),
	// 					KeyVersion: to.Ptr(""),
	// 					LastKeyRotationTimestamp: to.Ptr(time.Date(2019, time.December, 13, 20, 36, 23, 702329000, time.UTC)),
	// 				},
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 173958700, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2020, time.December, 15, 0, 43, 14, 173958700, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			NetworkRuleSet: &armstorage.NetworkRuleSet{
	// 				Bypass: to.Ptr(armstorage.BypassAzureServices),
	// 				DefaultAction: to.Ptr(armstorage.DefaultActionAllow),
	// 				IPRules: []*armstorage.IPRule{
	// 				},
	// 				VirtualNetworkRules: []*armstorage.VirtualNetworkRule{
	// 				},
	// 			},
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus"),
	// 			PrivateEndpointConnections: []*armstorage.PrivateEndpointConnection{
	// 			},
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardLRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
 */
async function storageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res131918", "sto131918", {
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}":
          {},
      },
    },
    kind: "Storage",
    location: "eastus",
    encryption: {
      encryptionIdentity: {
        encryptionFederatedIdentityClientId: "f83c6b1b-4d34-47e4-bb34-9d83df58b540",
        encryptionUserAssignedIdentity:
          "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
      },
      keySource: "Microsoft.Keyvault",
      keyVaultProperties: {
        keyName: "wrappingKey",
        keyVaultUri: "https://myvault8569.vault.azure.net",
        keyVersion: "",
      },
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    sku: { name: "Standard_LRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "dataCollaborationPolicyProperties": {
      "allowStorageConnectors": true,
      "allowStorageDataShares": true,
      "allowCrossTenantDataSharing": false
    }
  },
  "sku": {
    "name": "Standard_GRS"
  }
}

import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.StorageDataCollaborationPolicyProperties;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateWithDataCollaborationPolicy.json
     */
    /**
     * Sample code: StorageAccountCreateWithDataCollaborationPolicy.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateWithDataCollaborationPolicy(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res9101", "sto4445",
            new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                .withKind(Kind.STORAGE).withLocation("eastus").withDataCollaborationPolicyProperties(
                    new StorageDataCollaborationPolicyProperties().withAllowStorageConnectors(true)
                        .withAllowStorageDataShares(true).withAllowCrossTenantDataSharing(false)),
            com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_with_data_collaboration_policy.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "dataCollaborationPolicyProperties": {
                    "allowCrossTenantDataSharing": False,
                    "allowStorageConnectors": True,
                    "allowStorageDataShares": True,
                }
            },
            "sku": {"name": "Standard_GRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateWithDataCollaborationPolicy.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateWithDataCollaborationPolicy.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateWithDataCollaborationPolicy() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			DataCollaborationPolicyProperties: &armstorage.DataCollaborationPolicyProperties{
				AllowStorageConnectors:      to.Ptr(true),
				AllowStorageDataShares:      to.Ptr(true),
				AllowCrossTenantDataSharing: to.Ptr(false),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			DataCollaborationPolicyProperties: &armstorage.DataCollaborationPolicyProperties{
	// 				AllowStorageConnectors: to.Ptr(true),
	// 				AllowStorageDataShares: to.Ptr(true),
	// 				AllowCrossTenantDataSharing: to.Ptr(false),
	// 			},
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateWithDataCollaborationPolicy.json
 */
async function storageAccountCreateWithDataCollaborationPolicy() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    kind: "Storage",
    location: "eastus",
    dataCollaborationPolicyProperties: {
      allowStorageConnectors: true,
      allowStorageDataShares: true,
      allowCrossTenantDataSharing: false,
    },
    sku: { name: "Standard_GRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "immutableStorageWithVersioning": {
      "enabled": true,
      "immutabilityPolicy": {
        "allowProtectedAppendWrites": true,
        "immutabilityPeriodSinceCreationInDays": 15,
        "state": "Unlocked"
      }
    }
  },
  "sku": {
    "name": "Standard_GRS"
  }
}

import com.azure.resourcemanager.storage.models.AccountImmutabilityPolicyProperties;
import com.azure.resourcemanager.storage.models.AccountImmutabilityPolicyState;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.ImmutableStorageAccount;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateWithImmutabilityPolicy.json
     */
    /**
     * Sample code: StorageAccountCreateWithImmutabilityPolicy.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateWithImmutabilityPolicy(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withImmutableStorageWithVersioning(new ImmutableStorageAccount().withEnabled(true)
                        .withImmutabilityPolicy(new AccountImmutabilityPolicyProperties()
                            .withImmutabilityPeriodSinceCreationInDays(15)
                            .withState(AccountImmutabilityPolicyState.UNLOCKED).withAllowProtectedAppendWrites(true))),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_with_immutability_policy.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "immutableStorageWithVersioning": {
                    "enabled": True,
                    "immutabilityPolicy": {
                        "allowProtectedAppendWrites": True,
                        "immutabilityPeriodSinceCreationInDays": 15,
                        "state": "Unlocked",
                    },
                }
            },
            "sku": {"name": "Standard_GRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateWithImmutabilityPolicy.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateWithImmutabilityPolicy.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateWithImmutabilityPolicy() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			ImmutableStorageWithVersioning: &armstorage.ImmutableStorageAccount{
				Enabled: to.Ptr(true),
				ImmutabilityPolicy: &armstorage.AccountImmutabilityPolicyProperties{
					AllowProtectedAppendWrites:            to.Ptr(true),
					ImmutabilityPeriodSinceCreationInDays: to.Ptr[int32](15),
					State:                                 to.Ptr(armstorage.AccountImmutabilityPolicyStateUnlocked),
				},
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			ImmutableStorageWithVersioning: &armstorage.ImmutableStorageAccount{
	// 				Enabled: to.Ptr(true),
	// 				ImmutabilityPolicy: &armstorage.AccountImmutabilityPolicyProperties{
	// 					AllowProtectedAppendWrites: to.Ptr(true),
	// 					ImmutabilityPeriodSinceCreationInDays: to.Ptr[int32](15),
	// 					State: to.Ptr(armstorage.AccountImmutabilityPolicyStateUnlocked),
	// 				},
	// 			},
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateWithImmutabilityPolicy.json
 */
async function storageAccountCreateWithImmutabilityPolicy() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    immutableStorageWithVersioning: {
      enabled: true,
      immutabilityPolicy: {
        allowProtectedAppendWrites: true,
        immutabilityPeriodSinceCreationInDays: 15,
        state: "Unlocked",
      },
    },
    sku: { name: "Standard_GRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2026-09-01

{
  "extendedLocation": {
    "name": "losangeles001",
    "type": "EdgeZone"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "accessTier": "Smart",
    "allowBlobPublicAccess": false,
    "allowSharedKeyAccess": true,
    "defaultToOAuthAuthentication": false,
    "encryption": {
      "keySource": "Microsoft.Storage",
      "requireInfrastructureEncryption": false,
      "services": {
        "blob": {
          "enabled": true,
          "keyType": "Account"
        },
        "file": {
          "enabled": true,
          "keyType": "Account"
        }
      }
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "minimumTlsVersion": "TLS1_2",
    "routingPreference": {
      "publishInternetEndpoints": true,
      "publishMicrosoftEndpoints": true,
      "routingChoice": "MicrosoftRouting"
    },
    "sasPolicy": {
      "expirationAction": "Log",
      "sasExpirationPeriod": "1.15:59:59"
    },
    "geoPriorityReplicationStatus": {
      "isBlobEnabled": true
    }
  },
  "sku": {
    "name": "Standard_GRS"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  }
}

import com.azure.resourcemanager.storage.models.AccessTier;
import com.azure.resourcemanager.storage.models.Encryption;
import com.azure.resourcemanager.storage.models.EncryptionService;
import com.azure.resourcemanager.storage.models.EncryptionServices;
import com.azure.resourcemanager.storage.models.ExpirationAction;
import com.azure.resourcemanager.storage.models.ExtendedLocation;
import com.azure.resourcemanager.storage.models.ExtendedLocationTypes;
import com.azure.resourcemanager.storage.models.GeoPriorityReplicationStatus;
import com.azure.resourcemanager.storage.models.KeyPolicy;
import com.azure.resourcemanager.storage.models.KeySource;
import com.azure.resourcemanager.storage.models.KeyType;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.MinimumTlsVersion;
import com.azure.resourcemanager.storage.models.RoutingChoice;
import com.azure.resourcemanager.storage.models.RoutingPreference;
import com.azure.resourcemanager.storage.models.SasPolicy;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateWithSmartAccessTier.json
     */
    /**
     * Sample code: StorageAccountCreateWithSmartAccessTier.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void
        storageAccountCreateWithSmartAccessTier(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts()
            .create("res9101", "sto4445",
                new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_GRS))
                    .withKind(Kind.STORAGE).withLocation("eastus")
                    .withExtendedLocation(
                        new ExtendedLocation().withName("losangeles001").withType(ExtendedLocationTypes.EDGE_ZONE))
                    .withTags(
                        mapOf("key1", "fakeTokenPlaceholder", "key2", "fakeTokenPlaceholder"))
                    .withSasPolicy(
                        new SasPolicy().withSasExpirationPeriod(
                            "1.15:59:59").withExpirationAction(
                                ExpirationAction.LOG))
                    .withKeyPolicy(new KeyPolicy().withKeyExpirationPeriodInDays(20))
                    .withEncryption(new Encryption()
                        .withServices(new EncryptionServices()
                            .withBlob(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT))
                            .withFile(new EncryptionService().withEnabled(true).withKeyType(KeyType.ACCOUNT)))
                        .withKeySource(KeySource.MICROSOFT_STORAGE).withRequireInfrastructureEncryption(false))
                    .withAccessTier(AccessTier.SMART).withIsSftpEnabled(true).withIsHnsEnabled(true)
                    .withRoutingPreference(new RoutingPreference().withRoutingChoice(RoutingChoice.MICROSOFT_ROUTING)
                        .withPublishMicrosoftEndpoints(true).withPublishInternetEndpoints(true))
                    .withAllowBlobPublicAccess(false).withMinimumTlsVersion(MinimumTlsVersion.TLS1_2)
                    .withAllowSharedKeyAccess(true).withDefaultToOAuthAuthentication(false)
                    .withGeoPriorityReplicationStatus(new GeoPriorityReplicationStatus().withIsBlobEnabled(true)),
                com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_with_smart_access_tier.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="sto4445",
        parameters={
            "extendedLocation": {"name": "losangeles001", "type": "EdgeZone"},
            "kind": "Storage",
            "location": "eastus",
            "properties": {
                "accessTier": "Smart",
                "allowBlobPublicAccess": False,
                "allowSharedKeyAccess": True,
                "defaultToOAuthAuthentication": False,
                "encryption": {
                    "keySource": "Microsoft.Storage",
                    "requireInfrastructureEncryption": False,
                    "services": {
                        "blob": {"enabled": True, "keyType": "Account"},
                        "file": {"enabled": True, "keyType": "Account"},
                    },
                },
                "geoPriorityReplicationStatus": {"isBlobEnabled": True},
                "isHnsEnabled": True,
                "isSftpEnabled": True,
                "keyPolicy": {"keyExpirationPeriodInDays": 20},
                "minimumTlsVersion": "TLS1_2",
                "routingPreference": {
                    "publishInternetEndpoints": True,
                    "publishMicrosoftEndpoints": True,
                    "routingChoice": "MicrosoftRouting",
                },
                "sasPolicy": {"expirationAction": "Log", "sasExpirationPeriod": "1.15:59:59"},
            },
            "sku": {"name": "Standard_GRS"},
            "tags": {"key1": "value1", "key2": "value2"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateWithSmartAccessTier.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateWithSmartAccessTier.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateWithSmartAccessTier() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "sto4445", armstorage.AccountCreateParameters{
		ExtendedLocation: &armstorage.ExtendedLocation{
			Name: to.Ptr("losangeles001"),
			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
		},
		Kind:     to.Ptr(armstorage.KindStorage),
		Location: to.Ptr("eastus"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AccessTier:                   to.Ptr(armstorage.AccessTierSmart),
			AllowBlobPublicAccess:        to.Ptr(false),
			AllowSharedKeyAccess:         to.Ptr(true),
			DefaultToOAuthAuthentication: to.Ptr(false),
			Encryption: &armstorage.Encryption{
				KeySource:                       to.Ptr(armstorage.KeySourceMicrosoftStorage),
				RequireInfrastructureEncryption: to.Ptr(false),
				Services: &armstorage.EncryptionServices{
					Blob: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
					File: &armstorage.EncryptionService{
						Enabled: to.Ptr(true),
						KeyType: to.Ptr(armstorage.KeyTypeAccount),
					},
				},
			},
			IsHnsEnabled:  to.Ptr(true),
			IsSftpEnabled: to.Ptr(true),
			KeyPolicy: &armstorage.KeyPolicy{
				KeyExpirationPeriodInDays: to.Ptr[int32](20),
			},
			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
			RoutingPreference: &armstorage.RoutingPreference{
				PublishInternetEndpoints:  to.Ptr(true),
				PublishMicrosoftEndpoints: to.Ptr(true),
				RoutingChoice:             to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
			},
			SasPolicy: &armstorage.SasPolicy{
				ExpirationAction:    to.Ptr(armstorage.ExpirationActionLog),
				SasExpirationPeriod: to.Ptr("1.15:59:59"),
			},
			GeoPriorityReplicationStatus: &armstorage.GeoPriorityReplicationStatus{
				IsBlobEnabled: to.Ptr(true),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardGRS),
		},
		Tags: map[string]*string{
			"key1": to.Ptr("value1"),
			"key2": to.Ptr("value2"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		Name: to.Ptr("sto4445"),
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 		ExtendedLocation: &armstorage.ExtendedLocation{
	// 			Name: to.Ptr("losangeles001"),
	// 			Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 		},
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445"),
	// 		Kind: to.Ptr(armstorage.KindStorage),
	// 		Location: to.Ptr("eastus"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AllowBlobPublicAccess: to.Ptr(false),
	// 			AllowSharedKeyAccess: to.Ptr(true),
	// 			CreationTime: to.Ptr(time.Date(2017, time.May, 24, 13, 25, 33, 486323600, time.UTC)),
	// 			Encryption: &armstorage.Encryption{
	// 				KeySource: to.Ptr(armstorage.KeySourceMicrosoftStorage),
	// 				RequireInfrastructureEncryption: to.Ptr(false),
	// 				Services: &armstorage.EncryptionServices{
	// 					Blob: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 					File: &armstorage.EncryptionService{
	// 						Enabled: to.Ptr(true),
	// 						KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 						LastEnabledTime: to.Ptr(time.Date(2019, time.December, 11, 20, 49, 31, 703614000, time.UTC)),
	// 					},
	// 				},
	// 			},
	// 			IsHnsEnabled: to.Ptr(true),
	// 			IsSftpEnabled: to.Ptr(true),
	// 			KeyCreationTime: &armstorage.KeyCreationTime{
	// 				Key1: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 				Key2: to.Ptr(time.Date(2021, time.March, 18, 4, 42, 22, 432283600, time.UTC)),
	// 			},
	// 			KeyPolicy: &armstorage.KeyPolicy{
	// 				KeyExpirationPeriodInDays: to.Ptr[int32](20),
	// 			},
	// 			MinimumTLSVersion: to.Ptr(armstorage.MinimumTLSVersionTLS12),
	// 			PrimaryEndpoints: &armstorage.Endpoints{
	// 				Blob: to.Ptr("https://sto4445.blob.core.windows.net/"),
	// 				Dfs: to.Ptr("https://sto4445.dfs.core.windows.net/"),
	// 				File: to.Ptr("https://sto4445.file.core.windows.net/"),
	// 				InternetEndpoints: &armstorage.AccountInternetEndpoints{
	// 					Blob: to.Ptr("https://sto4445-internetrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-internetrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-internetrouting.file.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-internetrouting.web.core.windows.net/"),
	// 				},
	// 				MicrosoftEndpoints: &armstorage.AccountMicrosoftEndpoints{
	// 					Blob: to.Ptr("https://sto4445-microsoftrouting.blob.core.windows.net/"),
	// 					Dfs: to.Ptr("https://sto4445-microsoftrouting.dfs.core.windows.net/"),
	// 					File: to.Ptr("https://sto4445-microsoftrouting.file.core.windows.net/"),
	// 					Queue: to.Ptr("https://sto4445-microsoftrouting.queue.core.windows.net/"),
	// 					Table: to.Ptr("https://sto4445-microsoftrouting.table.core.windows.net/"),
	// 					Web: to.Ptr("https://sto4445-microsoftrouting.web.core.windows.net/"),
	// 				},
	// 				Queue: to.Ptr("https://sto4445.queue.core.windows.net/"),
	// 				Table: to.Ptr("https://sto4445.table.core.windows.net/"),
	// 				Web: to.Ptr("https://sto4445.web.core.windows.net/"),
	// 			},
	// 			PrimaryLocation: to.Ptr("eastus2euap"),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			RoutingPreference: &armstorage.RoutingPreference{
	// 				PublishInternetEndpoints: to.Ptr(true),
	// 				PublishMicrosoftEndpoints: to.Ptr(true),
	// 				RoutingChoice: to.Ptr(armstorage.RoutingChoiceMicrosoftRouting),
	// 			},
	// 			SasPolicy: &armstorage.SasPolicy{
	// 				ExpirationAction: to.Ptr(armstorage.ExpirationActionLog),
	// 				SasExpirationPeriod: to.Ptr("1.15:59:59"),
	// 			},
	// 			SecondaryLocation: to.Ptr("centraluseuap"),
	// 			StatusOfPrimary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			StatusOfSecondary: to.Ptr(armstorage.AccountStatusAvailable),
	// 			EnableHTTPSTrafficOnly: to.Ptr(true),
	// 			GeoPriorityReplicationStatus: &armstorage.GeoPriorityReplicationStatus{
	// 				IsBlobEnabled: to.Ptr(true),
	// 			},
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardGRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Tags: map[string]*string{
	// 			"key1": to.Ptr("value1"),
	// 			"key2": to.Ptr("value2"),
	// 		},
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateWithSmartAccessTier.json
 */
async function storageAccountCreateWithSmartAccessTier() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "sto4445", {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    kind: "Storage",
    location: "eastus",
    accessTier: "Smart",
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    minimumTlsVersion: "TLS1_2",
    routingPreference: {
      publishInternetEndpoints: true,
      publishMicrosoftEndpoints: true,
      routingChoice: "MicrosoftRouting",
    },
    sasPolicy: { expirationAction: "Log", sasExpirationPeriod: "1.15:59:59" },
    geoPriorityReplicationStatus: { isBlobEnabled: true },
    sku: { name: "Standard_GRS" },
    tags: { key1: "value1", key2: "value2" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/staturbocontoso01?api-version=2026-09-01

{
  "kind": "StorageV2",
  "location": "eastus2",
  "properties": {
    "accessTier": "Hot",
    "turboTier": {
      "status": "Enabled",
      "targetPercent": 10
    }
  },
  "sku": {
    "name": "Standard_LRS"
  }
}

import com.azure.resourcemanager.storage.models.AccessTier;
import com.azure.resourcemanager.storage.models.Kind;
import com.azure.resourcemanager.storage.models.Sku;
import com.azure.resourcemanager.storage.models.SkuName;
import com.azure.resourcemanager.storage.models.StorageAccountCreateParameters;
import com.azure.resourcemanager.storage.models.TurboTier;
import com.azure.resourcemanager.storage.models.TurboTierStatus;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for StorageAccounts Create.
 */
public final class Main {
    /*
     * x-ms-original-file: 2026-09-01/StorageAccountCreateWithTurboTier.json
     */
    /**
     * Sample code: StorageAccountCreateWithTurboTier.
     * 
     * @param manager Entry point to StorageManager.
     */
    public static void storageAccountCreateWithTurboTier(com.azure.resourcemanager.storage.StorageManager manager) {
        manager.serviceClient().getStorageAccounts().create("res9101", "staturbocontoso01",
            new StorageAccountCreateParameters().withSku(new Sku().withName(SkuName.STANDARD_LRS))
                .withKind(Kind.STORAGE_V2).withLocation("eastus2").withAccessTier(AccessTier.HOT)
                .withTurboTier(new TurboTier().withStatus(TurboTierStatus.ENABLED).withTargetPercent(10)),
            com.azure.core.util.Context.NONE);
    }

    // Use "Map.of" if available
    @SuppressWarnings("unchecked")
    private static <T> Map<String, T> mapOf(Object... inputs) {
        Map<String, T> map = new HashMap<>();
        for (int i = 0; i < inputs.length; i += 2) {
            String key = (String) inputs[i];
            T value = (T) inputs[i + 1];
            map.put(key, value);
        }
        return map;
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

from azure.identity import DefaultAzureCredential

from azure.mgmt.storage import StorageManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-storage
# USAGE
    python storage_account_create_with_turbo_tier.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = StorageManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="SUBSCRIPTION_ID",
    )

    response = client.storage_accounts.begin_create(
        resource_group_name="res9101",
        account_name="staturbocontoso01",
        parameters={
            "kind": "StorageV2",
            "location": "eastus2",
            "properties": {"accessTier": "Hot", "turboTier": {"status": "Enabled", "targetPercent": 10}},
            "sku": {"name": "Standard_LRS"},
        },
    ).result()
    print(response)


# x-ms-original-file: 2026-09-01/StorageAccountCreateWithTurboTier.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

package armstorage_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/storage/armstorage/v4"
)

// Generated from example definition: 2026-09-01/StorageAccountCreateWithTurboTier.json
func ExampleAccountsClient_BeginCreate_storageAccountCreateWithTurboTier() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armstorage.NewClientFactory("00000000-0000-0000-0000-000000000000", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewAccountsClient().BeginCreate(ctx, "res9101", "staturbocontoso01", armstorage.AccountCreateParameters{
		Kind:     to.Ptr(armstorage.KindStorageV2),
		Location: to.Ptr("eastus2"),
		Properties: &armstorage.AccountPropertiesCreateParameters{
			AccessTier: to.Ptr(armstorage.AccessTierHot),
			TurboTier: &armstorage.TurboTier{
				Status:        to.Ptr(armstorage.TurboTierStatusEnabled),
				TargetPercent: to.Ptr[int32](10),
			},
		},
		SKU: &armstorage.SKU{
			Name: to.Ptr(armstorage.SKUNameStandardLRS),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to poll the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res = armstorage.AccountsClientCreateResponse{
	// 	Account: armstorage.Account{
	// 		ID: to.Ptr("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/staturbocontoso01"),
	// 		Kind: to.Ptr(armstorage.KindStorageV2),
	// 		Location: to.Ptr("eastus2"),
	// 		Name: to.Ptr("staturbocontoso01"),
	// 		Properties: &armstorage.AccountProperties{
	// 			AccessTier: to.Ptr(armstorage.AccessTierHot),
	// 			ProvisioningState: to.Ptr(armstorage.ProvisioningStateSucceeded),
	// 			TurboTier: &armstorage.TurboTier{
	// 				Status: to.Ptr(armstorage.TurboTierStatusEnabled),
	// 				TargetPercent: to.Ptr[int32](10),
	// 			},
	// 		},
	// 		SKU: &armstorage.SKU{
	// 			Name: to.Ptr(armstorage.SKUNameStandardLRS),
	// 			Tier: to.Ptr(armstorage.SKUTierStandard),
	// 		},
	// 		Type: to.Ptr("Microsoft.Storage/storageAccounts"),
	// 	},
	// }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

const { StorageManagementClient } = require("@azure/arm-storage");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 *
 * @summary asynchronously creates a new storage account with the specified parameters. If an account is already created and a subsequent create request is issued with different properties, the account properties will be updated. If an account is already created and a subsequent create or update request is issued with the exact same set of properties, the request will succeed.
 * x-ms-original-file: 2026-09-01/StorageAccountCreateWithTurboTier.json
 */
async function storageAccountCreateWithTurboTier() {
  const credential = new DefaultAzureCredential();
  const subscriptionId = "00000000-0000-0000-0000-000000000000";
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.create("res9101", "staturbocontoso01", {
    kind: "StorageV2",
    location: "eastus2",
    accessTier: "Hot",
    turboTier: { status: "Enabled", targetPercent: 10 },
    sku: { name: "Standard_LRS" },
  });
  console.log(result);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue