Database Accounts - Create Or Update

Usługa:

Cosmos DB Resource Provider

Wersja interfejsu API:

2024-11-15

Tworzy lub aktualizuje konto bazy danych usługi Azure Cosmos DB. Metoda "Update" jest preferowana podczas przeprowadzania aktualizacji na koncie.

PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DocumentDB/databaseAccounts/{accountName}?api-version=2024-11-15

Parametry identyfikatora URI

Nazwa	W	Wymagane	Typ	Opis
accountName	path	True	string	Nazwa konta bazy danych usługi Cosmos DB. Wzorzec wyrażenia regularnego: ^[a-z0-9]+(-[a-z0-9]+)*
resourceGroupName	path	True	string	Nazwa grupy zasobów. Nazwa jest niewrażliwa na wielkość liter.
subscriptionId	path	True	string	Identyfikator subskrypcji docelowej.
api-version	query	True	string	Wersja interfejsu API do użycia dla tej operacji.

Treść żądania

Nazwa	Wymagane	Typ	Opis
properties.databaseAccountOfferType	True	DatabaseAccountOfferType	Typ oferty bazy danych
properties.locations	True	Location[]	Tablica zawierająca lokalizacje georeplikacji włączone dla konta usługi Cosmos DB.
identity		ManagedServiceIdentity	Tożsamość zasobu.
kind		DatabaseAccountKind	Wskazuje typ konta bazy danych. Można to ustawić tylko podczas tworzenia konta bazy danych.
location		string	Lokalizacja grupy zasobów, do której należy zasób.
properties.analyticalStorageConfiguration		AnalyticalStorageConfiguration	Właściwości specyficzne dla magazynu analitycznego.
properties.apiProperties		ApiProperties	Właściwości specyficzne dla interfejsu API. Obecnie obsługiwane tylko dla interfejsu API bazy danych MongoDB.
properties.backupPolicy		BackupPolicy: PeriodicModeBackupPolicy ContinuousModeBackupPolicy	Obiekt reprezentujący zasady tworzenia kopii zapasowych na koncie.
properties.capabilities		Capability[]	Lista możliwości usługi Cosmos DB dla konta
properties.capacity		Capacity	Obiekt reprezentujący wszystkie właściwości związane z wymuszaniem pojemności na koncie.
properties.connectorOffer		ConnectorOffer	Typ oferty łącznika cassandra dla konta bazy danych Cosmos DB C*.
properties.consistencyPolicy		ConsistencyPolicy	Zasady spójności dla konta usługi Cosmos DB.
properties.cors		CorsPolicy[]	Zasady CORS dla konta bazy danych usługi Cosmos DB.
properties.createMode		CreateMode	Wyliczenie wskazujące tryb tworzenia konta.
properties.customerManagedKeyStatus		string	Wskazuje stan funkcji Klucz zarządzany przez klienta na koncie. W przypadku wystąpienia błędów właściwość zawiera wskazówki dotyczące rozwiązywania problemów.
properties.defaultIdentity		string	Domyślna tożsamość na potrzeby uzyskiwania dostępu do magazynu kluczy używanych w funkcjach, takich jak klucze zarządzane przez klienta. Tożsamość domyślna musi być jawnie ustawiona przez użytkowników. Może to być "FirstPartyIdentity", "SystemAssignedIdentity" i nie tylko.
properties.disableKeyBasedMetadataWriteAccess		boolean	Wyłączanie operacji zapisu na zasobach metadanych (bazach danych, kontenerach, przepływności) za pomocą kluczy konta
properties.disableLocalAuth		boolean	Rezygnacja z uwierzytelniania lokalnego i upewnienie się, że do uwierzytelniania można używać tylko tożsamości usługi zarządzanej i usługi AAD.
properties.enableAnalyticalStorage		boolean	Flaga wskazująca, czy włączyć analizę magazynu.
properties.enableAutomaticFailover		boolean	Włącza automatyczne przełączanie w tryb failover regionu zapisu w rzadkim przypadku, że region jest niedostępny z powodu awarii. Automatyczne przełączanie w tryb failover spowoduje utworzenie nowego regionu zapisu dla konta i zostanie wybrane na podstawie priorytetów trybu failover skonfigurowanych dla konta.
properties.enableBurstCapacity		boolean	Flaga wskazująca włączanie/wyłączanie funkcji pojemności burst na koncie
properties.enableCassandraConnector		boolean	Włącza łącznik cassandra na koncie usługi Cosmos DB C*
properties.enableFreeTier		boolean	Flaga wskazująca, czy warstwa Bezpłatna jest włączona.
properties.enableMultipleWriteLocations		boolean	Umożliwia zapisanie konta w wielu lokalizacjach
properties.enablePartitionMerge		boolean	Flaga wskazująca włączanie/wyłączanie funkcji Scalanie partycji na koncie
properties.enablePerRegionPerPartitionAutoscale		boolean	Flaga wskazująca włączanie/wyłączanie funkcji PerRegionPerPartitionAutoscale na koncie
properties.ipRules		IpAddressOrRange[]	Lista adresów IPRules.
properties.isVirtualNetworkFilterEnabled		boolean	Flaga wskazująca, czy należy włączyć/wyłączyć reguły listy ACL sieci wirtualnej.
properties.keyVaultKeyUri		string	Identyfikator URI magazynu kluczy
properties.minimalTlsVersion		MinimalTlsVersion	Wskazuje minimalną dozwoloną wersję protokołu Tls. Wartość domyślna to Tls 1.2. Interfejsy API Cassandra i Mongo działają tylko z protokołem Tls 1.2.
properties.networkAclBypass		NetworkAclBypass	Wskazuje, jakie usługi mogą pomijać kontrole zapory.
properties.networkAclBypassResourceIds		string[]	Tablica zawierająca identyfikatory zasobów dla obejścia listy Acl sieci dla konta usługi Cosmos DB.
properties.publicNetworkAccess		PublicNetworkAccess	Czy żądania z sieci publicznej są dozwolone
properties.restoreParameters		RestoreParameters	Parametry wskazujące informacje o przywracaniu.
properties.virtualNetworkRules		VirtualNetworkRule[]	Lista reguł listy ACL sieci wirtualnej skonfigurowanych dla konta usługi Cosmos DB.
tags		object	Tagi to lista par klucz-wartość, które opisują zasób. Te tagi mogą służyć do wyświetlania i grupowania tego zasobu (między grupami zasobów). Dla zasobu można podać maksymalnie 15 tagów. Każdy tag musi mieć klucz nie większy niż 128 znaków i wartość nie większą niż 256 znaków. Na przykład domyślne środowisko dla typu szablonu jest ustawione z wartością "defaultExperience": "Cassandra". Bieżące wartości "defaultExperience" obejmują również wartości "Table", "Graph", "DocumentDB" i "MongoDB".

Odpowiedzi

Nazwa	Typ	Opis
200 OK	DatabaseAccountGetResults	Operacja tworzenia lub aktualizowania konta bazy danych zostanie ukończona asynchronicznie.

Zabezpieczenia

azure_auth

Przepływ protokołu OAuth2 usługi Azure Active Directory

Typ: oauth2
Flow: implicit
Adres URL autoryzacji: https://login.microsoftonline.com/common/oauth2/authorize

Zakresy

Nazwa	Opis
user_impersonation	Personifikuj konto użytkownika

Przykłady

CosmosDBDatabaseAccountCreateMax

CosmosDBDatabaseAccountCreateMin

CosmosDBRestoreDatabaseAccountCreateUpdate.json

CosmosDBDatabaseAccountCreateMax

Przykładowe żądanie

HTTP

PUT https://management.azure.com/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1?api-version=2024-11-15

{
  "location": "westus",
  "tags": {},
  "kind": "MongoDB",
  "identity": {
    "type": "SystemAssigned,UserAssigned",
    "userAssignedIdentities": {
      "/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {}
    }
  },
  "properties": {
    "databaseAccountOfferType": "Standard",
    "ipRules": [
      {
        "ipAddressOrRange": "23.43.230.120"
      },
      {
        "ipAddressOrRange": "110.12.240.0/12"
      }
    ],
    "isVirtualNetworkFilterEnabled": true,
    "virtualNetworkRules": [
      {
        "id": "/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1",
        "ignoreMissingVNetServiceEndpoint": false
      }
    ],
    "publicNetworkAccess": "Enabled",
    "locations": [
      {
        "failoverPriority": 0,
        "locationName": "southcentralus",
        "isZoneRedundant": false
      },
      {
        "failoverPriority": 1,
        "locationName": "eastus",
        "isZoneRedundant": false
      }
    ],
    "consistencyPolicy": {
      "defaultConsistencyLevel": "BoundedStaleness",
      "maxIntervalInSeconds": 10,
      "maxStalenessPrefix": 200
    },
    "keyVaultKeyUri": "https://myKeyVault.vault.azure.net",
    "defaultIdentity": "FirstPartyIdentity",
    "enableFreeTier": false,
    "apiProperties": {
      "serverVersion": "3.2"
    },
    "enableAnalyticalStorage": true,
    "enableBurstCapacity": true,
    "enablePerRegionPerPartitionAutoscale": true,
    "analyticalStorageConfiguration": {
      "schemaType": "WellDefined"
    },
    "createMode": "Default",
    "backupPolicy": {
      "type": "Periodic",
      "periodicModeProperties": {
        "backupIntervalInMinutes": 240,
        "backupRetentionIntervalInHours": 8,
        "backupStorageRedundancy": "Geo"
      }
    },
    "cors": [
      {
        "allowedOrigins": "https://test"
      }
    ],
    "networkAclBypass": "AzureServices",
    "networkAclBypassResourceIds": [
      "/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"
    ],
    "capacity": {
      "totalThroughputLimit": 2000
    },
    "minimalTlsVersion": "Tls12"
  }
}

Java

