Storage Accounts - Create

Referencia

Szolgáltatás:: Storage Resource Provider

API-verzió:: 2024-01-01

Aszinkron módon létrehoz egy új tárfiókot a megadott paraméterekkel. Ha már létrehozott egy fiókot, és egy későbbi létrehozási kérelmet adnak ki különböző tulajdonságokkal, a fióktulajdonságok frissülnek. Ha már létrehozott egy fiókot, és egy későbbi létrehozási vagy frissítési kérelmet adnak ki pontosan ugyanazzal a tulajdonságkészlettel, a kérés sikeres lesz.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Storage/storageAccounts/{accountName}?api-version=2024-01-01

URI-paraméterek

Name	In	Kötelező	Típus	Description
accountName	path	True	string minLength: 3 maxLength: 24 pattern: ^[a-z0-9]+$	A tárfiók neve a megadott erőforráscsoporton belül. A tárfiókok nevének 3 és 24 karakter közötti hosszúságúnak kell lennie, és csak számokat és kisbetűket kell használnia.
resourceGroupName	path	True	string minLength: 1 maxLength: 90 pattern: ^[-\w\._]+$	A felhasználó előfizetésében lévő erőforráscsoport neve. A név nem megkülönbözteti a kis- és nagybetűket.
subscriptionId	path	True	string minLength: 1	A cél-előfizetés azonosítója.
api-version	query	True	string minLength: 1	A művelethez használandó API-verzió.

Kérelem törzse

Name	Kötelező	Típus	Description
kind	True	Kind	Szükséges. A tárfiók típusát jelzi.
location	True	string	Szükséges. Lekéri vagy beállítja az erőforrás helyét. Ez lesz az egyik támogatott és regisztrált Azure GeoRégió (pl. USA nyugati régiója, USA keleti régiója, Délkelet-Ázsia stb.). Az erőforrás georégióját a létrehozás után nem lehet módosítani, de ha a frissítéskor azonos georégiót ad meg, a kérés sikeres lesz.
sku	True	Sku	Szükséges. Lekéri vagy beállítja a termékváltozat nevét.
extendedLocation		ExtendedLocation	Opcionális. Állítsa be az erőforrás kiterjesztett helyét. Ha nincs beállítva, a tárfiók az Azure fő régiójában jön létre. Ellenkező esetben a rendszer a megadott kiterjesztett helyen hozza létre
identity		Identity	Az erőforrás identitása.
properties.accessTier		AccessTier	Olyan tárfiókokhoz szükséges, ahol a típus = BlobStorage. A hozzáférési szint a számlázáshoz használatos. A prémium szintű hozzáférési szint a prémium szintű blokkblobok tárfióktípusának alapértelmezett értéke, és a prémium szintű blokkblobok tárfióktípusa esetében nem módosítható.
properties.allowBlobPublicAccess		boolean	Nyilvános hozzáférés engedélyezése vagy letiltása a tárfiókban lévő összes blobhoz vagy tárolóhoz. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.allowCrossTenantReplication		boolean	Az AAD-bérlői objektumok közötti replikáció engedélyezése vagy letiltása. Ezt a tulajdonságot csak akkor állítsa true értékre új vagy meglévő fiókokra, ha az objektumreplikációs szabályzatok különböző AAD-bérlők tárfiókjait érintik. Az alapértelmezett értelmezés hamis, ha az új fiókok alapértelmezés szerint követik az ajánlott biztonsági eljárásokat.
properties.allowSharedKeyAccess		boolean	Azt jelzi, hogy a tárfiók engedélyezi-e a fiók hozzáférési kulcsával való engedélyezést a megosztott kulccsal. Ha hamis, akkor minden kérést, beleértve a közös hozzáférésű jogosultságkódokat is, engedélyezni kell az Azure Active Directoryval (Azure AD). Az alapértelmezett érték null, ami az igaz értéknek felel meg.
properties.allowedCopyScope		AllowedCopyScope	Korlátozza az AAD-bérlőn belüli vagy az ugyanazon virtuális hálózatra mutató privát hivatkozásokkal rendelkező tárfiókok másolását.
properties.azureFilesIdentityBasedAuthentication		AzureFilesIdentityBasedAuthentication	Megadja az Azure Files identitásalapú hitelesítési beállításait.
properties.customDomain		CustomDomain	A tárfiókhoz rendelt felhasználói tartomány. A név a CNAME forrás. Tárfiókonként jelenleg csak egy egyéni tartomány támogatott. A meglévő egyéni tartomány törléséhez használjon egy üres sztringet az egyéni tartománynév tulajdonsághoz.
properties.defaultToOAuthAuthentication		boolean	Logikai jelző, amely azt jelzi, hogy az alapértelmezett hitelesítés OAuth-e vagy sem. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.dnsEndpointType		DnsEndpointType	Lehetővé teszi a végpont típusának megadását. Állítsa ezt az AzureDNSZone értékre, hogy egyetlen előfizetésben nagyszámú fiókot hozzon létre, amely fiókokat hoz létre egy Azure DNS-zónában, és a végpont URL-címe alfanumerikus DNS-zónaazonosítóval fog rendelkezni.
properties.enableExtendedGroups		boolean	Kiterjesztett csoporttámogatás engedélyezése a helyi felhasználók funkcióval, ha igaz értékre van állítva
properties.encryption		Encryption	A tárfiók kiszolgálóoldali titkosításához használandó titkosítási beállítások.
properties.immutableStorageWithVersioning		ImmutableStorageAccount	A tulajdonság nem módosítható, és csak a fiók létrehozásakor állítható be igaz értékre. Ha igaz értékre van állítva, alapértelmezés szerint engedélyezi az objektumszintű nem módosíthatóságot a fiók összes új tárolója számára.
properties.isHnsEnabled		boolean	A Fiókhierarchianévtér engedélyezve van, ha igaz értékre van állítva.
properties.isLocalUserEnabled		boolean	Engedélyezi a helyi felhasználók funkcióját, ha igaz értékre van állítva
properties.isNfsV3Enabled		boolean	Az NFS 3.0 protokoll támogatása engedélyezve van, ha igaz értékre van állítva.
properties.isSftpEnabled		boolean	Engedélyezi a biztonságos fájlátviteli protokollt, ha igaz értékre van állítva
properties.keyPolicy		KeyPolicy	A tárfiókhoz rendelt KeyPolicy.
properties.largeFileSharesState		LargeFileSharesState	Nagy fájlmegosztások engedélyezése, ha a beállítás engedélyezve van. Az engedélyezés után nem tiltható le.
properties.minimumTlsVersion		MinimumTlsVersion	Állítsa be a minimális TLS-verziót, hogy a tárterületre irányuló kérések esetén engedélyezve legyen. Ennek a tulajdonságnak az alapértelmezett értelmezése a TLS 1.0.
properties.networkAcls		NetworkRuleSet	Hálózati szabálykészlet
properties.publicNetworkAccess		PublicNetworkAccess	Engedélyezze, tiltsa le vagy hagyja, hogy a hálózati biztonsági peremhálózat konfigurációja kiértékelje a tárfiókhoz való nyilvános hálózati hozzáférést. Az érték megadása nem kötelező, de ha be van adva, akkor "Engedélyezve", "Letiltva" vagy "SecuredByPerimeter" értéknek kell lennie.
properties.routingPreference		RoutingPreference	A felhasználó által az adatátvitelhez választott hálózati útválasztással kapcsolatos információk megőrzése
properties.sasPolicy		SasPolicy	SasPolicy hozzárendelve a tárfiókhoz.
properties.supportsHttpsTrafficOnly		boolean	Csak akkor engedélyezi a https-forgalmat a tárolási szolgáltatásba, ha igaz értékre van adva. Az alapértelmezett érték igaz az API 2019-04-01-es verziója óta.
tags		object	Lekéri vagy beállítja az erőforrást leíró kulcsértékpárok listáját. Ezek a címkék használhatók az erőforrás megtekintéséhez és csoportosításához (erőforráscsoportok között). Egy erőforráshoz legfeljebb 15 címke adható meg. Minden címkének 128 karakternél nem hosszabb és 256 karakternél nem hosszabb hosszúságú kulccsal kell rendelkeznie.

Válaszok

Name	Típus	Description
200 OK	StorageAccount	OK – akkor lett visszaadva, ha a tárfiók már létrejött egy korábbi kérésből, a kérelem törzsében megadott ugyanazokkal a tulajdonságokkal.
202 Accepted		Elfogadva – A kérelem létrehozása vagy frissítése elfogadva; művelet aszinkron módon fejeződik be.

Biztonság

azure_auth

Azure Active Directory OAuth2-folyamat

Típus: oauth2
Folyamat: implicit
Engedélyezési URL: https://login.microsoftonline.com/common/oauth2/authorize

Hatókörök

Name	Description
user_impersonation	a felhasználói fiók megszemélyesítése

Példák

NfsV3AccountCreate

StorageAccountCreate

StorageAccountCreateAllowedCopyScopeToAAD

StorageAccountCreateAllowedCopyScopeToPrivateLink

StorageAccountCreateDisallowPublicNetworkAccess

StorageAccountCreateDnsEndpointTypeToAzureDnsZone

StorageAccountCreateDnsEndpointTypeToStandard

StorageAccountCreateEnablePublicNetworkAccess

StorageAccountCreatePremiumBlockBlobStorage

StorageAccountCreateUserAssignedEncryptionIdentityWithCMK

StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.

StorageAccountCreateWithImmutabilityPolicy

NfsV3AccountCreate

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

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


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:
     * specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/NfsV3AccountCreate.json
     */
    /**
     * Sample code: NfsV3AccountCreate.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void nfsV3AccountCreate(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Kind: to.Ptr(armstorage.KindBlockBlobStorage),
	// 	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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/NfsV3AccountCreate.json
 */