import com.azure.resourcemanager.cosmos.models.AnalyticalStorageConfiguration;
import com.azure.resourcemanager.cosmos.models.AnalyticalStorageSchemaType;
import com.azure.resourcemanager.cosmos.models.ApiProperties;
import com.azure.resourcemanager.cosmos.models.BackupStorageRedundancy;
import com.azure.resourcemanager.cosmos.models.Capacity;
import com.azure.resourcemanager.cosmos.models.ConsistencyPolicy;
import com.azure.resourcemanager.cosmos.models.CorsPolicy;
import com.azure.resourcemanager.cosmos.models.CreateMode;
import com.azure.resourcemanager.cosmos.models.DatabaseAccountCreateUpdateParameters;
import com.azure.resourcemanager.cosmos.models.DatabaseAccountKind;
import com.azure.resourcemanager.cosmos.models.DefaultConsistencyLevel;
import com.azure.resourcemanager.cosmos.models.IpAddressOrRange;
import com.azure.resourcemanager.cosmos.models.Location;
import com.azure.resourcemanager.cosmos.models.ManagedServiceIdentity;
import com.azure.resourcemanager.cosmos.models.ManagedServiceIdentityUserAssignedIdentities;
import com.azure.resourcemanager.cosmos.models.MinimalTlsVersion;
import com.azure.resourcemanager.cosmos.models.NetworkAclBypass;
import com.azure.resourcemanager.cosmos.models.PeriodicModeBackupPolicy;
import com.azure.resourcemanager.cosmos.models.PeriodicModeProperties;
import com.azure.resourcemanager.cosmos.models.PublicNetworkAccess;
import com.azure.resourcemanager.cosmos.models.ResourceIdentityType;
import com.azure.resourcemanager.cosmos.models.ServerVersion;
import com.azure.resourcemanager.cosmos.models.VirtualNetworkRule;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for DatabaseAccounts CreateOrUpdate.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/
     * CosmosDBDatabaseAccountCreateMax.json
     */
    /**
     * Sample code: CosmosDBDatabaseAccountCreateMax.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void cosmosDBDatabaseAccountCreateMax(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.cosmosDBAccounts().manager().serviceClient().getDatabaseAccounts().createOrUpdate("rg1", "ddb1",
            new DatabaseAccountCreateUpdateParameters().withLocation("westus").withTags(mapOf())
                .withKind(DatabaseAccountKind.MONGO_DB)
                .withIdentity(new ManagedServiceIdentity().withType(ResourceIdentityType.SYSTEM_ASSIGNED_USER_ASSIGNED)
                    .withUserAssignedIdentities(mapOf(
                        "/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1",
                        new ManagedServiceIdentityUserAssignedIdentities())))
                .withConsistencyPolicy(
                    new ConsistencyPolicy().withDefaultConsistencyLevel(DefaultConsistencyLevel.BOUNDED_STALENESS)
                        .withMaxStalenessPrefix(200L).withMaxIntervalInSeconds(10))
                .withLocations(Arrays.asList(
                    new Location().withLocationName("southcentralus").withFailoverPriority(0)
                        .withIsZoneRedundant(false),
                    new Location().withLocationName("eastus").withFailoverPriority(1).withIsZoneRedundant(false)))
                .withIpRules(Arrays.asList(new IpAddressOrRange().withIpAddressOrRange("23.43.230.120"),
                    new IpAddressOrRange().withIpAddressOrRange("110.12.240.0/12")))
                .withIsVirtualNetworkFilterEnabled(true)
                .withVirtualNetworkRules(Arrays.asList(new VirtualNetworkRule().withId(
                    "/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1")
                    .withIgnoreMissingVNetServiceEndpoint(false)))
                .withKeyVaultKeyUri("fakeTokenPlaceholder").withDefaultIdentity("FirstPartyIdentity")
                .withPublicNetworkAccess(PublicNetworkAccess.ENABLED).withEnableFreeTier(false)
                .withApiProperties(new ApiProperties().withServerVersion(ServerVersion.THREE_TWO))
                .withEnableAnalyticalStorage(true)
                .withAnalyticalStorageConfiguration(
                    new AnalyticalStorageConfiguration().withSchemaType(AnalyticalStorageSchemaType.WELL_DEFINED))
                .withCreateMode(CreateMode.DEFAULT)
                .withBackupPolicy(new PeriodicModeBackupPolicy().withPeriodicModeProperties(
                    new PeriodicModeProperties().withBackupIntervalInMinutes(240).withBackupRetentionIntervalInHours(8)
                        .withBackupStorageRedundancy(BackupStorageRedundancy.GEO)))
                .withCors(Arrays.asList(new CorsPolicy().withAllowedOrigins("https://test")))
                .withNetworkAclBypass(NetworkAclBypass.AZURE_SERVICES)
                .withNetworkAclBypassResourceIds(Arrays.asList(
                    "/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"))
                .withCapacity(new Capacity().withTotalThroughputLimit(2000))
                .withMinimalTlsVersion(MinimalTlsVersion.TLS12).withEnableBurstCapacity(true)
                .withEnablePerRegionPerPartitionAutoscale(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

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.cosmosdb import CosmosDBManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-cosmosdb
# USAGE
    python cosmos_db_database_account_create_max.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 = CosmosDBManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="subid",
    )

    response = client.database_accounts.begin_create_or_update(
        resource_group_name="rg1",
        account_name="ddb1",
        create_update_parameters={
            "identity": {
                "type": "SystemAssigned,UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {}
                },
            },
            "kind": "MongoDB",
            "location": "westus",
            "properties": {
                "analyticalStorageConfiguration": {"schemaType": "WellDefined"},
                "apiProperties": {"serverVersion": "3.2"},
                "backupPolicy": {
                    "periodicModeProperties": {
                        "backupIntervalInMinutes": 240,
                        "backupRetentionIntervalInHours": 8,
                        "backupStorageRedundancy": "Geo",
                    },
                    "type": "Periodic",
                },
                "capacity": {"totalThroughputLimit": 2000},
                "consistencyPolicy": {
                    "defaultConsistencyLevel": "BoundedStaleness",
                    "maxIntervalInSeconds": 10,
                    "maxStalenessPrefix": 200,
                },
                "cors": [{"allowedOrigins": "https://test"}],
                "createMode": "Default",
                "databaseAccountOfferType": "Standard",
                "defaultIdentity": "FirstPartyIdentity",
                "enableAnalyticalStorage": True,
                "enableBurstCapacity": True,
                "enableFreeTier": False,
                "enablePerRegionPerPartitionAutoscale": True,
                "ipRules": [{"ipAddressOrRange": "23.43.230.120"}, {"ipAddressOrRange": "110.12.240.0/12"}],
                "isVirtualNetworkFilterEnabled": True,
                "keyVaultKeyUri": "https://myKeyVault.vault.azure.net",
                "locations": [
                    {"failoverPriority": 0, "isZoneRedundant": False, "locationName": "southcentralus"},
                    {"failoverPriority": 1, "isZoneRedundant": False, "locationName": "eastus"},
                ],
                "minimalTlsVersion": "Tls12",
                "networkAclBypass": "AzureServices",
                "networkAclBypassResourceIds": [
                    "/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"
                ],
                "publicNetworkAccess": "Enabled",
                "virtualNetworkRules": [
                    {
                        "id": "/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1",
                        "ignoreMissingVNetServiceEndpoint": False,
                    }
                ],
            },
            "tags": {},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMax.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

Go

package armcosmos_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/cosmos/armcosmos/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ded6306d00ae294c24211e5069c1f56b15ba8ef5/specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMax.json
func ExampleDatabaseAccountsClient_BeginCreateOrUpdate_cosmosDbDatabaseAccountCreateMax() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcosmos.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatabaseAccountsClient().BeginCreateOrUpdate(ctx, "rg1", "ddb1", armcosmos.DatabaseAccountCreateUpdateParameters{
		Location: to.Ptr("westus"),
		Tags:     map[string]*string{},
		Identity: &armcosmos.ManagedServiceIdentity{
			Type: to.Ptr(armcosmos.ResourceIdentityTypeSystemAssignedUserAssigned),
			UserAssignedIdentities: map[string]*armcosmos.Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties{
				"/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {},
			},
		},
		Kind: to.Ptr(armcosmos.DatabaseAccountKindMongoDB),
		Properties: &armcosmos.DatabaseAccountCreateUpdateProperties{
			AnalyticalStorageConfiguration: &armcosmos.AnalyticalStorageConfiguration{
				SchemaType: to.Ptr(armcosmos.AnalyticalStorageSchemaTypeWellDefined),
			},
			APIProperties: &armcosmos.APIProperties{
				ServerVersion: to.Ptr(armcosmos.ServerVersionThree2),
			},
			BackupPolicy: &armcosmos.PeriodicModeBackupPolicy{
				Type: to.Ptr(armcosmos.BackupPolicyTypePeriodic),
				PeriodicModeProperties: &armcosmos.PeriodicModeProperties{
					BackupIntervalInMinutes:        to.Ptr[int32](240),
					BackupRetentionIntervalInHours: to.Ptr[int32](8),
					BackupStorageRedundancy:        to.Ptr(armcosmos.BackupStorageRedundancyGeo),
				},
			},
			Capacity: &armcosmos.Capacity{
				TotalThroughputLimit: to.Ptr[int32](2000),
			},
			ConsistencyPolicy: &armcosmos.ConsistencyPolicy{
				DefaultConsistencyLevel: to.Ptr(armcosmos.DefaultConsistencyLevelBoundedStaleness),
				MaxIntervalInSeconds:    to.Ptr[int32](10),
				MaxStalenessPrefix:      to.Ptr[int64](200),
			},
			Cors: []*armcosmos.CorsPolicy{
				{
					AllowedOrigins: to.Ptr("https://test"),
				}},
			CreateMode:                           to.Ptr(armcosmos.CreateModeDefault),
			DatabaseAccountOfferType:             to.Ptr("Standard"),
			DefaultIdentity:                      to.Ptr("FirstPartyIdentity"),
			EnableAnalyticalStorage:              to.Ptr(true),
			EnableBurstCapacity:                  to.Ptr(true),
			EnableFreeTier:                       to.Ptr(false),
			EnablePerRegionPerPartitionAutoscale: to.Ptr(true),
			IPRules: []*armcosmos.IPAddressOrRange{
				{
					IPAddressOrRange: to.Ptr("23.43.230.120"),
				},
				{
					IPAddressOrRange: to.Ptr("110.12.240.0/12"),
				}},
			IsVirtualNetworkFilterEnabled: to.Ptr(true),
			KeyVaultKeyURI:                to.Ptr("https://myKeyVault.vault.azure.net"),
			Locations: []*armcosmos.Location{
				{
					FailoverPriority: to.Ptr[int32](0),
					IsZoneRedundant:  to.Ptr(false),
					LocationName:     to.Ptr("southcentralus"),
				},
				{
					FailoverPriority: to.Ptr[int32](1),
					IsZoneRedundant:  to.Ptr(false),
					LocationName:     to.Ptr("eastus"),
				}},
			MinimalTLSVersion: to.Ptr(armcosmos.MinimalTLSVersionTls12),
			NetworkACLBypass:  to.Ptr(armcosmos.NetworkACLBypassAzureServices),
			NetworkACLBypassResourceIDs: []*string{
				to.Ptr("/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName")},
			PublicNetworkAccess: to.Ptr(armcosmos.PublicNetworkAccessEnabled),
			VirtualNetworkRules: []*armcosmos.VirtualNetworkRule{
				{
					ID:                               to.Ptr("/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"),
					IgnoreMissingVNetServiceEndpoint: to.Ptr(false),
				}},
		},
	}, 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.DatabaseAccountGetResults = armcosmos.DatabaseAccountGetResults{
	// 	Name: to.Ptr("ddb1"),
	// 	Type: to.Ptr("Microsoft.DocumentDB/databaseAccounts"),
	// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1"),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Identity: &armcosmos.ManagedServiceIdentity{
	// 		Type: to.Ptr(armcosmos.ResourceIdentityTypeSystemAssignedUserAssigned),
	// 		PrincipalID: to.Ptr("52f4fef3-3c3f-4ff3-b52e-b5c9eeb68656"),
	// 		TenantID: to.Ptr("33e01921-4d64-4f8c-a055-5bdaffd5e33d"),
	// 		UserAssignedIdentities: map[string]*armcosmos.Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties{
	// 			"/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": &armcosmos.Components1Jq1T4ISchemasManagedserviceidentityPropertiesUserassignedidentitiesAdditionalproperties{
	// 				ClientID: to.Ptr("fbe75b66-01c5-4f87-a220-233af3270436"),
	// 				PrincipalID: to.Ptr("33e01921-4d64-4f8c-a055-5bdaffd5e33d"),
	// 			},
	// 		},
	// 	},
	// 	Kind: to.Ptr(armcosmos.DatabaseAccountKindMongoDB),
	// 	Properties: &armcosmos.DatabaseAccountGetProperties{
	// 		AnalyticalStorageConfiguration: &armcosmos.AnalyticalStorageConfiguration{
	// 			SchemaType: to.Ptr(armcosmos.AnalyticalStorageSchemaTypeWellDefined),
	// 		},
	// 		APIProperties: &armcosmos.APIProperties{
	// 			ServerVersion: to.Ptr(armcosmos.ServerVersionThree2),
	// 		},
	// 		BackupPolicy: &armcosmos.PeriodicModeBackupPolicy{
	// 			Type: to.Ptr(armcosmos.BackupPolicyTypePeriodic),
	// 			PeriodicModeProperties: &armcosmos.PeriodicModeProperties{
	// 				BackupIntervalInMinutes: to.Ptr[int32](240),
	// 				BackupRetentionIntervalInHours: to.Ptr[int32](8),
	// 				BackupStorageRedundancy: to.Ptr(armcosmos.BackupStorageRedundancyGeo),
	// 			},
	// 		},
	// 		Capacity: &armcosmos.Capacity{
	// 			TotalThroughputLimit: to.Ptr[int32](2000),
	// 		},
	// 		ConsistencyPolicy: &armcosmos.ConsistencyPolicy{
	// 			DefaultConsistencyLevel: to.Ptr(armcosmos.DefaultConsistencyLevelBoundedStaleness),
	// 			MaxIntervalInSeconds: to.Ptr[int32](10),
	// 			MaxStalenessPrefix: to.Ptr[int64](200),
	// 		},
	// 		Cors: []*armcosmos.CorsPolicy{
	// 			{
	// 				AllowedOrigins: to.Ptr("https://test"),
	// 		}},
	// 		CreateMode: to.Ptr(armcosmos.CreateModeDefault),
	// 		DatabaseAccountOfferType: to.Ptr("Standard"),
	// 		DefaultIdentity: to.Ptr("FirstPartyIdentity"),
	// 		DisableKeyBasedMetadataWriteAccess: to.Ptr(false),
	// 		EnableAnalyticalStorage: to.Ptr(true),
	// 		EnableBurstCapacity: to.Ptr(true),
	// 		EnableFreeTier: to.Ptr(false),
	// 		FailoverPolicies: []*armcosmos.FailoverPolicy{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				LocationName: to.Ptr("South Central US"),
	// 			},
	// 			{
	// 				FailoverPriority: to.Ptr[int32](1),
	// 				ID: to.Ptr("ddb1-eastus"),
	// 				LocationName: to.Ptr("East US"),
	// 		}},
	// 		InstanceID: to.Ptr("d9b26648-2f53-4541-b3d8-3044f4f9810d"),
	// 		IPRules: []*armcosmos.IPAddressOrRange{
	// 			{
	// 				IPAddressOrRange: to.Ptr("23.43.230.120"),
	// 			},
	// 			{
	// 				IPAddressOrRange: to.Ptr("110.12.240.0/12"),
	// 		}},
	// 		IsVirtualNetworkFilterEnabled: to.Ptr(true),
	// 		KeyVaultKeyURI: to.Ptr("https://myKeyVault.vault.azure.net"),
	// 		KeysMetadata: &armcosmos.DatabaseAccountKeysMetadata{
	// 			PrimaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			PrimaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			SecondaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			SecondaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 		},
	// 		Locations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 			},
	// 			{
	// 				FailoverPriority: to.Ptr[int32](1),
	// 				ID: to.Ptr("ddb1-eastus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("East US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 		MinimalTLSVersion: to.Ptr(armcosmos.MinimalTLSVersionTls12),
	// 		NetworkACLBypass: to.Ptr(armcosmos.NetworkACLBypassAzureServices),
	// 		NetworkACLBypassResourceIDs: []*string{
	// 			to.Ptr("/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName")},
	// 			ProvisioningState: to.Ptr("Succeeded"),
	// 			PublicNetworkAccess: to.Ptr(armcosmos.PublicNetworkAccessEnabled),
	// 			ReadLocations: []*armcosmos.Location{
	// 				{
	// 					FailoverPriority: to.Ptr[int32](0),
	// 					ID: to.Ptr("ddb1-southcentralus"),
	// 					IsZoneRedundant: to.Ptr(false),
	// 					LocationName: to.Ptr("South Central US"),
	// 					ProvisioningState: to.Ptr("Succeeded"),
	// 				},
	// 				{
	// 					FailoverPriority: to.Ptr[int32](1),
	// 					ID: to.Ptr("ddb1-eastus"),
	// 					IsZoneRedundant: to.Ptr(false),
	// 					LocationName: to.Ptr("East US"),
	// 					ProvisioningState: to.Ptr("Succeeded"),
	// 			}},
	// 			VirtualNetworkRules: []*armcosmos.VirtualNetworkRule{
	// 				{
	// 					ID: to.Ptr("/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"),
	// 			}},
	// 			WriteLocations: []*armcosmos.Location{
	// 				{
	// 					FailoverPriority: to.Ptr[int32](0),
	// 					ID: to.Ptr("ddb1-southcentralus"),
	// 					IsZoneRedundant: to.Ptr(false),
	// 					LocationName: to.Ptr("South Central US"),
	// 					ProvisioningState: to.Ptr("Succeeded"),
	// 			}},
	// 		},
	// 		SystemData: &armcosmos.SystemData{
	// 			CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 		},
	// 	}
}

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

JavaScript

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

/**
 * This sample demonstrates how to Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 *
 * @summary Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMax.json
 */
async function cosmosDbDatabaseAccountCreateMax() {
  const subscriptionId = process.env["COSMOSDB_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["COSMOSDB_RESOURCE_GROUP"] || "rg1";
  const accountName = "ddb1";
  const createUpdateParameters = {
    analyticalStorageConfiguration: { schemaType: "WellDefined" },
    apiProperties: { serverVersion: "3.2" },
    backupPolicy: {
      type: "Periodic",
      periodicModeProperties: {
        backupIntervalInMinutes: 240,
        backupRetentionIntervalInHours: 8,
        backupStorageRedundancy: "Geo",
      },
    },
    capacity: { totalThroughputLimit: 2000 },
    consistencyPolicy: {
      defaultConsistencyLevel: "BoundedStaleness",
      maxIntervalInSeconds: 10,
      maxStalenessPrefix: 200,
    },
    cors: [{ allowedOrigins: "https://test" }],
    createMode: "Default",
    databaseAccountOfferType: "Standard",
    defaultIdentity: "FirstPartyIdentity",
    enableAnalyticalStorage: true,
    enableBurstCapacity: true,
    enableFreeTier: false,
    enablePerRegionPerPartitionAutoscale: true,
    identity: {
      type: "SystemAssigned,UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/fa5fc227A624475eB696Cdd604c735bc/resourceGroups/eu2cgroup/providers/MicrosoftManagedIdentity/userAssignedIdentities/id1":
          {},
      },
    },
    ipRules: [{ ipAddressOrRange: "23.43.230.120" }, { ipAddressOrRange: "110.12.240.0/12" }],
    isVirtualNetworkFilterEnabled: true,
    keyVaultKeyUri: "https://myKeyVault.vault.azure.net",
    kind: "MongoDB",
    location: "westus",
    locations: [
      {
        failoverPriority: 0,
        isZoneRedundant: false,
        locationName: "southcentralus",
      },
      { failoverPriority: 1, isZoneRedundant: false, locationName: "eastus" },
    ],
    minimalTlsVersion: "Tls12",
    networkAclBypass: "AzureServices",
    networkAclBypassResourceIds: [
      "/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName",
    ],
    publicNetworkAccess: "Enabled",
    tags: {},
    virtualNetworkRules: [
      {
        id: "/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1",
        ignoreMissingVNetServiceEndpoint: false,
      },
    ],
  };
  const credential = new DefaultAzureCredential();
  const client = new CosmosDBManagementClient(credential, subscriptionId);
  const result = await client.databaseAccounts.beginCreateOrUpdateAndWait(
    resourceGroupName,
    accountName,
    createUpdateParameters,
  );
  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

Przykładowa odpowiedź

Kod stanu:

200

{
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1",
  "name": "ddb1",
  "location": "West US",
  "type": "Microsoft.DocumentDB/databaseAccounts",
  "kind": "MongoDB",
  "tags": {},
  "identity": {
    "type": "SystemAssigned,UserAssigned",
    "principalId": "52f4fef3-3c3f-4ff3-b52e-b5c9eeb68656",
    "tenantId": "33e01921-4d64-4f8c-a055-5bdaffd5e33d",
    "userAssignedIdentities": {
      "/subscriptions/fa5fc227-a624-475e-b696-cdd604c735bc/resourceGroups/eu2cgroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/id1": {
        "clientId": "fbe75b66-01c5-4f87-a220-233af3270436",
        "principalId": "33e01921-4d64-4f8c-a055-5bdaffd5e33d"
      }
    }
  },
  "properties": {
    "provisioningState": "Initializing",
    "isVirtualNetworkFilterEnabled": true,
    "databaseAccountOfferType": "Standard",
    "disableKeyBasedMetadataWriteAccess": false,
    "consistencyPolicy": {
      "defaultConsistencyLevel": "BoundedStaleness",
      "maxIntervalInSeconds": 10,
      "maxStalenessPrefix": 200
    },
    "writeLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "readLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      },
      {
        "id": "ddb1-eastus",
        "locationName": "East US",
        "provisioningState": "Initializing",
        "failoverPriority": 1,
        "isZoneRedundant": false
      }
    ],
    "locations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      },
      {
        "id": "ddb1-eastus",
        "locationName": "East US",
        "provisioningState": "Initializing",
        "failoverPriority": 1,
        "isZoneRedundant": false
      }
    ],
    "failoverPolicies": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "failoverPriority": 0
      },
      {
        "id": "ddb1-eastus",
        "locationName": "East US",
        "failoverPriority": 1
      }
    ],
    "virtualNetworkRules": [
      {
        "id": "/subscriptions/subId/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet1/subnets/subnet1"
      }
    ],
    "publicNetworkAccess": "Enabled",
    "keyVaultKeyUri": "https://myKeyVault.vault.azure.net",
    "defaultIdentity": "FirstPartyIdentity",
    "enableFreeTier": false,
    "ipRules": [
      {
        "ipAddressOrRange": "23.43.230.120"
      },
      {
        "ipAddressOrRange": "110.12.240.0/12"
      }
    ],
    "apiProperties": {
      "serverVersion": "3.2"
    },
    "enableAnalyticalStorage": true,
    "enableBurstCapacity": true,
    "analyticalStorageConfiguration": {
      "schemaType": "WellDefined"
    },
    "createMode": "Default",
    "instanceId": "d9b26648-2f53-4541-b3d8-3044f4f9810d",
    "backupPolicy": {
      "type": "Periodic",
      "periodicModeProperties": {
        "backupIntervalInMinutes": 240,
        "backupRetentionIntervalInHours": 8,
        "backupStorageRedundancy": "Geo"
      }
    },
    "cors": [
      {
        "allowedOrigins": "https://test"
      }
    ],
    "networkAclBypass": "AzureServices",
    "networkAclBypassResourceIds": [
      "/subscriptions/subId/resourcegroups/rgName/providers/Microsoft.Synapse/workspaces/workspaceName"
    ],
    "capacity": {
      "totalThroughputLimit": 2000
    },
    "keysMetadata": {
      "primaryMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "secondaryMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "primaryReadonlyMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "secondaryReadonlyMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      }
    },
    "minimalTlsVersion": "Tls12"
  },
  "systemData": {
    "createdAt": "2021-03-12T22:05:09Z"
  }
}

CosmosDBDatabaseAccountCreateMin

Przykładowe żądanie

HTTP

PUT https://management.azure.com/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1?api-version=2024-11-15

{
  "location": "westus",
  "properties": {
    "databaseAccountOfferType": "Standard",
    "createMode": "Default",
    "locations": [
      {
        "failoverPriority": 0,
        "locationName": "southcentralus",
        "isZoneRedundant": false
      }
    ]
  }
}

Java