async function nfsV3AccountCreate() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    enableExtendedGroups: true,
    isHnsEnabled: true,
    enableNfsV3: true,
    kind: "BlockBlobStorage",
    location: "eastus",
    networkRuleSet: {
      bypass: "AzureServices",
      defaultAction: "Allow",
      ipRules: [],
      virtualNetworkRules: [
        {
          virtualNetworkResourceId:
            "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12",
        },
      ],
    },
    sku: { name: "Premium_LRS" },
    enableHttpsTrafficOnly: false,
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/NfsV3AccountCreate.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.PremiumLrs), StorageKind.BlockBlobStorage, new AzureLocation("eastus"))
{
    NetworkRuleSet = new StorageAccountNetworkRuleSet(StorageNetworkDefaultAction.Allow)
    {
        Bypass = StorageNetworkBypass.AzureServices,
        VirtualNetworkRules = { new StorageAccountVirtualNetworkRule(new ResourceIdentifier("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Network/virtualNetworks/net123/subnets/subnet12")) },
        IPRules = { },
    },
    EnableHttpsTrafficOnly = false,
    IsExtendedGroupEnabled = true,
    IsHnsEnabled = true,
    IsNfsV3Enabled = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

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

Állapotkód:: 202

StorageAccountCreate

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "defaultToOAuthAuthentication": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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.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:
     * specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreate.json
     */
    /**
     * Sample code: StorageAccountCreate.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void storageAccountCreate(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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),
                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,
                "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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"),
		},
	}, 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		IsSftpEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreate.json
 */
async function storageAccountCreate() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    defaultToOAuthAuthentication: false,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreate.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsSftpEnabled = true,
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
    IsDefaultToOAuthAuthentication = false,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateAllowedCopyScopeToAAD

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "allowedCopyScope": "AAD",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateAllowedCopyScopeToAAD.json
     */
    /**
     * Sample code: StorageAccountCreateAllowedCopyScopeToAAD.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void storageAccountCreateAllowedCopyScopeToAAD(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		AllowedCopyScope: to.Ptr(armstorage.AllowedCopyScopeAAD),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateAllowedCopyScopeToAAD.json
 */
async function storageAccountCreateAllowedCopyScopeToAad() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    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 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateAllowedCopyScopeToAAD.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    AllowedCopyScope = AllowedCopyScope.Aad,
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true,
    "allowedCopyScope": "AAD"
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateAllowedCopyScopeToPrivateLink

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "allowedCopyScope": "PrivateLink",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateAllowedCopyScopeToPrivateLink.json
     */
    /**
     * Sample code: StorageAccountCreateAllowedCopyScopeToPrivateLink.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateAllowedCopyScopeToPrivateLink(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		AllowedCopyScope: to.Ptr(armstorage.AllowedCopyScopePrivateLink),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
 */
async function storageAccountCreateAllowedCopyScopeToPrivateLink() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    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 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateAllowedCopyScopeToPrivateLink.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    AllowedCopyScope = AllowedCopyScope.PrivateLink,
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true,
    "allowedCopyScope": "PrivateLink"
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateDisallowPublicNetworkAccess

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "publicNetworkAccess": "Disabled",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateDisallowPublicNetworkAccess.json
     */
    /**
     * Sample code: StorageAccountCreateDisallowPublicNetworkAccess.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateDisallowPublicNetworkAccess(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDisallowPublicNetworkAccess.json
 */
async function storageAccountCreateDisallowPublicNetworkAccess() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDisallowPublicNetworkAccess.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    PublicNetworkAccess = StoragePublicNetworkAccess.Disabled,
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true,
    "publicNetworkAccess": "Disabled"
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateDnsEndpointTypeToAzureDnsZone

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "dnsEndpointType": "AzureDnsZone",
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "defaultToOAuthAuthentication": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
     */
    /**
     * Sample code: StorageAccountCreateDnsEndpointTypeToAzureDnsZone.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateDnsEndpointTypeToAzureDnsZone(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		IsSftpEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
 */
async function storageAccountCreateDnsEndpointTypeToAzureDnsZone() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    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" },
      },
    },
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDnsEndpointTypeToAzureDnsZone.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsSftpEnabled = true,
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
    IsDefaultToOAuthAuthentication = false,
    DnsEndpointType = StorageDnsEndpointType.AzureDnsZone,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "dnsEndpointType": "AzureDnsZone",
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.z24.web.storage.azure.net/",
      "dfs": "https://sto4445.z24.dfs.storage.azure.net/",
      "blob": "https://sto4445.z24.blob.storage.azure.net/",
      "file": "https://sto4445.z24.file.storage.azure.net/",
      "queue": "https://sto4445.z24.queue.storage.azure.net/",
      "table": "https://sto4445.z24.table.storage.azure.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.z24.web.storage.azure.net/",
        "dfs": "https://sto4445-microsoftrouting.z24.dfs.storage.azure.net/",
        "blob": "https://sto4445-microsoftrouting.z24.blob.storage.azure.net/",
        "file": "https://sto4445-microsoftrouting.z24.file.storage.azure.net/",
        "queue": "https://sto4445-microsoftrouting.z24.queue.storage.azure.net/",
        "table": "https://sto4445-microsoftrouting.z24.table.storage.azure.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.z24.web.storage.azure.net/",
        "dfs": "https://sto4445-internetrouting.z24.dfs.storage.azure.net/",
        "blob": "https://sto4445-internetrouting.z24.blob.storage.azure.net/",
        "file": "https://sto4445-internetrouting.z24.file.storage.azure.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateDnsEndpointTypeToStandard

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "dnsEndpointType": "Standard",
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "defaultToOAuthAuthentication": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateDnsEndpointTypeToStandard.json
     */
    /**
     * Sample code: StorageAccountCreateDnsEndpointTypeToStandard.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateDnsEndpointTypeToStandard(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		IsSftpEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDnsEndpointTypeToStandard.json
 */
async function storageAccountCreateDnsEndpointTypeToStandard() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    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" },
      },
    },
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    isHnsEnabled: true,
    isSftpEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateDnsEndpointTypeToStandard.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsSftpEnabled = true,
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
    IsDefaultToOAuthAuthentication = false,
    DnsEndpointType = StorageDnsEndpointType.Standard,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "dnsEndpointType": "Standard",
    "isHnsEnabled": true,
    "isSftpEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateEnablePublicNetworkAccess

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Standard_GRS"
  },
  "kind": "Storage",
  "location": "eastus",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "publicNetworkAccess": "Enabled",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateEnablePublicNetworkAccess.json
     */
    /**
     * Sample code: StorageAccountCreateEnablePublicNetworkAccess.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateEnablePublicNetworkAccess(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		AllowSharedKeyAccess: to.Ptr(true),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		IsHnsEnabled: to.Ptr(true),
	// 		KeyCreationTime: &armstorage.KeyCreationTime{
	// 			Key1: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 			Key2: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-18T04:42:22.432Z"); return t}()),
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateEnablePublicNetworkAccess.json
 */
async function storageAccountCreateEnablePublicNetworkAccess() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    allowBlobPublicAccess: false,
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    isHnsEnabled: true,
    keyPolicy: { keyExpirationPeriodInDays: 20 },
    kind: "Storage",
    location: "eastus",
    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" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateEnablePublicNetworkAccess.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    PublicNetworkAccess = StoragePublicNetworkAccess.Enabled,
    SasPolicy = new StorageAccountSasPolicy("1.15:59:59", ExpirationAction.Log),
    KeyExpirationPeriodInDays = 20,
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    IsHnsEnabled = true,
    RoutingPreference = new StorageRoutingPreference
    {
        RoutingChoice = StorageRoutingChoice.MicrosoftRouting,
        IsMicrosoftEndpointsPublished = true,
        IsInternetEndpointsPublished = true,
    },
    AllowBlobPublicAccess = false,
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "keyPolicy": {
      "keyExpirationPeriodInDays": 20
    },
    "sasPolicy": {
      "sasExpirationPeriod": "1.15:59:59",
      "expirationAction": "Log"
    },
    "keyCreationTime": {
      "key1": "2021-03-18T04:42:22.4322836Z",
      "key2": "2021-03-18T04:42:22.4322836Z"
    },
    "isHnsEnabled": true,
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/",
      "microsoftEndpoints": {
        "web": "https://sto4445-microsoftrouting.web.core.windows.net/",
        "dfs": "https://sto4445-microsoftrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-microsoftrouting.blob.core.windows.net/",
        "file": "https://sto4445-microsoftrouting.file.core.windows.net/",
        "queue": "https://sto4445-microsoftrouting.queue.core.windows.net/",
        "table": "https://sto4445-microsoftrouting.table.core.windows.net/"
      },
      "internetEndpoints": {
        "web": "https://sto4445-internetrouting.web.core.windows.net/",
        "dfs": "https://sto4445-internetrouting.dfs.core.windows.net/",
        "blob": "https://sto4445-internetrouting.blob.core.windows.net/",
        "file": "https://sto4445-internetrouting.file.core.windows.net/"
      }
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "routingPreference": {
      "routingChoice": "MicrosoftRouting",
      "publishMicrosoftEndpoints": true,
      "publishInternetEndpoints": true
    },
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "secondaryLocation": "centraluseuap",
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true,
    "publicNetworkAccess": "Enabled"
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreatePremiumBlockBlobStorage

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

{
  "sku": {
    "name": "Premium_LRS"
  },
  "kind": "BlockBlobStorage",
  "location": "eastus",
  "properties": {
    "minimumTlsVersion": "TLS1_2",
    "allowSharedKeyAccess": true,
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true
        },
        "blob": {
          "keyType": "Account",
          "enabled": true
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    }
  },
  "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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreatePremiumBlockBlobStorage.json
     */
    /**
     * Sample code: StorageAccountCreatePremiumBlockBlobStorage.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreatePremiumBlockBlobStorage(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 		"key1": to.Ptr("value1"),
	// 		"key2": to.Ptr("value2"),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		AccessTier: to.Ptr(armstorage.AccessTierPremium),
	// 		AllowBlobPublicAccess: to.Ptr(false),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-11T20:49:31.703Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreatePremiumBlockBlobStorage.json
 */
async function storageAccountCreatePremiumBlockBlobStorage() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    allowSharedKeyAccess: true,
    encryption: {
      keySource: "Microsoft.Storage",
      requireInfrastructureEncryption: false,
      services: {
        blob: { enabled: true, keyType: "Account" },
        file: { enabled: true, keyType: "Account" },
      },
    },
    kind: "BlockBlobStorage",
    location: "eastus",
    minimumTlsVersion: "TLS1_2",
    sku: { name: "Premium_LRS" },
    tags: { key1: "value1", key2: "value2" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreatePremiumBlockBlobStorage.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.PremiumLrs), StorageKind.BlockBlobStorage, new AzureLocation("eastus"))
{
    Tags =
    {
    ["key1"] = "value1",
    ["key2"] = "value2"
    },
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.Storage,
        RequireInfrastructureEncryption = false,
    },
    MinimumTlsVersion = StorageMinimumTlsVersion.Tls1_2,
    AllowSharedKeyAccess = true,
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "properties": {
    "allowBlobPublicAccess": false,
    "minimumTlsVersion": "TLS1_2",
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "blob": "https://sto4445.blob.core.windows.net/",
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/"
    },
    "primaryLocation": "eastus2euap",
    "accessTier": "Premium",
    "provisioningState": "Succeeded",
    "encryption": {
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2019-12-11T20:49:31.7036140Z"
        }
      },
      "requireInfrastructureEncryption": false,
      "keySource": "Microsoft.Storage"
    },
    "statusOfPrimary": "available",
    "statusOfSecondary": "available",
    "supportsHttpsTrafficOnly": true
  },
  "sku": {
    "name": "Premium_LRS",
    "tier": "Premium"
  },
  "tags": {
    "key1": "value1",
    "key2": "value2"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

StorageAccountCreateUserAssignedEncryptionIdentityWithCMK

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

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


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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
     */
    /**
     * Sample code: StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void storageAccountCreateUserAssignedEncryptionIdentityWithCMK(
        com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 	},
	// 	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),
	// 	Properties: &armstorage.AccountProperties{
	// 		AccessTier: to.Ptr(armstorage.AccessTierHot),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.083Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-13T20:36:23.702Z"); return t}()),
	// 			},
	// 			Services: &armstorage.EncryptionServices{
	// 				Blob: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.173Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.173Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
 */
async function storageAccountCreateUserAssignedEncryptionIdentityWithCmk() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    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" },
      },
    },
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/{subscriptionId}/resourceGroups/res9101/providers/MicrosoftManagedIdentity/userAssignedIdentities/{managedIdentityName}":
          {},
      },
    },
    kind: "Storage",
    location: "eastus",
    sku: { name: "Standard_LRS" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateUserAssignedEncryptionIdentityWithCMK.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardLrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    Identity = new ManagedServiceIdentity("UserAssigned")
    {
        UserAssignedIdentities =
        {
        [new ResourceIdentifier("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}")] = new UserAssignedIdentity()
        },
    },
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.KeyVault,
        KeyVaultProperties = new StorageAccountKeyVaultProperties
        {
            KeyName = "wrappingKey",
            KeyVersion = "",
            KeyVaultUri = new Uri("https://myvault8569.vault.azure.net"),
        },
        EncryptionIdentity = new StorageAccountEncryptionIdentity
        {
            EncryptionUserAssignedIdentity = "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
        },
    },
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "identity": {
    "userAssignedIdentities": {
      "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {
        "principalId": "8d823284-1060-42a5-9ec4-ed3d831e24d7",
        "clientId": "fbaa6278-1ecc-415c-819f-6e2058d3acb5"
      }
    },
    "type": "UserAssigned"
  },
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "kind": "StorageV2",
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "name": "sto4445",
  "type": "Microsoft.Storage/storageAccounts",
  "location": "eastus",
  "tags": {},
  "properties": {
    "privateEndpointConnections": [],
    "networkAcls": {
      "bypass": "AzureServices",
      "virtualNetworkRules": [],
      "ipRules": [],
      "defaultAction": "Allow"
    },
    "supportsHttpsTrafficOnly": true,
    "encryption": {
      "identity": {
        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourcegroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}"
      },
      "keyvaultproperties": {
        "keyvaulturi": "https://myvault8569.vault.azure.net",
        "keyname": "wrappingKey",
        "keyversion": "",
        "currentVersionedKeyIdentifier": "https://myvault8569.vault.azure.net/keys/wrappingKey/0682afdd9c104f4285df20107e956cad",
        "lastKeyRotationTimestamp": "2019-12-13T20:36:23.7023290Z"
      },
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2020-12-15T00:43:14.1739587Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2020-12-15T00:43:14.1739587Z"
        }
      },
      "keySource": "Microsoft.Keyvault"
    },
    "accessTier": "Hot",
    "provisioningState": "Succeeded",
    "creationTime": "2020-12-15T00:43:14.0839093Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/"
    },
    "primaryLocation": "eastus",
    "statusOfPrimary": "available"
  }
}

Állapotkód:: 202

StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res131918/providers/Microsoft.Storage/storageAccounts/sto131918?api-version=2024-01-01

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


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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
     */
    /**
     * Sample code: StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void storageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId(
        com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	Tags: map[string]*string{
	// 	},
	// 	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),
	// 	Properties: &armstorage.AccountProperties{
	// 		AccessTier: to.Ptr(armstorage.AccessTierHot),
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.083Z"); return t}()),
	// 		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(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2019-12-13T20:36:23.702Z"); return t}()),
	// 			},
	// 			Services: &armstorage.EncryptionServices{
	// 				Blob: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.173Z"); return t}()),
	// 				},
	// 				File: &armstorage.EncryptionService{
	// 					Enabled: to.Ptr(true),
	// 					KeyType: to.Ptr(armstorage.KeyTypeAccount),
	// 					LastEnabledTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-12-15T00:43:14.173Z"); return t}()),
	// 				},
	// 			},
	// 		},
	// 		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),
	// 	},
	// }
}

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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
 */
async function storageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res131918";
  const accountName = "sto131918";
  const parameters = {
    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" },
      },
    },
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/{subscriptionId}/resourceGroups/res9101/providers/MicrosoftManagedIdentity/userAssignedIdentities/{managedIdentityName}":
          {},
      },
    },
    kind: "Storage",
    location: "eastus",
    sku: { name: "Standard_LRS" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res131918";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto131918";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardLrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    Identity = new ManagedServiceIdentity("UserAssigned")
    {
        UserAssignedIdentities =
        {
        [new ResourceIdentifier("/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}")] = new UserAssignedIdentity()
        },
    },
    Encryption = new StorageAccountEncryption
    {
        Services = new StorageAccountEncryptionServices
        {
            Blob = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
            File = new StorageEncryptionService
            {
                IsEnabled = true,
                KeyType = StorageEncryptionKeyType.Account,
            },
        },
        KeySource = StorageAccountKeySource.KeyVault,
        KeyVaultProperties = new StorageAccountKeyVaultProperties
        {
            KeyName = "wrappingKey",
            KeyVersion = "",
            KeyVaultUri = new Uri("https://myvault8569.vault.azure.net"),
        },
        EncryptionIdentity = new StorageAccountEncryptionIdentity
        {
            EncryptionUserAssignedIdentity = "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
            EncryptionFederatedIdentityClientId = "f83c6b1b-4d34-47e4-bb34-9d83df58b540",
        },
    },
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "identity": {
    "userAssignedIdentities": {
      "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}": {
        "principalId": "8d823284-1060-42a5-9ec4-ed3d831e24d7",
        "clientId": "fbaa6278-1ecc-415c-819f-6e2058d3acb5"
      }
    },
    "type": "UserAssigned"
  },
  "sku": {
    "name": "Standard_LRS",
    "tier": "Standard"
  },
  "kind": "StorageV2",
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "name": "sto4445",
  "type": "Microsoft.Storage/storageAccounts",
  "location": "eastus",
  "tags": {},
  "properties": {
    "privateEndpointConnections": [],
    "networkAcls": {
      "bypass": "AzureServices",
      "virtualNetworkRules": [],
      "ipRules": [],
      "defaultAction": "Allow"
    },
    "supportsHttpsTrafficOnly": true,
    "encryption": {
      "identity": {
        "userAssignedIdentity": "/subscriptions/{subscription-id}/resourcegroups/res9101/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{managed-identity-name}",
        "federatedIdentityClientId": "f83c6b1b-4d34-47e4-bb34-9d83df58b540"
      },
      "keyvaultproperties": {
        "keyvaulturi": "https://myvault8569.vault.azure.net",
        "keyname": "wrappingKey",
        "keyversion": "",
        "currentVersionedKeyIdentifier": "https://myvault8569.vault.azure.net/keys/wrappingKey/0682afdd9c104f4285df20107e956cad",
        "lastKeyRotationTimestamp": "2019-12-13T20:36:23.7023290Z"
      },
      "services": {
        "file": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2020-12-15T00:43:14.1739587Z"
        },
        "blob": {
          "keyType": "Account",
          "enabled": true,
          "lastEnabledTime": "2020-12-15T00:43:14.1739587Z"
        }
      },
      "keySource": "Microsoft.Keyvault"
    },
    "accessTier": "Hot",
    "provisioningState": "Succeeded",
    "creationTime": "2020-12-15T00:43:14.0839093Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/"
    },
    "primaryLocation": "eastus",
    "statusOfPrimary": "available"
  }
}

Állapotkód:: 202

StorageAccountCreateWithImmutabilityPolicy

Mintakérelem

PUT https://management.azure.com/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445?api-version=2024-01-01

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


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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/
     * StorageAccountCreateWithImmutabilityPolicy.json
     */
    /**
     * Sample code: StorageAccountCreateWithImmutabilityPolicy.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        storageAccountCreateWithImmutabilityPolicy(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.storageAccounts().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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/97ee23a6db6078abcbec7b75bf9af8c503e9bb8b/specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/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("<subscription-id>", 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 pull 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.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"),
	// 	Location: to.Ptr("eastus"),
	// 	ExtendedLocation: &armstorage.ExtendedLocation{
	// 		Name: to.Ptr("losangeles001"),
	// 		Type: to.Ptr(armstorage.ExtendedLocationTypesEdgeZone),
	// 	},
	// 	Kind: to.Ptr(armstorage.KindStorage),
	// 	Properties: &armstorage.AccountProperties{
	// 		CreationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-05-24T13:25:33.486Z"); return t}()),
	// 		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");
require("dotenv/config");

/**
 * 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: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateWithImmutabilityPolicy.json
 */
async function storageAccountCreateWithImmutabilityPolicy() {
  const subscriptionId = process.env["STORAGE_SUBSCRIPTION_ID"] || "{subscription-id}";
  const resourceGroupName = process.env["STORAGE_RESOURCE_GROUP"] || "res9101";
  const accountName = "sto4445";
  const parameters = {
    extendedLocation: { name: "losangeles001", type: "EdgeZone" },
    immutableStorageWithVersioning: {
      enabled: true,
      immutabilityPolicy: {
        allowProtectedAppendWrites: true,
        immutabilityPeriodSinceCreationInDays: 15,
        state: "Unlocked",
      },
    },
    kind: "Storage",
    location: "eastus",
    sku: { name: "Standard_GRS" },
  };
  const credential = new DefaultAzureCredential();
  const client = new StorageManagementClient(credential, subscriptionId);
  const result = await client.storageAccounts.beginCreateAndWait(
    resourceGroupName,
    accountName,
    parameters,
  );
  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

using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Resources.Models;
using Azure.ResourceManager.Storage.Models;
using Azure.ResourceManager.Storage;

// Generated from example definition: specification/storage/resource-manager/Microsoft.Storage/stable/2024-01-01/examples/StorageAccountCreateWithImmutabilityPolicy.json
// this example is just showing the usage of "StorageAccounts_Create" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "{subscription-id}";
string resourceGroupName = "res9101";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);

// get the collection of this StorageAccountResource
StorageAccountCollection collection = resourceGroupResource.GetStorageAccounts();

// invoke the operation
string accountName = "sto4445";
StorageAccountCreateOrUpdateContent content = new StorageAccountCreateOrUpdateContent(new StorageSku(StorageSkuName.StandardGrs), StorageKind.Storage, new AzureLocation("eastus"))
{
    ExtendedLocation = new ExtendedLocation
    {
        Name = "losangeles001",
    },
    ImmutableStorageWithVersioning = new ImmutableStorageAccount
    {
        IsEnabled = true,
        ImmutabilityPolicy = new AccountImmutabilityPolicy
        {
            ImmutabilityPeriodSinceCreationInDays = 15,
            State = AccountImmutabilityPolicyState.Unlocked,
            AllowProtectedAppendWrites = true,
        },
    },
};
ArmOperation<StorageAccountResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, accountName, content);
StorageAccountResource result = lro.Value;

// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
StorageAccountData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");

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

Mintaválasz

Állapotkód:: 200

{
  "id": "/subscriptions/{subscription-id}/resourceGroups/res9101/providers/Microsoft.Storage/storageAccounts/sto4445",
  "kind": "Storage",
  "location": "eastus",
  "name": "sto4445",
  "extendedLocation": {
    "type": "EdgeZone",
    "name": "losangeles001"
  },
  "properties": {
    "creationTime": "2017-05-24T13:25:33.4863236Z",
    "primaryEndpoints": {
      "web": "https://sto4445.web.core.windows.net/",
      "dfs": "https://sto4445.dfs.core.windows.net/",
      "blob": "https://sto4445.blob.core.windows.net/",
      "file": "https://sto4445.file.core.windows.net/",
      "queue": "https://sto4445.queue.core.windows.net/",
      "table": "https://sto4445.table.core.windows.net/"
    },
    "primaryLocation": "eastus2euap",
    "provisioningState": "Succeeded",
    "immutableStorageWithVersioning": {
      "immutabilityPolicy": {
        "immutabilityPeriodSinceCreationInDays": 15,
        "allowProtectedAppendWrites": true,
        "state": "Unlocked"
      },
      "enabled": true
    }
  },
  "sku": {
    "name": "Standard_GRS",
    "tier": "Standard"
  },
  "type": "Microsoft.Storage/storageAccounts"
}