import com.azure.resourcemanager.cosmos.models.CreateMode;
import com.azure.resourcemanager.cosmos.models.DatabaseAccountCreateUpdateParameters;
import com.azure.resourcemanager.cosmos.models.Location;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for DatabaseAccounts CreateOrUpdate.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/
     * CosmosDBDatabaseAccountCreateMin.json
     */
    /**
     * Sample code: CosmosDBDatabaseAccountCreateMin.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void cosmosDBDatabaseAccountCreateMin(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.cosmosDBAccounts().manager().serviceClient().getDatabaseAccounts().createOrUpdate("rg1", "ddb1",
            new DatabaseAccountCreateUpdateParameters().withLocation("westus").withLocations(Arrays.asList(
                new Location().withLocationName("southcentralus").withFailoverPriority(0).withIsZoneRedundant(false)))
                .withCreateMode(CreateMode.DEFAULT),
            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

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.cosmosdb import CosmosDBManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-cosmosdb
# USAGE
    python cosmos_db_database_account_create_min.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 = CosmosDBManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="subid",
    )

    response = client.database_accounts.begin_create_or_update(
        resource_group_name="rg1",
        account_name="ddb1",
        create_update_parameters={
            "location": "westus",
            "properties": {
                "createMode": "Default",
                "databaseAccountOfferType": "Standard",
                "locations": [{"failoverPriority": 0, "isZoneRedundant": False, "locationName": "southcentralus"}],
            },
        },
    ).result()
    print(response)


# x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMin.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

Go

package armcosmos_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/cosmos/armcosmos/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ded6306d00ae294c24211e5069c1f56b15ba8ef5/specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMin.json
func ExampleDatabaseAccountsClient_BeginCreateOrUpdate_cosmosDbDatabaseAccountCreateMin() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcosmos.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatabaseAccountsClient().BeginCreateOrUpdate(ctx, "rg1", "ddb1", armcosmos.DatabaseAccountCreateUpdateParameters{
		Location: to.Ptr("westus"),
		Properties: &armcosmos.DatabaseAccountCreateUpdateProperties{
			CreateMode:               to.Ptr(armcosmos.CreateModeDefault),
			DatabaseAccountOfferType: to.Ptr("Standard"),
			Locations: []*armcosmos.Location{
				{
					FailoverPriority: to.Ptr[int32](0),
					IsZoneRedundant:  to.Ptr(false),
					LocationName:     to.Ptr("southcentralus"),
				}},
		},
	}, 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.DatabaseAccountGetResults = armcosmos.DatabaseAccountGetResults{
	// 	Name: to.Ptr("ddb1"),
	// 	Type: to.Ptr("Microsoft.DocumentDB/databaseAccounts"),
	// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1"),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Kind: to.Ptr(armcosmos.DatabaseAccountKindGlobalDocumentDB),
	// 	Properties: &armcosmos.DatabaseAccountGetProperties{
	// 		APIProperties: &armcosmos.APIProperties{
	// 		},
	// 		BackupPolicy: &armcosmos.PeriodicModeBackupPolicy{
	// 			Type: to.Ptr(armcosmos.BackupPolicyTypePeriodic),
	// 			PeriodicModeProperties: &armcosmos.PeriodicModeProperties{
	// 				BackupIntervalInMinutes: to.Ptr[int32](240),
	// 				BackupRetentionIntervalInHours: to.Ptr[int32](720),
	// 				BackupStorageRedundancy: to.Ptr(armcosmos.BackupStorageRedundancyGeo),
	// 			},
	// 		},
	// 		ConsistencyPolicy: &armcosmos.ConsistencyPolicy{
	// 			DefaultConsistencyLevel: to.Ptr(armcosmos.DefaultConsistencyLevelSession),
	// 			MaxIntervalInSeconds: to.Ptr[int32](5),
	// 			MaxStalenessPrefix: to.Ptr[int64](100),
	// 		},
	// 		Cors: []*armcosmos.CorsPolicy{
	// 		},
	// 		CreateMode: to.Ptr(armcosmos.CreateModeDefault),
	// 		DatabaseAccountOfferType: to.Ptr("Standard"),
	// 		DisableKeyBasedMetadataWriteAccess: to.Ptr(false),
	// 		EnableAnalyticalStorage: to.Ptr(false),
	// 		EnableFreeTier: to.Ptr(false),
	// 		FailoverPolicies: []*armcosmos.FailoverPolicy{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				LocationName: to.Ptr("South Central US"),
	// 		}},
	// 		InstanceID: to.Ptr("d9b26648-2f53-4541-b3d8-3044f4f9810d"),
	// 		IPRules: []*armcosmos.IPAddressOrRange{
	// 		},
	// 		KeysMetadata: &armcosmos.DatabaseAccountKeysMetadata{
	// 			PrimaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			PrimaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			SecondaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 			SecondaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 			},
	// 		},
	// 		Locations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 		MinimalTLSVersion: to.Ptr(armcosmos.MinimalTLSVersionTLS),
	// 		NetworkACLBypass: to.Ptr(armcosmos.NetworkACLBypassNone),
	// 		NetworkACLBypassResourceIDs: []*string{
	// 		},
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		ReadLocations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 		WriteLocations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 	},
	// 	SystemData: &armcosmos.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 	},
	// }
}

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

JavaScript

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

/**
 * This sample demonstrates how to Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 *
 * @summary Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBDatabaseAccountCreateMin.json
 */
async function cosmosDbDatabaseAccountCreateMin() {
  const subscriptionId = process.env["COSMOSDB_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["COSMOSDB_RESOURCE_GROUP"] || "rg1";
  const accountName = "ddb1";
  const createUpdateParameters = {
    createMode: "Default",
    databaseAccountOfferType: "Standard",
    location: "westus",
    locations: [
      {
        failoverPriority: 0,
        isZoneRedundant: false,
        locationName: "southcentralus",
      },
    ],
  };
  const credential = new DefaultAzureCredential();
  const client = new CosmosDBManagementClient(credential, subscriptionId);
  const result = await client.databaseAccounts.beginCreateOrUpdateAndWait(
    resourceGroupName,
    accountName,
    createUpdateParameters,
  );
  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

Przykładowa odpowiedź

Kod stanu:

200

{
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1",
  "name": "ddb1",
  "location": "West US",
  "type": "Microsoft.DocumentDB/databaseAccounts",
  "kind": "GlobalDocumentDB",
  "tags": {},
  "properties": {
    "provisioningState": "Initializing",
    "ipRules": [],
    "databaseAccountOfferType": "Standard",
    "disableKeyBasedMetadataWriteAccess": false,
    "consistencyPolicy": {
      "defaultConsistencyLevel": "Session",
      "maxIntervalInSeconds": 5,
      "maxStalenessPrefix": 100
    },
    "writeLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "readLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "locations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "failoverPolicies": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "failoverPriority": 0
      }
    ],
    "cors": [],
    "enableFreeTier": false,
    "apiProperties": {},
    "enableAnalyticalStorage": false,
    "analyticalStorageConfiguration": null,
    "networkAclBypass": "None",
    "networkAclBypassResourceIds": [],
    "instanceId": "d9b26648-2f53-4541-b3d8-3044f4f9810d",
    "createMode": "Default",
    "backupPolicy": {
      "type": "Periodic",
      "periodicModeProperties": {
        "backupIntervalInMinutes": 240,
        "backupRetentionIntervalInHours": 720,
        "backupStorageRedundancy": "Geo"
      }
    },
    "keysMetadata": {
      "primaryMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "secondaryMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "primaryReadonlyMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      },
      "secondaryReadonlyMasterKey": {
        "generationTime": "2021-03-12T22:05:09Z"
      }
    },
    "minimalTlsVersion": "Tls"
  },
  "systemData": {
    "createdAt": "2021-03-12T22:05:09Z"
  }
}

CosmosDBRestoreDatabaseAccountCreateUpdate.json

Przykładowe żądanie

HTTP

PUT https://management.azure.com/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1?api-version=2024-11-15

{
  "location": "westus",
  "tags": {},
  "kind": "GlobalDocumentDB",
  "properties": {
    "databaseAccountOfferType": "Standard",
    "locations": [
      {
        "failoverPriority": 0,
        "locationName": "southcentralus",
        "isZoneRedundant": false
      }
    ],
    "createMode": "Restore",
    "restoreParameters": {
      "restoreMode": "PointInTime",
      "restoreSource": "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc",
      "restoreTimestampInUtc": "2021-03-11T22:05:09Z",
      "restoreWithTtlDisabled": false,
      "databasesToRestore": [
        {
          "databaseName": "db1",
          "collectionNames": [
            "collection1",
            "collection2"
          ]
        },
        {
          "databaseName": "db2",
          "collectionNames": [
            "collection3",
            "collection4"
          ]
        }
      ]
    },
    "backupPolicy": {
      "type": "Continuous",
      "continuousModeProperties": {
        "tier": "Continuous30Days"
      }
    },
    "consistencyPolicy": {
      "defaultConsistencyLevel": "BoundedStaleness",
      "maxIntervalInSeconds": 10,
      "maxStalenessPrefix": 200
    },
    "keyVaultKeyUri": "https://myKeyVault.vault.azure.net",
    "enableFreeTier": false,
    "apiProperties": {
      "serverVersion": "3.2"
    },
    "enableAnalyticalStorage": true,
    "minimalTlsVersion": "Tls"
  }
}

Java

import com.azure.resourcemanager.cosmos.models.ApiProperties;
import com.azure.resourcemanager.cosmos.models.ConsistencyPolicy;
import com.azure.resourcemanager.cosmos.models.ContinuousModeBackupPolicy;
import com.azure.resourcemanager.cosmos.models.ContinuousModeProperties;
import com.azure.resourcemanager.cosmos.models.ContinuousTier;
import com.azure.resourcemanager.cosmos.models.CreateMode;
import com.azure.resourcemanager.cosmos.models.DatabaseAccountCreateUpdateParameters;
import com.azure.resourcemanager.cosmos.models.DatabaseAccountKind;
import com.azure.resourcemanager.cosmos.models.DatabaseRestoreResource;
import com.azure.resourcemanager.cosmos.models.DefaultConsistencyLevel;
import com.azure.resourcemanager.cosmos.models.Location;
import com.azure.resourcemanager.cosmos.models.MinimalTlsVersion;
import com.azure.resourcemanager.cosmos.models.RestoreMode;
import com.azure.resourcemanager.cosmos.models.RestoreParameters;
import com.azure.resourcemanager.cosmos.models.ServerVersion;
import java.time.OffsetDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for DatabaseAccounts CreateOrUpdate.
 */