Állapotkód:: 202

Definíciók

Name	Description
AccessTier	Olyan tárfiókokhoz szükséges, ahol a típus = BlobStorage. A hozzáférési szint a számlázáshoz használatos. A prémium szintű hozzáférési szint a prémium szintű blokkblobok tárfióktípusának alapértelmezett értéke, és a prémium szintű blokkblobok tárfióktípusa esetében nem módosítható.
AccountImmutabilityPolicyProperties	Ez határozza meg a fiókszintű nem módosítható szabályzat tulajdonságait.
AccountImmutabilityPolicyState	Az ImmutabilityPolicy állapot határozza meg a szabályzat módját. A letiltott állapot letiltja a házirendet, a zárolt állapot lehetővé teszi a nem módosítható megőrzési idő növelését és csökkentését, valamint engedélyezi az AllowProtectedAppendWrites tulajdonság összevonását, a zárolt állapot csak a nem módosítható megőrzési idő növelését teszi lehetővé. A szabályzatok csak letiltott vagy zárolt állapotban hozhatók létre, és a két állapot között válthatók. Zárolt állapotba csak zárolt állapotú házirendek válthatnak, amelyek nem állíthatók vissza.
AccountStatus	Lekéri az állapotot, amely jelzi, hogy a tárfiók elsődleges helye elérhető vagy nem érhető el.
AccountType	Az Azure Storage Active Directory-fióktípusát adja meg.
Action	A virtuális hálózati szabály művelete.
ActiveDirectoryProperties	Az Active Directory (AD) beállításainak tulajdonságai.
AllowedCopyScope	Korlátozza az AAD-bérlőn belüli vagy az ugyanazon virtuális hálózatra mutató privát hivatkozásokkal rendelkező tárfiókok másolását.
AzureFilesIdentityBasedAuthentication	Az Azure Files identitásalapú hitelesítésének beállításai.
BlobRestoreParameters	Blob-visszaállítási paraméterek
BlobRestoreProgressStatus	A blob-visszaállítás állapota. Lehetséges értékek: - Bejövő forgalom: Azt jelzi, hogy a blobok visszaállítása folyamatban van. - Kész: Azt jelzi, hogy a blob visszaállítása sikeresen befejeződött. - Sikertelen: Azt jelzi, hogy a blob visszaállítása sikertelen.
BlobRestoreRange	Blobtartomány
BlobRestoreStatus	Blob-visszaállítás állapota.
Bypass	Megadja, hogy a forgalom megkerülve legyen-e a naplózás/metrikák/AzureServices esetében. A lehetséges értékek a naplózás bármely kombinációját képezik\|Metrikák\|Az AzureServices (például "Naplózás, metrikák" vagy Nincs) a forgalom megkerüléséhez.
CustomDomain	A tárfiókhoz rendelt egyéni tartomány. Ez a frissítéssel állítható be.
DefaultAction	Az engedélyezés vagy a megtagadás alapértelmezett műveletét adja meg, ha más szabályok nem egyeznek.
DefaultSharePermission	Alapértelmezett megosztási engedély Kerberos-hitelesítést használó felhasználók számára, ha az RBAC-szerepkör nincs hozzárendelve.
DirectoryServiceOptions	A használt címtárszolgáltatást jelzi. Vegye figyelembe, hogy ez a szám a jövőben meghosszabbítható.
DnsEndpointType	Lehetővé teszi a végpont típusának megadását. Állítsa ezt az AzureDNSZone értékre, hogy egyetlen előfizetésben nagyszámú fiókot hozzon létre, amely fiókokat hoz létre egy Azure DNS-zónában, és a végpont URL-címe alfanumerikus DNS-zónaazonosítóval fog rendelkezni.
Encryption	A tárfiók titkosítási beállításai.
EncryptionIdentity	A tárfiók titkosítási identitása.
EncryptionService	Olyan szolgáltatás, amely lehetővé teszi a kiszolgálóoldali titkosítás használatát.
EncryptionServices	A titkosítást támogató szolgáltatások listája.
Endpoints	Nyilvános blob, üzenetsor, tábla, web vagy dfs objektum lekéréséhez használt URI-k.
ExpirationAction	Az SAS lejárati művelet határozza meg a sasPolicy.sasExpirationPeriod megsértése esetén végrehajtandó műveletet. A "Napló" művelet naplózási célokra használható, a "Blokk" művelet pedig az SAS-szabályzat lejárati időszakának nem megfelelő SAS-jogkivonatok használatának letiltására és letiltására használható.
ExtendedLocation	A kiterjesztett hely összetett típusa.
ExtendedLocationTypes	A kiterjesztett hely típusa.
GeoReplicationStats	A tárfiók blob-, tábla-, üzenetsor- és fájlszolgáltatásainak replikációjával kapcsolatos statisztikák. Ez csak akkor érhető el, ha a tárfiók georedundáns replikációja engedélyezve van.
GeoReplicationStatus	A másodlagos hely állapota. Lehetséges értékek: - Élő: Azt jelzi, hogy a másodlagos hely aktív és működőképes. - Bootstrap: Azt jelzi, hogy az elsődleges helyről a másodlagos helyre irányuló kezdeti szinkronizálás folyamatban van. Ez általában akkor fordul elő, ha a replikáció először engedélyezve van. - Nem érhető el: Azt jelzi, hogy a másodlagos hely átmenetileg nem érhető el.
Identity	Az erőforrás identitása.
IdentityType	Az identitás típusa.
ImmutableStorageAccount	Ez a tulajdonság engedélyezi és definiálja a fiókszintű nem módosíthatóságot. A funkció engedélyezése automatikusan engedélyezi a Blob verziószámozását.
IPRule	IP-szabály adott IP-címmel vagy IP-címtartománysal CIDR formátumban.
KeyCreationTime	A tárfiókkulcsok létrehozásának ideje.
KeyPolicy	A tárfiókhoz rendelt KeyPolicy.
KeySource	A titkosítási kulcsforrás (szolgáltató). Lehetséges értékek (kis- és nagybetűk megkülönböztetése): Microsoft.Storage, Microsoft.Keyvault
KeyType	A titkosítási szolgáltatáshoz használandó titkosítási kulcs típusa. Az "Account" kulcstípus azt jelenti, hogy a rendszer egy fiók hatókörű titkosítási kulcsot használ. A "Szolgáltatás" kulcstípus azt jelenti, hogy a rendszer egy alapértelmezett szolgáltatáskulcsot használ.
KeyVaultProperties	A Key Vault tulajdonságai.
Kind	A tárfiók típusát jelzi.
LargeFileSharesState	Nagy fájlmegosztások engedélyezése, ha a beállítás engedélyezve van. Az engedélyezés után nem tiltható le.
MinimumTlsVersion	Állítsa be a minimális TLS-verziót, hogy a tárterületre irányuló kérések esetén engedélyezve legyen. Ennek a tulajdonságnak az alapértelmezett értelmezése a TLS 1.0.
NetworkRuleSet	Hálózati szabálykészlet
postFailoverRedundancy	A fiók redundanciatípusa a fiók feladatátvétele után.
postPlannedFailoverRedundancy	A fiók redundanciatípusa a tervezett fiók feladatátvétele után.
PrivateEndpoint	A privát végpont erőforrása.
PrivateEndpointConnection	A privát végpont kapcsolati erőforrása.
PrivateEndpointConnectionProvisioningState	Az aktuális kiépítési állapot.
PrivateEndpointServiceConnectionStatus	A privát végpont kapcsolatának állapota.
PrivateLinkServiceConnectionState	A szolgáltatásfelhasználó és a szolgáltató közötti kapcsolat állapotával kapcsolatos információk gyűjteménye.
ProvisioningState	Lekéri a tárfiók állapotát a művelet meghívásakor.
PublicNetworkAccess	Engedélyezze, tiltsa le vagy hagyja, hogy a hálózati biztonsági peremhálózat konfigurációja kiértékelje a tárfiókhoz való nyilvános hálózati hozzáférést. Az érték megadása nem kötelező, de ha be van adva, akkor "Engedélyezve", "Letiltva" vagy "SecuredByPerimeter" értéknek kell lennie.
ResourceAccessRule	Erőforrás-hozzáférési szabály.
RoutingChoice	Az útválasztási választási lehetőség a felhasználó által választott hálózati útválasztás típusát határozza meg.
RoutingPreference	Az útválasztási beállítás határozza meg a hálózati típust, a microsoftos vagy az internetes útválasztást a felhasználói adatok továbbításához. Az alapértelmezett beállítás a Microsoft Routing
SasPolicy	SasPolicy hozzárendelve a tárfiókhoz.
Sku	A tárfiók termékváltozata.
SkuConversionStatus	Ez a tulajdonság a termékváltozat aktuális konvertálási állapotát jelzi.
SkuName	Az termékváltozat neve. A fióklétrehozáshoz szükséges; nem kötelező a frissítéshez. Vegye figyelembe, hogy a régebbi verziókban a termékváltozat neve accountType volt.
SkuTier	Az SKU-szint (raktározási egység kód szintje). Ez a termékváltozat neve alapján történik.
State	Lekéri a virtuális hálózati szabály állapotát.
StorageAccount	A tárfiók.
StorageAccountCreateParameters	A tárfiók létrehozásakor használt paraméterek.
StorageAccountInternetEndpoints	A nyilvános blob-, fájl-, webes vagy elosztott fájlrendszerbeli objektumok internetes útválasztási végponton keresztüli lekéréséhez használt URI-k.
StorageAccountMicrosoftEndpoints	Azok az URI-k, amelyek nyilvános blob, üzenetsor, tábla, webes vagy elosztott fájlrendszerbeli objektum lekérésére szolgálnak egy Microsoft-útválasztási végponton keresztül.
StorageAccountSkuConversionStatus	Ez határozza meg az aszinkron termékváltozatok konvertálási állapotobjektumát.
UserAssignedIdentity	UserAssignedIdentity az erőforráshoz.
VirtualNetworkRule	Virtuális hálózati szabály.

AccessTier

Enumerálás

Olyan tárfiókokhoz szükséges, ahol a típus = BlobStorage. A hozzáférési szint a számlázáshoz használatos. A prémium szintű hozzáférési szint a prémium szintű blokkblobok tárfióktípusának alapértelmezett értéke, és a prémium szintű blokkblobok tárfióktípusa esetében nem módosítható.

Érték	Description
Cold
Cool
Hot
Premium

AccountImmutabilityPolicyProperties

Objektum

Ez határozza meg a fiókszintű nem módosítható szabályzat tulajdonságait.

Name	Típus	Description
allowProtectedAppendWrites	boolean	Ez a tulajdonság csak letiltott és feloldott időalapú adatmegőrzési szabályzatok esetén módosítható. Ha engedélyezve van, az új blokkok egy hozzáfűző blobba írhatók, miközben fenntartják a nem módosíthatóság elleni védelmet és megfelelőséget. Csak új blokkok vehetők fel, és a meglévő blokkok nem módosíthatók vagy törölhetők.
immutabilityPeriodSinceCreationInDays	integer (int32) minimum: 1 maximum: 146000	A házirend létrehozása óta a tárolóban lévő blobok nem módosíthatósági időszaka napokban.
state	AccountImmutabilityPolicyState	Az ImmutabilityPolicy állapot határozza meg a szabályzat módját. A letiltott állapot letiltja a házirendet, a zárolt állapot lehetővé teszi a nem módosítható megőrzési idő növelését és csökkentését, valamint engedélyezi az AllowProtectedAppendWrites tulajdonság összevonását, a zárolt állapot csak a nem módosítható megőrzési idő növelését teszi lehetővé. A szabályzatok csak letiltott vagy zárolt állapotban hozhatók létre, és a két állapot között válthatók. Zárolt állapotba csak zárolt állapotú házirendek válthatnak, amelyek nem állíthatók vissza.

AccountImmutabilityPolicyState

Enumerálás

Az ImmutabilityPolicy állapot határozza meg a szabályzat módját. A letiltott állapot letiltja a házirendet, a zárolt állapot lehetővé teszi a nem módosítható megőrzési idő növelését és csökkentését, valamint engedélyezi az AllowProtectedAppendWrites tulajdonság összevonását, a zárolt állapot csak a nem módosítható megőrzési idő növelését teszi lehetővé. A szabályzatok csak letiltott vagy zárolt állapotban hozhatók létre, és a két állapot között válthatók. Zárolt állapotba csak zárolt állapotú házirendek válthatnak, amelyek nem állíthatók vissza.

Érték	Description
Disabled
Locked
Unlocked

AccountStatus

Enumerálás

Lekéri az állapotot, amely jelzi, hogy a tárfiók elsődleges helye elérhető vagy nem érhető el.

Érték	Description
available
unavailable

AccountType

Enumerálás

Az Azure Storage Active Directory-fióktípusát adja meg.

Érték	Description
Computer
User

Action

Enumerálás

A virtuális hálózati szabály művelete.

Érték	Description
Allow

ActiveDirectoryProperties

Objektum

Az Active Directory (AD) beállításainak tulajdonságai.

Name	Típus	Description
accountType	AccountType	Az Azure Storage Active Directory-fióktípusát adja meg.
azureStorageSid	string	Megadja az Azure Storage biztonsági azonosítóját (SID).
domainGuid	string	A tartomány GUID azonosítójának megadása.
domainName	string	Megadja az elsődleges tartományt, amely esetében az AD DNS-kiszolgáló mérvadó.
domainSid	string	Megadja a biztonsági azonosítót (SID).
forestName	string	Megadja a lekérendő Active Directory-erdőt.
netBiosDomainName	string	Megadja a NetBIOS-tartománynevet.
samAccountName	string	Az Azure Storage Active Directory SAMAccountName tulajdonságát adja meg.

AllowedCopyScope

Enumerálás

Korlátozza az AAD-bérlőn belüli vagy az ugyanazon virtuális hálózatra mutató privát hivatkozásokkal rendelkező tárfiókok másolását.

Érték	Description
AAD
PrivateLink

AzureFilesIdentityBasedAuthentication

Objektum

Az Azure Files identitásalapú hitelesítésének beállításai.

Name	Típus	Description
activeDirectoryProperties	ActiveDirectoryProperties	A directoryServiceOptions AD esetén kötelező, AADKERB esetén nem kötelező.
defaultSharePermission	DefaultSharePermission	Alapértelmezett megosztási engedély Kerberos-hitelesítést használó felhasználók számára, ha az RBAC-szerepkör nincs hozzárendelve.
directoryServiceOptions	DirectoryServiceOptions	A használt címtárszolgáltatást jelzi. Vegye figyelembe, hogy ez a szám a jövőben meghosszabbítható.

BlobRestoreParameters

Objektum

Blob-visszaállítási paraméterek

Name	Típus	Description
blobRanges	BlobRestoreRange[]	Visszaállítandó blobtartományok.
timeToRestore	string (date-time)	A blob visszaállítása a megadott időpontra.

BlobRestoreProgressStatus

Enumerálás

A blob-visszaállítás állapota. Lehetséges értékek: - Bejövő forgalom: Azt jelzi, hogy a blobok visszaállítása folyamatban van. - Kész: Azt jelzi, hogy a blob visszaállítása sikeresen befejeződött. - Sikertelen: Azt jelzi, hogy a blob visszaállítása sikertelen.

Érték	Description
Complete
Failed
InProgress

BlobRestoreRange

Objektum

Blobtartomány

Name	Típus	Description
endRange	string	Blob végtartománya. Ez kizárólagos. Az üres azt jelenti, hogy a fiók vége.
startRange	string	Blob kezdőtartománya. Ez mindent magában foglal. Az üres azt jelenti, hogy a fiók elindul.

BlobRestoreStatus

Objektum

Blob-visszaállítás állapota.

Name	Típus	Description
failureReason	string	Hiba oka, ha a blob visszaállítása sikertelen.
parameters	BlobRestoreParameters	Blob-visszaállítási kérelem paraméterei.
restoreId	string	Blob-visszaállítási kérelem nyomon követésének azonosítója.
status	BlobRestoreProgressStatus	A blob-visszaállítás állapota. Lehetséges értékek: - Bejövő forgalom: Azt jelzi, hogy a blobok visszaállítása folyamatban van. - Kész: Azt jelzi, hogy a blob visszaállítása sikeresen befejeződött. - Sikertelen: Azt jelzi, hogy a blob visszaállítása sikertelen.

Bypass

Enumerálás

Megadja, hogy a forgalom megkerülve legyen-e a naplózás/metrikák/AzureServices esetében. A lehetséges értékek a naplózás bármely kombinációját képezik|Metrikák|Az AzureServices (például "Naplózás, metrikák" vagy Nincs) a forgalom megkerüléséhez.

Érték	Description
AzureServices
Logging
Metrics
None

CustomDomain

Objektum

A tárfiókhoz rendelt egyéni tartomány. Ez a frissítéssel állítható be.

Name	Típus	Description
name	string	Lekéri vagy beállítja a tárfiókhoz rendelt egyéni tartománynevet. A név a CNAME forrás.
useSubDomainName	boolean	Azt jelzi, hogy engedélyezve van-e a közvetett CName-ellenőrzés. Az alapértelmezett érték hamis. Ezt csak frissítésekre kell beállítani.

DefaultAction

Enumerálás

Az engedélyezés vagy a megtagadás alapértelmezett műveletét adja meg, ha más szabályok nem egyeznek.

Érték	Description
Allow
Deny

DefaultSharePermission

Enumerálás

Alapértelmezett megosztási engedély Kerberos-hitelesítést használó felhasználók számára, ha az RBAC-szerepkör nincs hozzárendelve.

Érték	Description
None
StorageFileDataSmbShareContributor
StorageFileDataSmbShareElevatedContributor
StorageFileDataSmbShareReader

DirectoryServiceOptions

Enumerálás

A használt címtárszolgáltatást jelzi. Vegye figyelembe, hogy ez a szám a jövőben meghosszabbítható.

Érték	Description
AADDS
AADKERB
AD
None

DnsEndpointType

Enumerálás

Lehetővé teszi a végpont típusának megadását. Állítsa ezt az AzureDNSZone értékre, hogy egyetlen előfizetésben nagyszámú fiókot hozzon létre, amely fiókokat hoz létre egy Azure DNS-zónában, és a végpont URL-címe alfanumerikus DNS-zónaazonosítóval fog rendelkezni.

Érték	Description
AzureDnsZone
Standard

Encryption

Objektum

A tárfiók titkosítási beállításai.

Name	Típus	Alapértelmezett érték	Description
identity	EncryptionIdentity		A szolgáltatásoldali titkosítással inaktív identitás.
keySource	KeySource	Microsoft.Storage	A titkosítási kulcsforrás (szolgáltató). Lehetséges értékek (kis- és nagybetűk megkülönböztetése): Microsoft.Storage, Microsoft.Keyvault
keyvaultproperties	KeyVaultProperties		A Key Vault által biztosított tulajdonságok.
requireInfrastructureEncryption	boolean		Logikai érték, amely azt jelzi, hogy a szolgáltatás egy másodlagos titkosítási réteget alkalmaz-e a inaktív adatok platform által felügyelt kulcsaival.
services	EncryptionServices		A titkosítást támogató szolgáltatások listája.

EncryptionIdentity

Objektum

A tárfiók titkosítási identitása.

Name	Típus	Description
federatedIdentityClientId	string	A több-bérlős alkalmazás ügyfélazonosítója, amelyet a tárfiók felhasználó által hozzárendelt identitásával együtt kell használni a tárfiók bérlők közötti ügyfél által felügyelt kulcsok kiszolgálóoldali titkosításához.
userAssignedIdentity	string	A tárfiók kiszolgálóoldali titkosításához társítandó UserAssigned identitás erőforrás-azonosítója.

EncryptionService

Objektum

Olyan szolgáltatás, amely lehetővé teszi a kiszolgálóoldali titkosítás használatát.

Name	Típus	Description
enabled	boolean	Logikai érték, amely azt jelzi, hogy a szolgáltatás titkosítja-e az adatokat a tárolás során. A inaktív titkosítás alapértelmezés szerint ma engedélyezve van, és nem tiltható le.
keyType	KeyType	A titkosítási szolgáltatáshoz használandó titkosítási kulcs típusa. Az "Account" kulcstípus azt jelenti, hogy a rendszer egy fiók hatókörű titkosítási kulcsot használ. A "Szolgáltatás" kulcstípus azt jelenti, hogy a rendszer egy alapértelmezett szolgáltatáskulcsot használ.
lastEnabledTime	string (date-time)	Hozzávetőleges becslést kap arra a dátumra/időre, amikor a titkosítást a felhasználó utoljára engedélyezte. Az adatok jelenleg alapértelmezés szerint inaktív állapotban vannak titkosítva, és nem tilthatók le.

EncryptionServices

Objektum

A titkosítást támogató szolgáltatások listája.

Name	Típus	Description
blob	EncryptionService	A blobtároló szolgáltatás titkosítási függvénye.
file	EncryptionService	A fájltárolási szolgáltatás titkosítási függvénye.
queue	EncryptionService	A queue storage szolgáltatás titkosítási függvénye.
table	EncryptionService	A table storage szolgáltatás titkosítási függvénye.

Endpoints

Objektum

Nyilvános blob, üzenetsor, tábla, web vagy dfs objektum lekéréséhez használt URI-k.

Name	Típus	Description
blob	string	Lekéri a blobvégpontot.
dfs	string	Lekéri az elosztott fájlrendszer végpontot.
file	string	Lekéri a fájlvégpontot.
internetEndpoints	StorageAccountInternetEndpoints	Lekéri az internetes útválasztási tárvégpontokat
microsoftEndpoints	StorageAccountMicrosoftEndpoints	Lekéri a Microsoft Routing Storage-végpontokat.
queue	string	Lekéri az üzenetsorvégpontot.
table	string	Lekéri a táblavégpontot.
web	string	Lekéri a webes végpontot.

ExpirationAction

Enumerálás

Az SAS lejárati művelet határozza meg a sasPolicy.sasExpirationPeriod megsértése esetén végrehajtandó műveletet. A "Napló" művelet naplózási célokra használható, a "Blokk" művelet pedig az SAS-szabályzat lejárati időszakának nem megfelelő SAS-jogkivonatok használatának letiltására és letiltására használható.

Érték	Description
Block
Log

ExtendedLocation

Objektum

A kiterjesztett hely összetett típusa.

Name	Típus	Description
name	string	A kiterjesztett hely neve.
type	ExtendedLocationTypes	A kiterjesztett hely típusa.

ExtendedLocationTypes

Enumerálás