public final class Main {
    /*
     * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/
     * CosmosDBRestoreDatabaseAccountCreateUpdate.json
     */
    /**
     * Sample code: CosmosDBRestoreDatabaseAccountCreateUpdate.json.
     * 
     * @param azure The entry point for accessing resource management APIs in Azure.
     */
    public static void
        cosmosDBRestoreDatabaseAccountCreateUpdateJson(com.azure.resourcemanager.AzureResourceManager azure) {
        azure.cosmosDBAccounts().manager().serviceClient().getDatabaseAccounts().createOrUpdate("rg1", "ddb1",
            new DatabaseAccountCreateUpdateParameters().withLocation("westus").withTags(mapOf())
                .withKind(DatabaseAccountKind.GLOBAL_DOCUMENT_DB)
                .withConsistencyPolicy(
                    new ConsistencyPolicy().withDefaultConsistencyLevel(DefaultConsistencyLevel.BOUNDED_STALENESS)
                        .withMaxStalenessPrefix(200L).withMaxIntervalInSeconds(10))
                .withLocations(Arrays.asList(new Location().withLocationName("southcentralus").withFailoverPriority(0)
                    .withIsZoneRedundant(false)))
                .withKeyVaultKeyUri("fakeTokenPlaceholder").withEnableFreeTier(false)
                .withApiProperties(new ApiProperties().withServerVersion(ServerVersion.THREE_TWO))
                .withEnableAnalyticalStorage(true).withCreateMode(CreateMode.RESTORE)
                .withBackupPolicy(new ContinuousModeBackupPolicy().withContinuousModeProperties(
                    new ContinuousModeProperties().withTier(ContinuousTier.CONTINUOUS30DAYS)))
                .withRestoreParameters(new RestoreParameters().withRestoreSource(
                    "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc")
                    .withRestoreTimestampInUtc(OffsetDateTime.parse("2021-03-11T22:05:09Z"))
                    .withRestoreWithTtlDisabled(false).withRestoreMode(RestoreMode.POINT_IN_TIME)
                    .withDatabasesToRestore(Arrays.asList(
                        new DatabaseRestoreResource().withDatabaseName("db1")
                            .withCollectionNames(Arrays.asList("collection1", "collection2")),
                        new DatabaseRestoreResource().withDatabaseName("db2")
                            .withCollectionNames(Arrays.asList("collection3", "collection4")))))
                .withMinimalTlsVersion(MinimalTlsVersion.TLS),
            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

Python

from azure.identity import DefaultAzureCredential

from azure.mgmt.cosmosdb import CosmosDBManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-cosmosdb
# USAGE
    python cosmos_db_restore_database_account_create_update.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 = CosmosDBManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="subid",
    )

    response = client.database_accounts.begin_create_or_update(
        resource_group_name="rg1",
        account_name="ddb1",
        create_update_parameters={
            "kind": "GlobalDocumentDB",
            "location": "westus",
            "properties": {
                "apiProperties": {"serverVersion": "3.2"},
                "backupPolicy": {"continuousModeProperties": {"tier": "Continuous30Days"}, "type": "Continuous"},
                "consistencyPolicy": {
                    "defaultConsistencyLevel": "BoundedStaleness",
                    "maxIntervalInSeconds": 10,
                    "maxStalenessPrefix": 200,
                },
                "createMode": "Restore",
                "databaseAccountOfferType": "Standard",
                "enableAnalyticalStorage": True,
                "enableFreeTier": False,
                "keyVaultKeyUri": "https://myKeyVault.vault.azure.net",
                "locations": [{"failoverPriority": 0, "isZoneRedundant": False, "locationName": "southcentralus"}],
                "minimalTlsVersion": "Tls",
                "restoreParameters": {
                    "databasesToRestore": [
                        {"collectionNames": ["collection1", "collection2"], "databaseName": "db1"},
                        {"collectionNames": ["collection3", "collection4"], "databaseName": "db2"},
                    ],
                    "restoreMode": "PointInTime",
                    "restoreSource": "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc",
                    "restoreTimestampInUtc": "2021-03-11T22:05:09Z",
                    "restoreWithTtlDisabled": False,
                },
            },
            "tags": {},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBRestoreDatabaseAccountCreateUpdate.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

Go

package armcosmos_test

import (
	"context"
	"log"

	"time"

	"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/cosmos/armcosmos/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/ded6306d00ae294c24211e5069c1f56b15ba8ef5/specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBRestoreDatabaseAccountCreateUpdate.json
func ExampleDatabaseAccountsClient_BeginCreateOrUpdate_cosmosDbRestoreDatabaseAccountCreateUpdateJson() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armcosmos.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewDatabaseAccountsClient().BeginCreateOrUpdate(ctx, "rg1", "ddb1", armcosmos.DatabaseAccountCreateUpdateParameters{
		Location: to.Ptr("westus"),
		Tags:     map[string]*string{},
		Kind:     to.Ptr(armcosmos.DatabaseAccountKindGlobalDocumentDB),
		Properties: &armcosmos.DatabaseAccountCreateUpdateProperties{
			APIProperties: &armcosmos.APIProperties{
				ServerVersion: to.Ptr(armcosmos.ServerVersionThree2),
			},
			BackupPolicy: &armcosmos.ContinuousModeBackupPolicy{
				Type: to.Ptr(armcosmos.BackupPolicyTypeContinuous),
				ContinuousModeProperties: &armcosmos.ContinuousModeProperties{
					Tier: to.Ptr(armcosmos.ContinuousTierContinuous30Days),
				},
			},
			ConsistencyPolicy: &armcosmos.ConsistencyPolicy{
				DefaultConsistencyLevel: to.Ptr(armcosmos.DefaultConsistencyLevelBoundedStaleness),
				MaxIntervalInSeconds:    to.Ptr[int32](10),
				MaxStalenessPrefix:      to.Ptr[int64](200),
			},
			CreateMode:               to.Ptr(armcosmos.CreateModeRestore),
			DatabaseAccountOfferType: to.Ptr("Standard"),
			EnableAnalyticalStorage:  to.Ptr(true),
			EnableFreeTier:           to.Ptr(false),
			KeyVaultKeyURI:           to.Ptr("https://myKeyVault.vault.azure.net"),
			Locations: []*armcosmos.Location{
				{
					FailoverPriority: to.Ptr[int32](0),
					IsZoneRedundant:  to.Ptr(false),
					LocationName:     to.Ptr("southcentralus"),
				}},
			MinimalTLSVersion: to.Ptr(armcosmos.MinimalTLSVersionTLS),
			RestoreParameters: &armcosmos.RestoreParameters{
				RestoreSource:          to.Ptr("/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc"),
				RestoreTimestampInUTC:  to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-11T22:05:09.000Z"); return t }()),
				RestoreWithTTLDisabled: to.Ptr(false),
				DatabasesToRestore: []*armcosmos.DatabaseRestoreResource{
					{
						CollectionNames: []*string{
							to.Ptr("collection1"),
							to.Ptr("collection2")},
						DatabaseName: to.Ptr("db1"),
					},
					{
						CollectionNames: []*string{
							to.Ptr("collection3"),
							to.Ptr("collection4")},
						DatabaseName: to.Ptr("db2"),
					}},
				RestoreMode: to.Ptr(armcosmos.RestoreModePointInTime),
			},
		},
	}, 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.DatabaseAccountGetResults = armcosmos.DatabaseAccountGetResults{
	// 	Name: to.Ptr("ddb1"),
	// 	Type: to.Ptr("Microsoft.DocumentDB/databaseAccounts"),
	// 	ID: to.Ptr("/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1"),
	// 	Location: to.Ptr("West US"),
	// 	Tags: map[string]*string{
	// 	},
	// 	Kind: to.Ptr(armcosmos.DatabaseAccountKindGlobalDocumentDB),
	// 	Properties: &armcosmos.DatabaseAccountGetProperties{
	// 		APIProperties: &armcosmos.APIProperties{
	// 		},
	// 		BackupPolicy: &armcosmos.ContinuousModeBackupPolicy{
	// 			Type: to.Ptr(armcosmos.BackupPolicyTypeContinuous),
	// 			ContinuousModeProperties: &armcosmos.ContinuousModeProperties{
	// 				Tier: to.Ptr(armcosmos.ContinuousTierContinuous30Days),
	// 			},
	// 		},
	// 		ConsistencyPolicy: &armcosmos.ConsistencyPolicy{
	// 			DefaultConsistencyLevel: to.Ptr(armcosmos.DefaultConsistencyLevelSession),
	// 			MaxIntervalInSeconds: to.Ptr[int32](5),
	// 			MaxStalenessPrefix: to.Ptr[int64](100),
	// 		},
	// 		CreateMode: to.Ptr(armcosmos.CreateModeRestore),
	// 		DatabaseAccountOfferType: to.Ptr("Standard"),
	// 		DisableKeyBasedMetadataWriteAccess: to.Ptr(false),
	// 		EnableAnalyticalStorage: to.Ptr(false),
	// 		EnableFreeTier: to.Ptr(false),
	// 		FailoverPolicies: []*armcosmos.FailoverPolicy{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				LocationName: to.Ptr("South Central US"),
	// 		}},
	// 		InstanceID: to.Ptr("d9b26648-2f53-4541-b3d8-3044f4f9810d"),
	// 		IPRules: []*armcosmos.IPAddressOrRange{
	// 		},
	// 		KeysMetadata: &armcosmos.DatabaseAccountKeysMetadata{
	// 			PrimaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-02-25T20:30:11.000Z"); return t}()),
	// 			},
	// 			PrimaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-02-25T20:30:11.000Z"); return t}()),
	// 			},
	// 			SecondaryMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-02-25T20:30:11.000Z"); return t}()),
	// 			},
	// 			SecondaryReadonlyMasterKey: &armcosmos.AccountKeyMetadata{
	// 				GenerationTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2022-02-25T20:30:11.000Z"); return t}()),
	// 			},
	// 		},
	// 		Locations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 		MinimalTLSVersion: to.Ptr(armcosmos.MinimalTLSVersionTLS),
	// 		ProvisioningState: to.Ptr("Succeeded"),
	// 		ReadLocations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 		WriteLocations: []*armcosmos.Location{
	// 			{
	// 				FailoverPriority: to.Ptr[int32](0),
	// 				ID: to.Ptr("ddb1-southcentralus"),
	// 				IsZoneRedundant: to.Ptr(false),
	// 				LocationName: to.Ptr("South Central US"),
	// 				ProvisioningState: to.Ptr("Succeeded"),
	// 		}},
	// 	},
	// 	SystemData: &armcosmos.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2021-03-12T22:05:09.000Z"); return t}()),
	// 	},
	// }
}

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

JavaScript

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

/**
 * This sample demonstrates how to Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 *
 * @summary Creates or updates an Azure Cosmos DB database account. The "Update" method is preferred when performing updates on an account.
 * x-ms-original-file: specification/cosmos-db/resource-manager/Microsoft.DocumentDB/stable/2024-11-15/examples/CosmosDBRestoreDatabaseAccountCreateUpdate.json
 */
async function cosmosDbRestoreDatabaseAccountCreateUpdateJson() {
  const subscriptionId = process.env["COSMOSDB_SUBSCRIPTION_ID"] || "subid";
  const resourceGroupName = process.env["COSMOSDB_RESOURCE_GROUP"] || "rg1";
  const accountName = "ddb1";
  const createUpdateParameters = {
    apiProperties: { serverVersion: "3.2" },
    backupPolicy: {
      type: "Continuous",
      continuousModeProperties: { tier: "Continuous30Days" },
    },
    consistencyPolicy: {
      defaultConsistencyLevel: "BoundedStaleness",
      maxIntervalInSeconds: 10,
      maxStalenessPrefix: 200,
    },
    createMode: "Restore",
    databaseAccountOfferType: "Standard",
    enableAnalyticalStorage: true,
    enableFreeTier: false,
    keyVaultKeyUri: "https://myKeyVault.vault.azure.net",
    kind: "GlobalDocumentDB",
    location: "westus",
    locations: [
      {
        failoverPriority: 0,
        isZoneRedundant: false,
        locationName: "southcentralus",
      },
    ],
    minimalTlsVersion: "Tls",
    restoreParameters: {
      databasesToRestore: [
        {
          collectionNames: ["collection1", "collection2"],
          databaseName: "db1",
        },
        {
          collectionNames: ["collection3", "collection4"],
          databaseName: "db2",
        },
      ],
      restoreMode: "PointInTime",
      restoreSource:
        "/subscriptions/subid/providers/Microsoft.DocumentDB/locations/westus/restorableDatabaseAccounts/1a97b4bb-f6a0-430e-ade1-638d781830cc",
      restoreTimestampInUtc: new Date("2021-03-11T22:05:09Z"),
      restoreWithTtlDisabled: false,
    },
    tags: {},
  };
  const credential = new DefaultAzureCredential();
  const client = new CosmosDBManagementClient(credential, subscriptionId);
  const result = await client.databaseAccounts.beginCreateOrUpdateAndWait(
    resourceGroupName,
    accountName,
    createUpdateParameters,
  );
  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

Przykładowa odpowiedź

Kod stanu:

200

{
  "id": "/subscriptions/subid/resourceGroups/rg1/providers/Microsoft.DocumentDB/databaseAccounts/ddb1",
  "name": "ddb1",
  "location": "West US",
  "type": "Microsoft.DocumentDB/databaseAccounts",
  "kind": "GlobalDocumentDB",
  "tags": {},
  "properties": {
    "provisioningState": "Initializing",
    "ipRules": [],
    "databaseAccountOfferType": "Standard",
    "disableKeyBasedMetadataWriteAccess": false,
    "instanceId": "d9b26648-2f53-4541-b3d8-3044f4f9810d",
    "createMode": "Restore",
    "consistencyPolicy": {
      "defaultConsistencyLevel": "Session",
      "maxIntervalInSeconds": 5,
      "maxStalenessPrefix": 100
    },
    "writeLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "readLocations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "locations": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "provisioningState": "Initializing",
        "failoverPriority": 0,
        "isZoneRedundant": false
      }
    ],
    "failoverPolicies": [
      {
        "id": "ddb1-southcentralus",
        "locationName": "South Central US",
        "failoverPriority": 0
      }
    ],
    "backupPolicy": {
      "type": "Continuous",
      "continuousModeProperties": {
        "tier": "Continuous30Days"
      }
    },
    "enableFreeTier": false,
    "apiProperties": {},
    "enableAnalyticalStorage": false,
    "keysMetadata": {
      "primaryMasterKey": {
        "generationTime": "2022-02-25T20:30:11Z"
      },
      "secondaryMasterKey": {
        "generationTime": "2022-02-25T20:30:11Z"
      },
      "primaryReadonlyMasterKey": {
        "generationTime": "2022-02-25T20:30:11Z"
      },
      "secondaryReadonlyMasterKey": {
        "generationTime": "2022-02-25T20:30:11Z"
      }
    },
    "minimalTlsVersion": "Tls"
  },
  "systemData": {
    "createdAt": "2021-03-12T22:05:09Z"
  }
}

Definicje

Nazwa	Opis
AccountKeyMetadata	Metadane związane z kluczem dostępu dla danego konta bazy danych.
AnalyticalStorageConfiguration	Właściwości specyficzne dla magazynu analitycznego.
AnalyticalStorageSchemaType	Opisuje typy schematu dla magazynu analitycznego.
ApiProperties
BackupPolicyMigrationState	Obiekt reprezentujący stan migracji między zasadami tworzenia kopii zapasowych.
BackupPolicyMigrationStatus	Opisuje stan migracji między typami zasad kopii zapasowych.
BackupPolicyType	Opisuje tryb tworzenia kopii zapasowych.
BackupStorageRedundancy	Wyliczenie wskazujące typ nadmiarowości magazynu kopii zapasowych.
Capability	Obiekt możliwości usługi Cosmos DB
Capacity	Obiekt reprezentujący wszystkie właściwości związane z wymuszaniem pojemności na koncie.
ConnectorOffer	Typ oferty łącznika cassandra dla konta bazy danych Usługi Cosmos DB C*.
ConsistencyPolicy	Zasady spójności dla konta bazy danych usługi Cosmos DB.
ContinuousModeBackupPolicy	Obiekt reprezentujący zasady tworzenia kopii zapasowych trybu ciągłego.
ContinuousModeProperties	Wartości konfiguracji dla kopii zapasowej w trybie okresowym
ContinuousTier	Wyliczenie wskazujące typ warstwy ciągłej kopii zapasowej.
CorsPolicy	Zasady CORS dla konta bazy danych usługi Cosmos DB.
createdByType	Typ tożsamości, która utworzyła zasób.
CreateMode	Wyliczenie wskazujące tryb tworzenia konta.
DatabaseAccountCreateUpdateParameters	Parametry do tworzenia i aktualizowania kont bazy danych usługi Cosmos DB.
DatabaseAccountGetResults	Konto bazy danych usługi Azure Cosmos DB.
DatabaseAccountKeysMetadata	Metadane powiązane z poszczególnymi kluczami dostępu dla danego konta bazy danych usługi Cosmos DB.
DatabaseAccountKind	Wskazuje typ konta bazy danych. Można to ustawić tylko podczas tworzenia konta bazy danych.
DatabaseAccountOfferType	Typ oferty dla konta bazy danych usługi Cosmos DB.
DatabaseRestoreResource	Określone bazy danych do przywrócenia.
DefaultConsistencyLevel	Domyślny poziom spójności i ustawienia konfiguracji konta usługi Cosmos DB.
FailoverPolicy	Zasady trybu failover dla danego regionu konta bazy danych.
GremlinDatabaseRestoreResource	Określone bazy danych Języka Gremlin do przywrócenia.
IpAddressOrRange	IpAddressOrRange, obiekt
Location	Region, w którym jest wdrażane konto bazy danych usługi Azure Cosmos DB.
ManagedServiceIdentity	Tożsamość zasobu.
MinimalTlsVersion	Wskazuje minimalną dozwoloną wersję protokołu Tls. Wartość domyślna to Tls 1.2. Interfejsy API Cassandra i Mongo działają tylko z protokołem Tls 1.2.
NetworkAclBypass	Wskazuje, jakie usługi mogą pomijać kontrole zapory.
PeriodicModeBackupPolicy	Obiekt reprezentujący zasady tworzenia kopii zapasowych w trybie okresowym.
PeriodicModeProperties	Wartości konfiguracji dla kopii zapasowej w trybie okresowym
PrivateEndpointConnection	Połączenie prywatnego punktu końcowego
PrivateEndpointProperty	Prywatny punkt końcowy, do którego należy połączenie.
PrivateLinkServiceConnectionStateProperty	Stan połączenia prywatnego punktu końcowego.
PublicNetworkAccess	Czy żądania z sieci publicznej są dozwolone
ResourceIdentityType	Typ tożsamości używany dla zasobu. Typ "SystemAssigned,UserAssigned" zawiera zarówno niejawnie utworzoną tożsamość, jak i zestaw tożsamości przypisanych przez użytkownika. Typ "Brak" spowoduje usunięcie wszystkich tożsamości z usługi.
RestoreMode	Opisuje tryb przywracania.
RestoreParameters	Parametry wskazujące informacje o przywracaniu.
ServerVersion	Opisuje wersję konta bazy danych MongoDB.
systemData	Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.
UserAssignedIdentities	Lista tożsamości użytkowników skojarzonych z zasobem. Odwołania do klucza słownika tożsamości użytkownika będą identyfikatorami zasobów arm w postaci: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}".
VirtualNetworkRule	Obiekt reguły listy ACL sieci wirtualnej

AccountKeyMetadata

Metadane związane z kluczem dostępu dla danego konta bazy danych.

Nazwa	Typ	Opis
generationTime	string	Czas generowania w formacie UTC klucza w formacie ISO-8601. Jeśli w obiekcie brakuje wartości, oznacza to, że ostatnia regenerowana wartość klucza została wyzwolona przed 2022-06-18.

AnalyticalStorageConfiguration

Właściwości specyficzne dla magazynu analitycznego.

Nazwa	Typ	Opis
schemaType	AnalyticalStorageSchemaType	Opisuje typy schematu dla magazynu analitycznego.

AnalyticalStorageSchemaType

Opisuje typy schematu dla magazynu analitycznego.

Nazwa	Typ	Opis
FullFidelity	string
WellDefined	string

ApiProperties

Nazwa	Typ	Opis
serverVersion	ServerVersion	Opisuje wersję konta bazy danych MongoDB.

BackupPolicyMigrationState

Obiekt reprezentujący stan migracji między zasadami tworzenia kopii zapasowych.

Nazwa	Typ	Opis
startTime	string	Godzina rozpoczęcia migracji zasad kopii zapasowych (format ISO-8601).
status	BackupPolicyMigrationStatus	Opisuje stan migracji między typami zasad kopii zapasowych.
targetType	BackupPolicyType	Opisuje docelowy typ zasad kopii zapasowych migracji zasad kopii zapasowych.

BackupPolicyMigrationStatus

Opisuje stan migracji między typami zasad kopii zapasowych.

Nazwa	Typ	Opis
Completed	string
Failed	string
InProgress	string
Invalid	string

BackupPolicyType

Opisuje tryb tworzenia kopii zapasowych.

Nazwa	Typ	Opis
Continuous	string
Periodic	string

BackupStorageRedundancy

Wyliczenie wskazujące typ nadmiarowości magazynu kopii zapasowych.

Nazwa	Typ	Opis
Geo	string
Local	string
Zone	string

Capability

Obiekt możliwości usługi Cosmos DB

Nazwa	Typ	Opis
name	string	Nazwa możliwości usługi Cosmos DB. Na przykład "name": "EnableCassandra". Bieżące wartości obejmują również wartości "EnableTable" i "EnableGremlin".

Capacity

Obiekt reprezentujący wszystkie właściwości związane z wymuszaniem pojemności na koncie.

Nazwa	Typ	Opis
totalThroughputLimit	integer	Łączny limit przepływności nałożony na konto. SumaThroughputLimit z 2000 r. nakłada ścisły limit maksymalnej przepływności, który można aprowizować na tym koncie na 2000. TotalThroughputLimit -1 wskazuje brak limitów aprowizacji przepływności.

ConnectorOffer

Typ oferty łącznika cassandra dla konta bazy danych Usługi Cosmos DB C*.

Nazwa	Typ	Opis
Small	string

ConsistencyPolicy

Zasady spójności dla konta bazy danych usługi Cosmos DB.

Nazwa	Typ	Opis
defaultConsistencyLevel	DefaultConsistencyLevel	Domyślny poziom spójności i ustawienia konfiguracji konta usługi Cosmos DB.
maxIntervalInSeconds	integer	W przypadku użycia z poziomem spójności Powiązana nieaktualność ta wartość reprezentuje tolerowaną ilość czasu nieaktualności (w sekundach). Zaakceptowany zakres dla tej wartości to 5– 86400. Wymagane, gdy parametr defaultConsistencyPolicy ma ustawioną wartość "BoundedStaleness".
maxStalenessPrefix	integer	W przypadku użycia z poziomem spójności Powiązana nieaktualność ta wartość reprezentuje liczbę nieaktywnych żądań tolerowanych. Akceptowany zakres dla tej wartości to 1 – 2 147 483 647. Wymagane, gdy parametr defaultConsistencyPolicy ma ustawioną wartość "BoundedStaleness".

ContinuousModeBackupPolicy

Obiekt reprezentujący zasady tworzenia kopii zapasowych trybu ciągłego.

Nazwa	Typ	Opis
continuousModeProperties	ContinuousModeProperties	Wartości konfiguracji kopii zapasowej trybu ciągłego
migrationState	BackupPolicyMigrationState	Obiekt reprezentujący stan migracji między zasadami tworzenia kopii zapasowych.
type	string: Continuous	Opisuje tryb tworzenia kopii zapasowych.

ContinuousModeProperties

Wartości konfiguracji dla kopii zapasowej w trybie okresowym

Nazwa	Typ	Opis
tier	ContinuousTier	Wyliczenie wskazujące typ trybu ciągłej kopii zapasowej

ContinuousTier

Wyliczenie wskazujące typ warstwy ciągłej kopii zapasowej.

Nazwa	Typ	Opis
Continuous30Days	string
Continuous7Days	string

CorsPolicy

Zasady CORS dla konta bazy danych usługi Cosmos DB.

Nazwa	Typ	Opis
allowedHeaders	string	Nagłówki żądań, które domena źródła może określać w żądaniu CORS.
allowedMethods	string	Metody (czasowniki żądań HTTP), których domena pochodzenia może używać dla żądania CORS.
allowedOrigins	string	Domeny pochodzenia, które mogą wysłać żądanie do usługi za pośrednictwem mechanizmu CORS.
exposedHeaders	string	Nagłówki odpowiedzi, które mogą być wysyłane w odpowiedzi na żądanie CORS i udostępniane przez przeglądarkę wystawcy żądania.
maxAgeInSeconds	integer	Maksymalny czas buforowania żądania OPCJE wstępne w przeglądarce.

createdByType

Typ tożsamości, która utworzyła zasób.

Nazwa	Typ	Opis
Application	string
Key	string
ManagedIdentity	string
User	string

CreateMode

Wyliczenie wskazujące tryb tworzenia konta.

Nazwa	Typ	Opis
Default	string
Restore	string

DatabaseAccountCreateUpdateParameters

Parametry do tworzenia i aktualizowania kont bazy danych usługi Cosmos DB.

Nazwa	Typ	Domyślna wartość	Opis
id	string		Unikatowy identyfikator zasobu usługi ARM.
identity	ManagedServiceIdentity		Tożsamość zasobu.
kind	DatabaseAccountKind	GlobalDocumentDB	Wskazuje typ konta bazy danych. Można to ustawić tylko podczas tworzenia konta bazy danych.
location	string		Lokalizacja grupy zasobów, do której należy zasób.
name	string		Nazwa zasobu usługi ARM.
properties.analyticalStorageConfiguration	AnalyticalStorageConfiguration		Właściwości specyficzne dla magazynu analitycznego.
properties.apiProperties	ApiProperties		Właściwości specyficzne dla interfejsu API. Obecnie obsługiwane tylko dla interfejsu API bazy danych MongoDB.
properties.backupPolicy	BackupPolicy: ContinuousModeBackupPolicy PeriodicModeBackupPolicy		Obiekt reprezentujący zasady tworzenia kopii zapasowych na koncie.
properties.capabilities	Capability[]		Lista możliwości usługi Cosmos DB dla konta
properties.capacity	Capacity		Obiekt reprezentujący wszystkie właściwości związane z wymuszaniem pojemności na koncie.
properties.connectorOffer	ConnectorOffer		Typ oferty łącznika cassandra dla konta bazy danych Cosmos DB C*.
properties.consistencyPolicy	ConsistencyPolicy		Zasady spójności dla konta usługi Cosmos DB.
properties.cors	CorsPolicy[]		Zasady CORS dla konta bazy danych usługi Cosmos DB.
properties.createMode	CreateMode	Default	Wyliczenie wskazujące tryb tworzenia konta.
properties.customerManagedKeyStatus	string		Wskazuje stan funkcji Klucz zarządzany przez klienta na koncie. W przypadku wystąpienia błędów właściwość zawiera wskazówki dotyczące rozwiązywania problemów.
properties.databaseAccountOfferType	DatabaseAccountOfferType		Typ oferty bazy danych
properties.defaultIdentity	string		Domyślna tożsamość na potrzeby uzyskiwania dostępu do magazynu kluczy używanych w funkcjach, takich jak klucze zarządzane przez klienta. Tożsamość domyślna musi być jawnie ustawiona przez użytkowników. Może to być "FirstPartyIdentity", "SystemAssignedIdentity" i nie tylko.
properties.disableKeyBasedMetadataWriteAccess	boolean		Wyłączanie operacji zapisu na zasobach metadanych (bazach danych, kontenerach, przepływności) za pomocą kluczy konta
properties.disableLocalAuth	boolean		Rezygnacja z uwierzytelniania lokalnego i upewnienie się, że do uwierzytelniania można używać tylko tożsamości usługi zarządzanej i usługi AAD.
properties.enableAnalyticalStorage	boolean		Flaga wskazująca, czy włączyć analizę magazynu.
properties.enableAutomaticFailover	boolean		Włącza automatyczne przełączanie w tryb failover regionu zapisu w rzadkim przypadku, że region jest niedostępny z powodu awarii. Automatyczne przełączanie w tryb failover spowoduje utworzenie nowego regionu zapisu dla konta i zostanie wybrane na podstawie priorytetów trybu failover skonfigurowanych dla konta.
properties.enableBurstCapacity	boolean		Flaga wskazująca włączanie/wyłączanie funkcji pojemności burst na koncie
properties.enableCassandraConnector	boolean		Włącza łącznik cassandra na koncie usługi Cosmos DB C*
properties.enableFreeTier	boolean		Flaga wskazująca, czy warstwa Bezpłatna jest włączona.
properties.enableMultipleWriteLocations	boolean		Umożliwia zapisanie konta w wielu lokalizacjach
properties.enablePartitionMerge	boolean		Flaga wskazująca włączanie/wyłączanie funkcji Scalanie partycji na koncie
properties.enablePerRegionPerPartitionAutoscale	boolean		Flaga wskazująca włączanie/wyłączanie funkcji PerRegionPerPartitionAutoscale na koncie
properties.ipRules	IpAddressOrRange[]		Lista adresów IPRules.
properties.isVirtualNetworkFilterEnabled	boolean		Flaga wskazująca, czy należy włączyć/wyłączyć reguły listy ACL sieci wirtualnej.
properties.keyVaultKeyUri	string		Identyfikator URI magazynu kluczy
properties.keysMetadata	DatabaseAccountKeysMetadata		Ta właściwość jest ignorowana podczas operacji aktualizacji/tworzenia, ponieważ metadane są tylko do odczytu. Obiekt reprezentuje metadane kluczy konta konta usługi Cosmos DB.
properties.locations	Location[]		Tablica zawierająca lokalizacje georeplikacji włączone dla konta usługi Cosmos DB.
properties.minimalTlsVersion	MinimalTlsVersion		Wskazuje minimalną dozwoloną wersję protokołu Tls. Wartość domyślna to Tls 1.2. Interfejsy API Cassandra i Mongo działają tylko z protokołem Tls 1.2.
properties.networkAclBypass	NetworkAclBypass		Wskazuje, jakie usługi mogą pomijać kontrole zapory.
properties.networkAclBypassResourceIds	string[]		Tablica zawierająca identyfikatory zasobów dla obejścia listy Acl sieci dla konta usługi Cosmos DB.
properties.publicNetworkAccess	PublicNetworkAccess		Czy żądania z sieci publicznej są dozwolone
properties.restoreParameters	RestoreParameters		Parametry wskazujące informacje o przywracaniu.
properties.virtualNetworkRules	VirtualNetworkRule[]		Lista reguł listy ACL sieci wirtualnej skonfigurowanych dla konta usługi Cosmos DB.
tags	object		Tagi to lista par klucz-wartość, które opisują zasób. Te tagi mogą służyć do wyświetlania i grupowania tego zasobu (między grupami zasobów). Dla zasobu można podać maksymalnie 15 tagów. Każdy tag musi mieć klucz nie większy niż 128 znaków i wartość nie większą niż 256 znaków. Na przykład domyślne środowisko dla typu szablonu jest ustawione z wartością "defaultExperience": "Cassandra". Bieżące wartości "defaultExperience" obejmują również wartości "Table", "Graph", "DocumentDB" i "MongoDB".
type	string		Typ zasobu platformy Azure.

DatabaseAccountGetResults

Konto bazy danych usługi Azure Cosmos DB.

Nazwa	Typ	Domyślna wartość	Opis
id	string		Unikatowy identyfikator zasobu usługi ARM.
identity	ManagedServiceIdentity		Tożsamość zasobu.
kind	DatabaseAccountKind	GlobalDocumentDB	Wskazuje typ konta bazy danych. Można to ustawić tylko podczas tworzenia konta bazy danych.
location	string		Lokalizacja grupy zasobów, do której należy zasób.
name	string		Nazwa zasobu usługi ARM.
properties.analyticalStorageConfiguration	AnalyticalStorageConfiguration		Właściwości specyficzne dla magazynu analitycznego.
properties.apiProperties	ApiProperties		Właściwości specyficzne dla interfejsu API.
properties.backupPolicy	BackupPolicy: ContinuousModeBackupPolicy PeriodicModeBackupPolicy		Obiekt reprezentujący zasady tworzenia kopii zapasowych na koncie.
properties.capabilities	Capability[]		Lista możliwości usługi Cosmos DB dla konta
properties.capacity	Capacity		Obiekt reprezentujący wszystkie właściwości związane z wymuszaniem pojemności na koncie.
properties.connectorOffer	ConnectorOffer		Typ oferty łącznika cassandra dla konta bazy danych Cosmos DB C*.
properties.consistencyPolicy	ConsistencyPolicy		Zasady spójności dla konta bazy danych usługi Cosmos DB.
properties.cors	CorsPolicy[]		Zasady CORS dla konta bazy danych usługi Cosmos DB.
properties.createMode	CreateMode	Default	Wyliczenie wskazujące tryb tworzenia konta.
properties.customerManagedKeyStatus	string		Wskazuje stan funkcji Klucz zarządzany przez klienta na koncie. W przypadku wystąpienia błędów właściwość zawiera wskazówki dotyczące rozwiązywania problemów.
properties.databaseAccountOfferType	DatabaseAccountOfferType		Typ oferty dla konta bazy danych usługi Cosmos DB. Wartość domyślna: Standardowa.
properties.defaultIdentity	string		Domyślna tożsamość na potrzeby uzyskiwania dostępu do magazynu kluczy używanych w funkcjach, takich jak klucze zarządzane przez klienta. Tożsamość domyślna musi być jawnie ustawiona przez użytkowników. Może to być "FirstPartyIdentity", "SystemAssignedIdentity" i nie tylko.
properties.disableKeyBasedMetadataWriteAccess	boolean		Wyłączanie operacji zapisu na zasobach metadanych (bazach danych, kontenerach, przepływności) za pomocą kluczy konta
properties.disableLocalAuth	boolean		Rezygnacja z uwierzytelniania lokalnego i upewnienie się, że do uwierzytelniania można używać tylko tożsamości usługi zarządzanej i usługi AAD.
properties.documentEndpoint	string		Punkt końcowy połączenia dla konta bazy danych usługi Cosmos DB.
properties.enableAnalyticalStorage	boolean		Flaga wskazująca, czy włączyć analizę magazynu.
properties.enableAutomaticFailover	boolean		Włącza automatyczne przełączanie w tryb failover regionu zapisu w rzadkim przypadku, że region jest niedostępny z powodu awarii. Automatyczne przełączanie w tryb failover spowoduje utworzenie nowego regionu zapisu dla konta i zostanie wybrane na podstawie priorytetów trybu failover skonfigurowanych dla konta.
properties.enableBurstCapacity	boolean		Flaga wskazująca włączanie/wyłączanie funkcji pojemności burst na koncie
properties.enableCassandraConnector	boolean		Włącza łącznik cassandra na koncie usługi Cosmos DB C*
properties.enableFreeTier	boolean		Flaga wskazująca, czy warstwa Bezpłatna jest włączona.
properties.enableMultipleWriteLocations	boolean		Umożliwia zapisanie konta w wielu lokalizacjach
properties.enablePartitionMerge	boolean		Flaga wskazująca włączanie/wyłączanie funkcji Scalanie partycji na koncie
properties.enablePerRegionPerPartitionAutoscale	boolean		Flaga wskazująca włączanie/wyłączanie funkcji PerRegionPerPartitionAutoscale na koncie
properties.failoverPolicies	FailoverPolicy[]		Tablica zawierająca regiony uporządkowane według priorytetów trybu failover.
properties.instanceId	string		Unikatowy identyfikator przypisany do konta bazy danych
properties.ipRules	IpAddressOrRange[]		Lista adresów IPRules.
properties.isVirtualNetworkFilterEnabled	boolean		Flaga wskazująca, czy należy włączyć/wyłączyć reguły listy ACL sieci wirtualnej.
properties.keyVaultKeyUri	string		Identyfikator URI magazynu kluczy
properties.keysMetadata	DatabaseAccountKeysMetadata		Obiekt reprezentujący metadane dla kluczy konta usługi Cosmos DB.
properties.locations	Location[]		Tablica zawierająca wszystkie lokalizacje włączone dla konta usługi Cosmos DB.
properties.minimalTlsVersion	MinimalTlsVersion		Wskazuje minimalną dozwoloną wersję protokołu Tls. Wartość domyślna to Tls 1.2. Interfejsy API Cassandra i Mongo działają tylko z protokołem Tls 1.2.
properties.networkAclBypass	NetworkAclBypass		Wskazuje, jakie usługi mogą pomijać kontrole zapory.
properties.networkAclBypassResourceIds	string[]		Tablica zawierająca identyfikatory zasobów dla obejścia listy Acl sieci dla konta usługi Cosmos DB.
properties.privateEndpointConnections	PrivateEndpointConnection[]		Lista połączeń prywatnych punktów końcowych skonfigurowanych dla konta usługi Cosmos DB.
properties.provisioningState	string		Stan konta usługi Cosmos DB w momencie wywołania operacji. Stan może być jednym z następujących elementów. "Tworzenie" — tworzone jest konto usługi Cosmos DB. Gdy konto znajduje się w stanie Tworzenie, zwracane są tylko właściwości określone jako dane wejściowe dla operacji tworzenia konta usługi Cosmos DB. "Powodzenie" — konto usługi Cosmos DB jest aktywne do użycia. "Aktualizowanie" — konto usługi Cosmos DB jest aktualizowane. "Usuwanie" — konto usługi Cosmos DB jest usuwane. "Niepowodzenie" — tworzenie konta usługi Cosmos DB nie powiodło się. "DeletionFailed" — usunięcie konta usługi Cosmos DB nie powiodło się.
properties.publicNetworkAccess	PublicNetworkAccess		Czy żądania z sieci publicznej są dozwolone
properties.readLocations	Location[]		Tablica zawierająca lokalizacje odczytu włączone dla konta usługi Cosmos DB.
properties.restoreParameters	RestoreParameters		Parametry wskazujące informacje o przywracaniu.
properties.virtualNetworkRules	VirtualNetworkRule[]		Lista reguł listy ACL sieci wirtualnej skonfigurowanych dla konta usługi Cosmos DB.
properties.writeLocations	Location[]		Tablica zawierająca lokalizację zapisu dla konta usługi Cosmos DB.
systemData	systemData		Metadane systemowe odnoszące się do tego zasobu.
tags	object		Tagi to lista par klucz-wartość, które opisują zasób. Te tagi mogą służyć do wyświetlania i grupowania tego zasobu (między grupami zasobów). Dla zasobu można podać maksymalnie 15 tagów. Każdy tag musi mieć klucz nie większy niż 128 znaków i wartość nie większą niż 256 znaków. Na przykład domyślne środowisko dla typu szablonu jest ustawione z wartością "defaultExperience": "Cassandra". Bieżące wartości "defaultExperience" obejmują również wartości "Table", "Graph", "DocumentDB" i "MongoDB".
type	string		Typ zasobu platformy Azure.

DatabaseAccountKeysMetadata

Metadane powiązane z poszczególnymi kluczami dostępu dla danego konta bazy danych usługi Cosmos DB.

Nazwa	Typ	Opis
primaryMasterKey	AccountKeyMetadata	Metadane związane z podstawowym kluczem Read-Write dla danego konta bazy danych usługi Cosmos DB.
primaryReadonlyMasterKey	AccountKeyMetadata	Metadane związane z podstawowym kluczem Read-Only dla danego konta bazy danych usługi Cosmos DB.
secondaryMasterKey	AccountKeyMetadata	Metadane związane z pomocniczym kluczem Read-Write dla danego konta bazy danych usługi Cosmos DB.
secondaryReadonlyMasterKey	AccountKeyMetadata	Metadane związane z pomocniczym kluczem Read-Only dla danego konta bazy danych usługi Cosmos DB.

DatabaseAccountKind

Wskazuje typ konta bazy danych. Można to ustawić tylko podczas tworzenia konta bazy danych.

Nazwa	Typ	Opis
GlobalDocumentDB	string
MongoDB	string
Parse	string

DatabaseAccountOfferType

Typ oferty dla konta bazy danych usługi Cosmos DB.

Nazwa	Typ	Opis
Standard	string

DatabaseRestoreResource

Określone bazy danych do przywrócenia.

Nazwa	Typ	Opis
collectionNames	string[]	Nazwy kolekcji dostępnych do przywrócenia.
databaseName	string	Nazwa bazy danych dostępnej do przywrócenia.

DefaultConsistencyLevel

Domyślny poziom spójności i ustawienia konfiguracji konta usługi Cosmos DB.

Nazwa	Typ	Opis
BoundedStaleness	string
ConsistentPrefix	string
Eventual	string
Session	string
Strong	string

FailoverPolicy

Zasady trybu failover dla danego regionu konta bazy danych.

Nazwa	Typ	Opis
failoverPriority	integer	Priorytet pracy w trybie failover regionu. Priorytet pracy w trybie failover 0 wskazuje region zapisu. Maksymalna wartość priorytetu trybu failover = (całkowita liczba regionów — 1). Wartości priorytetów trybu failover muszą być unikatowe dla każdego z regionów, w których istnieje konto bazy danych.
id	string	Unikatowy identyfikator regionu, w którym konto bazy danych jest replikowane. Przykład: <accountName>—<locationName>.
locationName	string	Nazwa regionu, w którym istnieje konto bazy danych.

GremlinDatabaseRestoreResource

Określone bazy danych Języka Gremlin do przywrócenia.

Nazwa	Typ	Opis
databaseName	string	Nazwa bazy danych gremlin dostępnej do przywrócenia.
graphNames	string[]	Nazwy grafów dostępnych do przywrócenia.

IpAddressOrRange

IpAddressOrRange, obiekt

Nazwa	Typ	Opis
ipAddressOrRange	string	Pojedynczy adres IPv4 lub pojedynczy zakres adresów IPv4 w formacie CIDR. Podane adresy IP muszą być poprawnie sformatowane i nie mogą być zawarte w jednym z następujących zakresów: 10.0.0.0/8, 100.64.0.0/10, 172.16.0.0/12, 192.168.0.0/16, ponieważ nie są one wymuszane przez filtr adresu IP. Przykład prawidłowych danych wejściowych: "23.40.210.245" lub "23.40.210.0/8".

Location

Region, w którym jest wdrażane konto bazy danych usługi Azure Cosmos DB.

Nazwa	Typ	Opis
documentEndpoint	string	Punkt końcowy połączenia dla określonego regionu. Przykład: https://<accountName>—<locationName>.documents.azure.com:443/
failoverPriority	integer	Priorytet pracy w trybie failover regionu. Priorytet pracy w trybie failover 0 wskazuje region zapisu. Maksymalna wartość priorytetu trybu failover = (całkowita liczba regionów — 1). Wartości priorytetów trybu failover muszą być unikatowe dla każdego z regionów, w których istnieje konto bazy danych.
id	string	Unikatowy identyfikator regionu w ramach konta bazy danych. Przykład: <accountName>—<locationName>.
isZoneRedundant	boolean	Flaga wskazująca, czy ten region jest regionem AvailabilityZone
locationName	string	Nazwa regionu.
provisioningState	string	Stan konta usługi Cosmos DB w momencie wywołania operacji. Stan może być jednym z następujących elementów. "Tworzenie" — tworzone jest konto usługi Cosmos DB. Gdy konto znajduje się w stanie Tworzenie, zwracane są tylko właściwości określone jako dane wejściowe dla operacji tworzenia konta usługi Cosmos DB. "Powodzenie" — konto usługi Cosmos DB jest aktywne do użycia. "Aktualizowanie" — konto usługi Cosmos DB jest aktualizowane. "Usuwanie" — konto usługi Cosmos DB jest usuwane. "Niepowodzenie" — tworzenie konta usługi Cosmos DB nie powiodło się. "DeletionFailed" — usunięcie konta usługi Cosmos DB nie powiodło się.

ManagedServiceIdentity

Tożsamość zasobu.

Nazwa	Typ	Opis
principalId	string	Identyfikator podmiotu zabezpieczeń tożsamości przypisanej przez system. Ta właściwość zostanie udostępniona tylko dla tożsamości przypisanej przez system.
tenantId	string	Identyfikator dzierżawy tożsamości przypisanej przez system. Ta właściwość zostanie udostępniona tylko dla tożsamości przypisanej przez system.
type	ResourceIdentityType	Typ tożsamości używany dla zasobu. Typ "SystemAssigned,UserAssigned" zawiera zarówno niejawnie utworzoną tożsamość, jak i zestaw tożsamości przypisanych przez użytkownika. Typ "Brak" spowoduje usunięcie wszystkich tożsamości z usługi.
userAssignedIdentities	UserAssignedIdentities	Lista tożsamości użytkowników skojarzonych z zasobem. Odwołania do klucza słownika tożsamości użytkownika będą identyfikatorami zasobów arm w postaci: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}".

MinimalTlsVersion

Wskazuje minimalną dozwoloną wersję protokołu Tls. Wartość domyślna to Tls 1.2. Interfejsy API Cassandra i Mongo działają tylko z protokołem Tls 1.2.

Nazwa	Typ	Opis
Tls	string
Tls11	string
Tls12	string

NetworkAclBypass

Wskazuje, jakie usługi mogą pomijać kontrole zapory.

Nazwa	Typ	Opis
AzureServices	string
None	string

PeriodicModeBackupPolicy

Obiekt reprezentujący zasady tworzenia kopii zapasowych w trybie okresowym.

Nazwa	Typ	Opis
migrationState	BackupPolicyMigrationState	Obiekt reprezentujący stan migracji między zasadami tworzenia kopii zapasowych.
periodicModeProperties	PeriodicModeProperties	Wartości konfiguracji dla kopii zapasowej w trybie okresowym
type	string: Periodic	Opisuje tryb tworzenia kopii zapasowych.

PeriodicModeProperties

Wartości konfiguracji dla kopii zapasowej w trybie okresowym

Nazwa	Typ	Opis
backupIntervalInMinutes	integer	Liczba całkowita reprezentująca interwał w minutach między dwoma kopiami zapasowymi
backupRetentionIntervalInHours	integer	Liczba całkowita reprezentująca czas (w godzinach), przez który każda kopia zapasowa jest zachowywana
backupStorageRedundancy	BackupStorageRedundancy	Wyliczenie wskazujące typ miejsca przechowywania kopii zapasowych

PrivateEndpointConnection

Połączenie prywatnego punktu końcowego

Nazwa	Typ	Opis
id	string	W pełni kwalifikowany identyfikator zasobu dla zasobu. Ex - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string	Nazwa zasobu
properties.groupId	string	Identyfikator grupy prywatnego punktu końcowego.
properties.privateEndpoint	PrivateEndpointProperty	Prywatny punkt końcowy, do którego należy połączenie.
properties.privateLinkServiceConnectionState	PrivateLinkServiceConnectionStateProperty	Stan połączenia prywatnego punktu końcowego.
properties.provisioningState	string	Stan aprowizacji prywatnego punktu końcowego.
type	string	Typ zasobu. Np. "Microsoft.Compute/virtualMachines" lub "Microsoft.Storage/storageAccounts"

PrivateEndpointProperty

Prywatny punkt końcowy, do którego należy połączenie.

Nazwa	Typ	Opis
id	string	Identyfikator zasobu prywatnego punktu końcowego.

PrivateLinkServiceConnectionStateProperty

Stan połączenia prywatnego punktu końcowego.

Nazwa	Typ	Opis
actionsRequired	string	Każda akcja wymagana poza podstawowym przepływem pracy (zatwierdzanie/ odrzucanie/rozłączanie)
description	string	Opis połączenia usługi private link.
status	string	Stan połączenia usługi private link.

PublicNetworkAccess

Czy żądania z sieci publicznej są dozwolone

Nazwa	Typ	Opis
Disabled	string
Enabled	string
SecuredByPerimeter	string

ResourceIdentityType

Typ tożsamości używany dla zasobu. Typ "SystemAssigned,UserAssigned" zawiera zarówno niejawnie utworzoną tożsamość, jak i zestaw tożsamości przypisanych przez użytkownika. Typ "Brak" spowoduje usunięcie wszystkich tożsamości z usługi.

Nazwa	Typ	Opis
None	string
SystemAssigned	string
SystemAssigned,UserAssigned	string
UserAssigned	string

RestoreMode

Opisuje tryb przywracania.

Nazwa	Typ	Opis
PointInTime	string

RestoreParameters

Parametry wskazujące informacje o przywracaniu.

Nazwa	Typ	Opis
databasesToRestore	DatabaseRestoreResource[]	Lista określonych baz danych dostępnych do przywrócenia.
gremlinDatabasesToRestore	GremlinDatabaseRestoreResource[]	Lista określonych baz danych gremlin dostępnych do przywrócenia.
restoreMode	RestoreMode	Opisuje tryb przywracania.
restoreSource	string	Identyfikator przywracalnego konta bazy danych, z którego należy zainicjować przywracanie. Na przykład: /subscriptions/{subscriptionId}/providers/Microsoft.DocumentDB/locations/{location}/restorableDatabaseAccounts/{restorableDatabaseAccountName}
restoreTimestampInUtc	string	Godzina przywrócenia konta (format ISO-8601).
restoreWithTtlDisabled	boolean	Określa, czy przywrócone konto będzie mieć czas-To-Live wyłączone po pomyślnym przywróceniu.
tablesToRestore	string[]	Lista określonych tabel dostępnych do przywrócenia.

ServerVersion

Opisuje wersję konta bazy danych MongoDB.

Nazwa	Typ	Opis
3.2	string
3.6	string
4.0	string
4.2	string
5.0	string
6.0	string
7.0	string

systemData

Metadane dotyczące tworzenia i ostatniej modyfikacji zasobu.

Nazwa	Typ	Opis
createdAt	string	Sygnatura czasowa tworzenia zasobu (UTC).
createdBy	string	Tożsamość, która utworzyła zasób.
createdByType	createdByType	Typ tożsamości, która utworzyła zasób.
lastModifiedAt	string	Znacznik czasu ostatniej modyfikacji zasobu (UTC)
lastModifiedBy	string	Tożsamość, która ostatnio zmodyfikowała zasób.
lastModifiedByType	createdByType	Typ tożsamości, która ostatnio zmodyfikowała zasób.

UserAssignedIdentities

Lista tożsamości użytkowników skojarzonych z zasobem. Odwołania do klucza słownika tożsamości użytkownika będą identyfikatorami zasobów arm w postaci: "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}".

Nazwa	Typ	Opis

VirtualNetworkRule

Obiekt reguły listy ACL sieci wirtualnej

Nazwa	Typ	Opis
id	string	Identyfikator zasobu podsieci, na przykład: /subscriptions/{subscriptionId}/resourceGroups/{groupName}/providers/Microsoft.Network/virtualNetworks/{virtualNetworkName}/subnets/{subnetName}.
ignoreMissingVNetServiceEndpoint	boolean	Utwórz regułę zapory, zanim sieć wirtualna ma włączony punkt końcowy usługi sieci wirtualnej.