A kiterjesztett hely típusa.

Érték	Description
EdgeZone

GeoReplicationStats

Objektum

A tárfiók blob-, tábla-, üzenetsor- és fájlszolgáltatásainak replikációjával kapcsolatos statisztikák. Ez csak akkor érhető el, ha a tárfiók georedundáns replikációja engedélyezve van.

Name	Típus	Description
canFailover	boolean	Logikai jelző, amely azt jelzi, hogy a fiók feladatátvétele támogatott-e a fiókban.
canPlannedFailover	boolean	Logikai jelző, amely azt jelzi, hogy támogatott-e a fiók tervezett feladatátvétele.
lastSyncTime	string (date-time)	Az utc dátum/idő érték előtti összes elsődleges írás garantáltan elérhető az olvasási műveletekhez. Az ezt az időpontot követő elsődleges írások olvasáshoz nem feltétlenül érhetők el. Előfordulhat, hogy az elem alapértelmezett érték, ha a LastSyncTime értéke nem érhető el, ez akkor fordulhat elő, ha a másodlagos kapcsolat offline állapotban van, vagy bootstrap állapotban vagyunk.
postFailoverRedundancy	postFailoverRedundancy	A fiók redundanciatípusa a fiók feladatátvétele után.
postPlannedFailoverRedundancy	postPlannedFailoverRedundancy	A fiók redundanciatípusa a tervezett fiók feladatátvétele után.
status	GeoReplicationStatus	A másodlagos hely állapota. Lehetséges értékek: - Élő: Azt jelzi, hogy a másodlagos hely aktív és működőképes. - Bootstrap: Azt jelzi, hogy az elsődleges helyről a másodlagos helyre irányuló kezdeti szinkronizálás folyamatban van. Ez általában akkor fordul elő, ha a replikáció először engedélyezve van. - Nem érhető el: Azt jelzi, hogy a másodlagos hely átmenetileg nem érhető el.

GeoReplicationStatus

Enumerálás

A másodlagos hely állapota. Lehetséges értékek: - Élő: Azt jelzi, hogy a másodlagos hely aktív és működőképes. - Bootstrap: Azt jelzi, hogy az elsődleges helyről a másodlagos helyre irányuló kezdeti szinkronizálás folyamatban van. Ez általában akkor fordul elő, ha a replikáció először engedélyezve van. - Nem érhető el: Azt jelzi, hogy a másodlagos hely átmenetileg nem érhető el.

Érték	Description
Bootstrap
Live
Unavailable

Identity

Objektum

Az erőforrás identitása.

Name	Típus	Description
principalId	string	Az erőforrás-identitás egyszerű azonosítója.
tenantId	string	Az erőforrás bérlőazonosítója.
type	IdentityType	Az identitás típusa.
userAssignedIdentities	<string, UserAssignedIdentity>	Lekéri vagy beállítja azoknak a kulcsértékpároknak a listáját, amelyek leírják a tárfiókhoz használni kívánt felhasználó által hozzárendelt identitásokat. A kulcs az identitás ARM-erőforrás-azonosítója. Itt csak 1 felhasználó által hozzárendelt identitás engedélyezett.

IdentityType

Enumerálás

Az identitás típusa.

Érték	Description
None
SystemAssigned
SystemAssigned,UserAssigned
UserAssigned

ImmutableStorageAccount

Objektum

Ez a tulajdonság engedélyezi és definiálja a fiókszintű nem módosíthatóságot. A funkció engedélyezése automatikusan engedélyezi a Blob verziószámozását.

Name	Típus	Description
enabled	boolean	Logikai jelző, amely lehetővé teszi a fiókszintű megváltoztathatatlanságot. Az ilyen fiók összes tárolója alapértelmezés szerint engedélyezve van az objektumszintű nem módosíthatósággal.
immutabilityPolicy	AccountImmutabilityPolicyProperties	Megadja az alapértelmezett fiókszintű nem módosíthatósági szabályzatot, amely öröklődik, és olyan objektumokra van alkalmazva, amelyek nem rendelkeznek explicit módosíthatósági szabályzattal az objektum szintjén. Az objektumszintű nem módosíthatósági házirend nagyobb elsőbbséget élvez, mint a tárolószintű megváltoztathatatlansági szabályzat, amely nagyobb elsőbbséget élvez, mint a fiókszintű megváltoztathatatlansági szabályzat.

IPRule

Objektum

IP-szabály adott IP-címmel vagy IP-címtartománysal CIDR formátumban.

Name	Típus	Alapértelmezett érték	Description
action	Action	Allow	Az IP ACL-szabály művelete.
value	string		CiDR formátumban adja meg az IP- vagy IP-tartományt. Csak IPV4-cím engedélyezett.

KeyCreationTime

Objektum

A tárfiókkulcsok létrehozásának ideje.

Name	Típus	Description
key1	string (date-time)
key2	string (date-time)

KeyPolicy

Objektum

A tárfiókhoz rendelt KeyPolicy.

Name	Típus	Description
keyExpirationPeriodInDays	integer (int32)	A kulcs lejárati ideje napokban.

KeySource

Enumerálás

A titkosítási kulcsforrás (szolgáltató). Lehetséges értékek (kis- és nagybetűk megkülönböztetése): Microsoft.Storage, Microsoft.Keyvault

Érték	Description
Microsoft.Keyvault
Microsoft.Storage

KeyType

Enumerálás

A titkosítási szolgáltatáshoz használandó titkosítási kulcs típusa. Az "Account" kulcstípus azt jelenti, hogy a rendszer egy fiók hatókörű titkosítási kulcsot használ. A "Szolgáltatás" kulcstípus azt jelenti, hogy a rendszer egy alapértelmezett szolgáltatáskulcsot használ.

Érték	Description
Account
Service

KeyVaultProperties

Objektum

A Key Vault tulajdonságai.

Name	Típus	Description
currentVersionedKeyExpirationTimestamp	string (date-time)	Ez egy írásvédett tulajdonság, amely a titkosításhoz használt ügyfél által kezelt kulcs aktuális verziójának lejárati idejét jelöli.
currentVersionedKeyIdentifier	string	A jelenleg használt Key Vault-kulcs objektumazonosítója.
keyname	string	A KeyVault-kulcs neve.
keyvaulturi	string	A KeyVault Uri-ja.
keyversion	string	A KeyVault-kulcs verziója.
lastKeyRotationTimestamp	string (date-time)	A Key Vault-kulcs utolsó elforgatásának időbélyege.

Kind

Enumerálás

A tárfiók típusát jelzi.

Érték	Description
BlobStorage
BlockBlobStorage
FileStorage
Storage
StorageV2

LargeFileSharesState

Enumerálás

Nagy fájlmegosztások engedélyezése, ha a beállítás engedélyezve van. Az engedélyezés után nem tiltható le.

Érték	Description
Disabled
Enabled

MinimumTlsVersion

Enumerálás

Állítsa be a minimális TLS-verziót, hogy a tárterületre irányuló kérések esetén engedélyezve legyen. Ennek a tulajdonságnak az alapértelmezett értelmezése a TLS 1.0.

Érték	Description
TLS1_0
TLS1_1
TLS1_2
TLS1_3

NetworkRuleSet

Objektum

Hálózati szabálykészlet

Name	Típus	Alapértelmezett érték	Description
bypass	Bypass	AzureServices	Megadja, hogy a forgalom megkerülve legyen-e a naplózás/metrikák/AzureServices esetében. A lehetséges értékek a naplózás bármely kombinációját képezik\|Metrikák\|Az AzureServices (például "Naplózás, metrikák" vagy Nincs) a forgalom megkerüléséhez.
defaultAction	DefaultAction	Allow	Az engedélyezés vagy a megtagadás alapértelmezett műveletét adja meg, ha más szabályok nem egyeznek.
ipRules	IPRule[]		Az IP ACL-szabályok beállítása
resourceAccessRules	ResourceAccessRule[]		Az erőforrás-hozzáférési szabályok beállítása
virtualNetworkRules	VirtualNetworkRule[]		A virtuális hálózati szabályok beállítása

postFailoverRedundancy

Enumerálás

A fiók redundanciatípusa a fiók feladatátvétele után.

Érték	Description
Standard_LRS
Standard_ZRS

postPlannedFailoverRedundancy

Enumerálás

A fiók redundanciatípusa a tervezett fiók feladatátvétele után.

Érték	Description
Standard_GRS
Standard_GZRS
Standard_RAGRS
Standard_RAGZRS

PrivateEndpoint

Objektum

A privát végpont erőforrása.

Name	Típus	Description
id	string	A privát végpont ARM-azonosítója

PrivateEndpointConnection

Objektum

A privát végpont kapcsolati erőforrása.

Name	Típus	Description
id	string	Az erőforrás teljes erőforrás-azonosítója. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string	Az erőforrás neve
properties.privateEndpoint	PrivateEndpoint	A privát végpont erőforrása.
properties.privateLinkServiceConnectionState	PrivateLinkServiceConnectionState	A szolgáltatásfelhasználó és a szolgáltató közötti kapcsolat állapotával kapcsolatos információk gyűjteménye.
properties.provisioningState	PrivateEndpointConnectionProvisioningState	A privát végpont kapcsolati erőforrásának kiépítési állapota.
type	string	Az erőforrás típusa. Pl. "Microsoft.Compute/virtualMachines" vagy "Microsoft.Storage/storageAccounts"

PrivateEndpointConnectionProvisioningState

Enumerálás

Az aktuális kiépítési állapot.

Érték	Description
Creating
Deleting
Failed
Succeeded

PrivateEndpointServiceConnectionStatus

Enumerálás

A privát végpont kapcsolatának állapota.

Érték	Description
Approved
Pending
Rejected

PrivateLinkServiceConnectionState

Objektum

A szolgáltatásfelhasználó és a szolgáltató közötti kapcsolat állapotával kapcsolatos információk gyűjteménye.

Name	Típus	Description
actionRequired	string	Üzenet, amely jelzi, hogy a szolgáltató módosításaihoz szükség van-e a fogyasztó frissítésére.
description	string	A kapcsolat jóváhagyásának/elutasításának oka.
status	PrivateEndpointServiceConnectionStatus	Azt jelzi, hogy a szolgáltatás tulajdonosa jóváhagyta/elutasította/eltávolította-e a kapcsolatot.

ProvisioningState

Enumerálás

Lekéri a tárfiók állapotát a művelet meghívásakor.

Érték	Description
Creating
ResolvingDNS
Succeeded

PublicNetworkAccess

Enumerálás

Engedélyezze, tiltsa le vagy hagyja, hogy a hálózati biztonsági peremhálózat konfigurációja kiértékelje a tárfiókhoz való nyilvános hálózati hozzáférést. Az érték megadása nem kötelező, de ha be van adva, akkor "Engedélyezve", "Letiltva" vagy "SecuredByPerimeter" értéknek kell lennie.

Érték	Description
Disabled
Enabled
SecuredByPerimeter

ResourceAccessRule

Objektum

Erőforrás-hozzáférési szabály.

Name	Típus	Description
resourceId	string	Erőforrás-azonosító
tenantId	string	Bérlőazonosító

RoutingChoice

Enumerálás

Az útválasztási választási lehetőség a felhasználó által választott hálózati útválasztás típusát határozza meg.

Érték	Description
InternetRouting
MicrosoftRouting

RoutingPreference

Objektum

Az útválasztási beállítás határozza meg a hálózati típust, a microsoftos vagy az internetes útválasztást a felhasználói adatok továbbításához. Az alapértelmezett beállítás a Microsoft Routing

Name	Típus	Description
publishInternetEndpoints	boolean	Logikai jelző, amely azt jelzi, hogy közzé kell-e tenni az internetes útválasztási tárvégpontokat
publishMicrosoftEndpoints	boolean	Logikai jelző, amely jelzi, hogy a Microsoft útválasztási tárvégpontjait közzé kell-e tenni
routingChoice	RoutingChoice	Az útválasztási választási lehetőség a felhasználó által választott hálózati útválasztás típusát határozza meg.

SasPolicy

Objektum

SasPolicy hozzárendelve a tárfiókhoz.

Name	Típus	Alapértelmezett érték	Description
expirationAction	ExpirationAction	Log	Az SAS lejárati művelet határozza meg a sasPolicy.sasExpirationPeriod megsértése esetén végrehajtandó műveletet. A "Napló" művelet naplózási célokra használható, a "Blokk" művelet pedig az SAS-szabályzat lejárati időszakának nem megfelelő SAS-jogkivonatok használatának letiltására és letiltására használható.
sasExpirationPeriod	string		Az SAS lejárati ideje, DD.HH:MM:SS.

Sku

Objektum

A tárfiók termékváltozata.

Name	Típus	Description
name	SkuName	Az termékváltozat neve. A fióklétrehozáshoz szükséges; nem kötelező a frissítéshez. Vegye figyelembe, hogy a régebbi verziókban a termékváltozat neve accountType volt.
tier	SkuTier	Az SKU-szint (raktározási egység kód szintje). Ez a termékváltozat neve alapján történik.

SkuConversionStatus

Enumerálás

Ez a tulajdonság a termékváltozat aktuális konvertálási állapotát jelzi.

Érték	Description
Failed
InProgress
Succeeded

SkuName

Enumerálás

Az termékváltozat neve. A fióklétrehozáshoz szükséges; nem kötelező a frissítéshez. Vegye figyelembe, hogy a régebbi verziókban a termékváltozat neve accountType volt.

Érték	Description
PremiumV2_LRS
PremiumV2_ZRS
Premium_LRS
Premium_ZRS
StandardV2_GRS
StandardV2_GZRS
StandardV2_LRS
StandardV2_ZRS
Standard_GRS
Standard_GZRS
Standard_LRS
Standard_RAGRS
Standard_RAGZRS
Standard_ZRS

SkuTier

Enumerálás

Az SKU-szint (raktározási egység kód szintje). Ez a termékváltozat neve alapján történik.

Érték	Description
Premium
Standard

State

Enumerálás

Lekéri a virtuális hálózati szabály állapotát.

Érték	Description
Deprovisioning
Failed
NetworkSourceDeleted
Provisioning
Succeeded

StorageAccount

Objektum

A tárfiók.

Name	Típus	Description
extendedLocation	ExtendedLocation	Az erőforrás kiterjesztett áthelyezése.
id	string	Az erőforrás teljes erőforrás-azonosítója. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
identity	Identity	Az erőforrás identitása.
kind	Kind	Megszerzi a fajtát.
location	string	Az a földrajzi hely, ahol az erőforrás él
name	string	Az erőforrás neve
properties.accessTier	AccessTier	Olyan tárfiókokhoz szükséges, ahol a típus = BlobStorage. A hozzáférési szint a számlázáshoz használatos. A prémium szintű hozzáférési szint a prémium szintű blokkblobok tárfióktípusának alapértelmezett értéke, és a prémium szintű blokkblobok tárfióktípusa esetében nem módosítható.
properties.accountMigrationInProgress	boolean	Ha az ügyfél által kezdeményezett fiókmigrálás folyamatban van, az érték igaz lesz, különben null értékű lesz.
properties.allowBlobPublicAccess	boolean	Nyilvános hozzáférés engedélyezése vagy letiltása a tárfiókban lévő összes blobhoz vagy tárolóhoz. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.allowCrossTenantReplication	boolean	Az AAD-bérlői objektumok közötti replikáció engedélyezése vagy letiltása. Ezt a tulajdonságot csak akkor állítsa true értékre új vagy meglévő fiókokra, ha az objektumreplikációs szabályzatok különböző AAD-bérlők tárfiókjait érintik. Az alapértelmezett értelmezés hamis, ha az új fiókok alapértelmezés szerint követik az ajánlott biztonsági eljárásokat.
properties.allowSharedKeyAccess	boolean	Azt jelzi, hogy a tárfiók engedélyezi-e a fiók hozzáférési kulcsával való engedélyezést a megosztott kulccsal. Ha hamis, akkor minden kérést, beleértve a közös hozzáférésű jogosultságkódokat is, engedélyezni kell az Azure Active Directoryval (Azure AD). Az alapértelmezett érték null, ami az igaz értéknek felel meg.
properties.allowedCopyScope	AllowedCopyScope	Korlátozza az AAD-bérlőn belüli vagy az ugyanazon virtuális hálózatra mutató privát hivatkozásokkal rendelkező tárfiókok másolását.
properties.azureFilesIdentityBasedAuthentication	AzureFilesIdentityBasedAuthentication	Megadja az Azure Files identitásalapú hitelesítési beállításait.
properties.blobRestoreStatus	BlobRestoreStatus	Blob-visszaállítás állapota
properties.creationTime	string (date-time)	Lekéri a tárfiók létrehozásának dátumát és időpontját UTC-ben.
properties.customDomain	CustomDomain	Lekéri a tárfiókhoz hozzárendelt egyéni tartományt.
properties.defaultToOAuthAuthentication	boolean	Logikai jelző, amely azt jelzi, hogy az alapértelmezett hitelesítés OAuth-e vagy sem. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.dnsEndpointType	DnsEndpointType	Lehetővé teszi a végpont típusának megadását. Állítsa ezt az AzureDNSZone értékre, hogy egyetlen előfizetésben nagyszámú fiókot hozzon létre, amely fiókokat hoz létre egy Azure DNS-zónában, és a végpont URL-címe alfanumerikus DNS-zónaazonosítóval fog rendelkezni.
properties.enableExtendedGroups	boolean	Kiterjesztett csoporttámogatás engedélyezése a helyi felhasználók funkcióval, ha igaz értékre van állítva
properties.encryption	Encryption	A tárfiók kiszolgálóoldali titkosításához használandó titkosítási beállítások.
properties.failoverInProgress	boolean	Ha a feladatátvétel folyamatban van, az érték igaz lesz, ellenkező esetben null értékű lesz.
properties.geoReplicationStats	GeoReplicationStats	Georeplikációs statisztikák
properties.immutableStorageWithVersioning	ImmutableStorageAccount	A tulajdonság nem módosítható, és csak a fiók létrehozásakor állítható be igaz értékre. Ha igaz értékre van állítva, alapértelmezés szerint engedélyezi az objektumszintű nem módosíthatóságot a fiókban lévő összes tároló esetében.
properties.isHnsEnabled	boolean	A Fiókhierarchianévtér engedélyezve van, ha igaz értékre van állítva.
properties.isLocalUserEnabled	boolean	Engedélyezi a helyi felhasználók funkcióját, ha igaz értékre van állítva
properties.isNfsV3Enabled	boolean	Az NFS 3.0 protokoll támogatása engedélyezve van, ha igaz értékre van állítva.
properties.isSftpEnabled	boolean	Engedélyezi a biztonságos fájlátviteli protokollt, ha igaz értékre van állítva
properties.isSkuConversionBlocked	boolean	Ez a tulajdonság igaz vagy hamis értékre lesz állítva egy folyamatban lévő migrálás esetén. Az alapértelmezett érték null.
properties.keyCreationTime	KeyCreationTime	A tárfiókkulcsok létrehozásának ideje.
properties.keyPolicy	KeyPolicy	A tárfiókhoz rendelt KeyPolicy.
properties.largeFileSharesState	LargeFileSharesState	Nagy fájlmegosztások engedélyezése, ha a beállítás engedélyezve van. Az engedélyezés után nem tiltható le.
properties.lastGeoFailoverTime	string (date-time)	Lekéri a feladatátvétel legutóbbi példányának időbélyegét a másodlagos helyre. A rendszer csak a legutóbbi időbélyeget őrzi meg. Ez az elem nem lesz visszaadva, ha még soha nem volt feladatátvételi példány. Csak akkor érhető el, ha az accountType Standard_GRS vagy Standard_RAGRS.
properties.minimumTlsVersion	MinimumTlsVersion	Állítsa be a minimális TLS-verziót, hogy a tárterületre irányuló kérések esetén engedélyezve legyen. Ennek a tulajdonságnak az alapértelmezett értelmezése a TLS 1.0.
properties.networkAcls	NetworkRuleSet	Hálózati szabálykészlet
properties.primaryEndpoints	Endpoints	Lekéri a nyilvános blobok, üzenetsorok vagy táblaobjektumok lekéréséhez használt URL-címeket. Vegye figyelembe, hogy Standard_ZRS és Premium_LRS fiókok csak a blobvégpontot adják vissza.
properties.primaryLocation	string	Lekéri a tárfiók elsődleges adatközpontjának helyét.
properties.privateEndpointConnections	PrivateEndpointConnection[]	A megadott tárfiókhoz társított privát végpontkapcsolatok listája
properties.provisioningState	ProvisioningState	Lekéri a tárfiók állapotát a művelet meghívásakor.
properties.publicNetworkAccess	PublicNetworkAccess	Engedélyezze, tiltsa le vagy hagyja, hogy a hálózati biztonsági peremhálózat konfigurációja kiértékelje a tárfiókhoz való nyilvános hálózati hozzáférést.
properties.routingPreference	RoutingPreference	A felhasználó által az adatátvitelhez választott hálózati útválasztással kapcsolatos információk megőrzése
properties.sasPolicy	SasPolicy	SasPolicy hozzárendelve a tárfiókhoz.
properties.secondaryEndpoints	Endpoints	Lekéri a nyilvános blob, üzenetsor vagy táblaobjektum lekéréséhez használt URL-címeket a tárfiók másodlagos helyről. Csak akkor érhető el, ha a termékváltozat neve Standard_RAGRS.
properties.secondaryLocation	string	Lekéri a tárfiók georeplikált másodlagos helyét. Csak akkor érhető el, ha az accountType Standard_GRS vagy Standard_RAGRS.
properties.statusOfPrimary	AccountStatus	Lekéri az állapotot, amely jelzi, hogy a tárfiók elsődleges helye elérhető vagy nem érhető el.
properties.statusOfSecondary	AccountStatus	Lekéri az állapotot, amely jelzi, hogy a tárfiók másodlagos helye elérhető vagy nem érhető el. Csak akkor érhető el, ha a termékváltozat neve Standard_GRS vagy Standard_RAGRS.
properties.storageAccountSkuConversionStatus	StorageAccountSkuConversionStatus	Ez a tulajdonság írásvédett, és a kiszolgáló állítja be az aszinkron tárfiók-termékváltozat-átalakítási műveletek során.
properties.supportsHttpsTrafficOnly	boolean	Csak akkor engedélyezi a https-forgalmat a tárolási szolgáltatásba, ha igaz értékre van adva.
sku	Sku	Lekéri az SKU-t.
tags	object	Erőforráscímkék.
type	string	Az erőforrás típusa. Pl. "Microsoft.Compute/virtualMachines" vagy "Microsoft.Storage/storageAccounts"

StorageAccountCreateParameters

Objektum

A tárfiók létrehozásakor használt paraméterek.

Name	Típus	Description
extendedLocation	ExtendedLocation	Opcionális. Állítsa be az erőforrás kiterjesztett helyét. Ha nincs beállítva, a tárfiók az Azure fő régiójában jön létre. Ellenkező esetben a rendszer a megadott kiterjesztett helyen hozza létre
identity	Identity	Az erőforrás identitása.
kind	Kind	Szükséges. A tárfiók típusát jelzi.
location	string	Szükséges. Lekéri vagy beállítja az erőforrás helyét. Ez lesz az egyik támogatott és regisztrált Azure GeoRégió (pl. USA nyugati régiója, USA keleti régiója, Délkelet-Ázsia stb.). Az erőforrás georégióját a létrehozás után nem lehet módosítani, de ha a frissítéskor azonos georégiót ad meg, a kérés sikeres lesz.
properties.accessTier	AccessTier	Olyan tárfiókokhoz szükséges, ahol a típus = BlobStorage. A hozzáférési szint a számlázáshoz használatos. A prémium szintű hozzáférési szint a prémium szintű blokkblobok tárfióktípusának alapértelmezett értéke, és a prémium szintű blokkblobok tárfióktípusa esetében nem módosítható.
properties.allowBlobPublicAccess	boolean	Nyilvános hozzáférés engedélyezése vagy letiltása a tárfiókban lévő összes blobhoz vagy tárolóhoz. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.allowCrossTenantReplication	boolean	Az AAD-bérlői objektumok közötti replikáció engedélyezése vagy letiltása. Ezt a tulajdonságot csak akkor állítsa true értékre új vagy meglévő fiókokra, ha az objektumreplikációs szabályzatok különböző AAD-bérlők tárfiókjait érintik. Az alapértelmezett értelmezés hamis, ha az új fiókok alapértelmezés szerint követik az ajánlott biztonsági eljárásokat.
properties.allowSharedKeyAccess	boolean	Azt jelzi, hogy a tárfiók engedélyezi-e a fiók hozzáférési kulcsával való engedélyezést a megosztott kulccsal. Ha hamis, akkor minden kérést, beleértve a közös hozzáférésű jogosultságkódokat is, engedélyezni kell az Azure Active Directoryval (Azure AD). Az alapértelmezett érték null, ami az igaz értéknek felel meg.
properties.allowedCopyScope	AllowedCopyScope	Korlátozza az AAD-bérlőn belüli vagy az ugyanazon virtuális hálózatra mutató privát hivatkozásokkal rendelkező tárfiókok másolását.
properties.azureFilesIdentityBasedAuthentication	AzureFilesIdentityBasedAuthentication	Megadja az Azure Files identitásalapú hitelesítési beállításait.
properties.customDomain	CustomDomain	A tárfiókhoz rendelt felhasználói tartomány. A név a CNAME forrás. Tárfiókonként jelenleg csak egy egyéni tartomány támogatott. A meglévő egyéni tartomány törléséhez használjon egy üres sztringet az egyéni tartománynév tulajdonsághoz.
properties.defaultToOAuthAuthentication	boolean	Logikai jelző, amely azt jelzi, hogy az alapértelmezett hitelesítés OAuth-e vagy sem. Az alapértelmezett értelmezés hamis ehhez a tulajdonsághoz.
properties.dnsEndpointType	DnsEndpointType	Lehetővé teszi a végpont típusának megadását. Állítsa ezt az AzureDNSZone értékre, hogy egyetlen előfizetésben nagyszámú fiókot hozzon létre, amely fiókokat hoz létre egy Azure DNS-zónában, és a végpont URL-címe alfanumerikus DNS-zónaazonosítóval fog rendelkezni.
properties.enableExtendedGroups	boolean	Kiterjesztett csoporttámogatás engedélyezése a helyi felhasználók funkcióval, ha igaz értékre van állítva
properties.encryption	Encryption	A tárfiók kiszolgálóoldali titkosításához használandó titkosítási beállítások.
properties.immutableStorageWithVersioning	ImmutableStorageAccount	A tulajdonság nem módosítható, és csak a fiók létrehozásakor állítható be igaz értékre. Ha igaz értékre van állítva, alapértelmezés szerint engedélyezi az objektumszintű nem módosíthatóságot a fiók összes új tárolója számára.
properties.isHnsEnabled	boolean	A Fiókhierarchianévtér engedélyezve van, ha igaz értékre van állítva.
properties.isLocalUserEnabled	boolean	Engedélyezi a helyi felhasználók funkcióját, ha igaz értékre van állítva
properties.isNfsV3Enabled	boolean	Az NFS 3.0 protokoll támogatása engedélyezve van, ha igaz értékre van állítva.
properties.isSftpEnabled	boolean	Engedélyezi a biztonságos fájlátviteli protokollt, ha igaz értékre van állítva
properties.keyPolicy	KeyPolicy	A tárfiókhoz rendelt KeyPolicy.
properties.largeFileSharesState	LargeFileSharesState	Nagy fájlmegosztások engedélyezése, ha a beállítás engedélyezve van. Az engedélyezés után nem tiltható le.
properties.minimumTlsVersion	MinimumTlsVersion	Állítsa be a minimális TLS-verziót, hogy a tárterületre irányuló kérések esetén engedélyezve legyen. Ennek a tulajdonságnak az alapértelmezett értelmezése a TLS 1.0.
properties.networkAcls	NetworkRuleSet	Hálózati szabálykészlet
properties.publicNetworkAccess	PublicNetworkAccess	Engedélyezze, tiltsa le vagy hagyja, hogy a hálózati biztonsági peremhálózat konfigurációja kiértékelje a tárfiókhoz való nyilvános hálózati hozzáférést. Az érték megadása nem kötelező, de ha be van adva, akkor "Engedélyezve", "Letiltva" vagy "SecuredByPerimeter" értéknek kell lennie.
properties.routingPreference	RoutingPreference	A felhasználó által az adatátvitelhez választott hálózati útválasztással kapcsolatos információk megőrzése
properties.sasPolicy	SasPolicy	SasPolicy hozzárendelve a tárfiókhoz.
properties.supportsHttpsTrafficOnly	boolean	Csak akkor engedélyezi a https-forgalmat a tárolási szolgáltatásba, ha igaz értékre van adva. Az alapértelmezett érték igaz az API 2019-04-01-es verziója óta.
sku	Sku	Szükséges. Lekéri vagy beállítja a termékváltozat nevét.
tags	object	Lekéri vagy beállítja az erőforrást leíró kulcsértékpárok listáját. Ezek a címkék használhatók az erőforrás megtekintéséhez és csoportosításához (erőforráscsoportok között). Egy erőforráshoz legfeljebb 15 címke adható meg. Minden címkének 128 karakternél nem hosszabb és 256 karakternél nem hosszabb hosszúságú kulccsal kell rendelkeznie.

StorageAccountInternetEndpoints

Objektum

A nyilvános blob-, fájl-, webes vagy elosztott fájlrendszerbeli objektumok internetes útválasztási végponton keresztüli lekéréséhez használt URI-k.

Name	Típus	Description
blob	string	Lekéri a blobvégpontot.
dfs	string	Lekéri az elosztott fájlrendszer végpontot.
file	string	Lekéri a fájlvégpontot.
web	string	Lekéri a webes végpontot.

StorageAccountMicrosoftEndpoints

Objektum

Azok az URI-k, amelyek nyilvános blob, üzenetsor, tábla, webes vagy elosztott fájlrendszerbeli objektum lekérésére szolgálnak egy Microsoft-útválasztási végponton keresztül.

Name	Típus	Description
blob	string	Lekéri a blobvégpontot.
dfs	string	Lekéri az elosztott fájlrendszer végpontot.
file	string	Lekéri a fájlvégpontot.
queue	string	Lekéri az üzenetsorvégpontot.
table	string	Lekéri a táblavégpontot.
web	string	Lekéri a webes végpontot.

StorageAccountSkuConversionStatus

Objektum

Ez határozza meg az aszinkron termékváltozatok konvertálási állapotobjektumát.

Name	Típus	Description
endTime	string	Ez a tulajdonság a termékváltozat konvertálásának befejezési idejét jelöli.
skuConversionStatus	SkuConversionStatus	Ez a tulajdonság a termékváltozat aktuális konvertálási állapotát jelzi.
startTime	string	Ez a tulajdonság a termékváltozat konvertálásának kezdési időpontját jelöli.
targetSkuName	SkuName	Ez a tulajdonság azt a célváltozatnevet jelöli, amelyre a fiók termékváltozata aszinkron módon lesz konvertálva.

UserAssignedIdentity

Objektum

UserAssignedIdentity az erőforráshoz.

Name	Típus	Description
clientId	string	Az identitás ügyfélazonosítója.
principalId	string	Az identitás fő azonosítója.

VirtualNetworkRule

Objektum

Virtuális hálózati szabály.

Name	Típus	Alapértelmezett érték	Description
action	Action	Allow	A virtuális hálózati szabály művelete.
id	string		Egy alhálózat erőforrás-azonosítója, például: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{vnetName}/subnets/{subnetName}.
state	State		Lekéri a virtuális hálózati szabály állapotát.

Megosztás a következőn keresztül:

Storage Accounts - Create

URI-paraméterek

Kérelem törzse

Válaszok

Biztonság

azure_auth

Hatókörök

Példák

NfsV3AccountCreate

Mintakérelem

Mintaválasz

StorageAccountCreate

Mintakérelem

Mintaválasz

StorageAccountCreateAllowedCopyScopeToAAD

Mintakérelem

Mintaválasz

StorageAccountCreateAllowedCopyScopeToPrivateLink

Mintakérelem

Mintaválasz

StorageAccountCreateDisallowPublicNetworkAccess

Mintakérelem

Mintaválasz

StorageAccountCreateDnsEndpointTypeToAzureDnsZone

Mintakérelem

Mintaválasz

StorageAccountCreateDnsEndpointTypeToStandard

Mintakérelem

Mintaválasz

StorageAccountCreateEnablePublicNetworkAccess

Mintakérelem

Mintaválasz

StorageAccountCreatePremiumBlockBlobStorage

Mintakérelem

Mintaválasz

StorageAccountCreateUserAssignedEncryptionIdentityWithCMK

Mintakérelem

Mintaválasz

StorageAccountCreateUserAssignedIdentityWithFederatedIdentityClientId.

Mintakérelem

Mintaválasz

StorageAccountCreateWithImmutabilityPolicy

Mintakérelem

Mintaválasz

Definíciók

AccessTier

AccountImmutabilityPolicyProperties

AccountImmutabilityPolicyState

AccountStatus

AccountType

Action

ActiveDirectoryProperties

AllowedCopyScope

AzureFilesIdentityBasedAuthentication

BlobRestoreParameters

BlobRestoreProgressStatus

BlobRestoreRange

BlobRestoreStatus

Bypass

CustomDomain

DefaultAction

DefaultSharePermission

DirectoryServiceOptions

DnsEndpointType

Encryption

EncryptionIdentity

EncryptionService

EncryptionServices

Endpoints

ExpirationAction

ExtendedLocation

ExtendedLocationTypes

GeoReplicationStats

GeoReplicationStatus

Identity

IdentityType

ImmutableStorageAccount

IPRule

KeyCreationTime