Crea un nuovo server oppure sovrascrive un server esistente.
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/servers/{serverName}?api-version=2017-12-01
Parametri dell'URI
| Nome |
In |
Necessario |
Tipo |
Descrizione |
|
resourceGroupName
|
path |
True
|
string
|
Nome del gruppo di risorse. Per il nome non viene fatta distinzione tra maiuscole e minuscole.
|
|
serverName
|
path |
True
|
string
|
Nome del server.
|
|
subscriptionId
|
path |
True
|
string
|
ID della sottoscrizione di destinazione.
|
|
api-version
|
query |
True
|
string
|
Versione dell'API da usare per questa operazione.
|
Corpo della richiesta
| Nome |
Necessario |
Tipo |
Descrizione |
|
location
|
True
|
string
|
La posizione in cui risiede la risorsa.
|
|
properties
|
True
|
ServerPropertiesForCreate:
|
Proprietà del server.
|
|
identity
|
|
ResourceIdentity
|
Identità di Azure Active Directory del server.
|
|
sku
|
|
Sku
|
SKU (piano tariffario) del server.
|
|
tags
|
|
object
|
Metadati specifici dell'applicazione sotto forma di coppie chiave-valore.
|
Risposte
| Nome |
Tipo |
Descrizione |
|
200 OK
|
Server
|
OK
|
|
201 Created
|
Server
|
Data di creazione
|
|
202 Accepted
|
|
Accettato
|
|
Other Status Codes
|
CloudError
|
Risposta di errore che descrive perché l'operazione non è riuscita.
|
Sicurezza
azure_auth
Flusso OAuth2 di Azure Active Directory
Tipo:
oauth2
Flow:
implicit
URL di autorizzazione:
https://login.microsoftonline.com/common/oauth2/authorize
Ambiti
| Nome |
Descrizione |
|
user_impersonation
|
rappresentare l'account utente
|
Esempio
Create a database as a point in time restore
Esempio di richiesta
PUT https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TargetResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/targetserver?api-version=2017-12-01
{
"location": "brazilsouth",
"properties": {
"restorePointInTime": "2017-12-14T00:00:37.467Z",
"createMode": "PointInTimeRestore",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"
},
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"capacity": 2,
"family": "Gen5"
},
"tags": {
"ElasticServer": "1"
}
}
import com.azure.resourcemanager.postgresql.models.ServerPropertiesForRestore;
import com.azure.resourcemanager.postgresql.models.Sku;
import com.azure.resourcemanager.postgresql.models.SkuTier;
import java.time.OffsetDateTime;
import java.util.HashMap;
import java.util.Map;
/**
* Samples for Servers Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/
* ServerCreatePointInTimeRestore.json
*/
/**
* Sample code: Create a database as a point in time restore.
*
* @param manager Entry point to PostgreSqlManager.
*/
public static void
createADatabaseAsAPointInTimeRestore(com.azure.resourcemanager.postgresql.PostgreSqlManager manager) {
manager.servers().define("targetserver").withRegion("brazilsouth")
.withExistingResourceGroup("TargetResourceGroup")
.withProperties(new ServerPropertiesForRestore().withSourceServerId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver")
.withRestorePointInTime(OffsetDateTime.parse("2017-12-14T00:00:37.467Z")))
.withTags(mapOf("ElasticServer", "1"))
.withSku(new Sku().withName("B_Gen5_2").withTier(SkuTier.BASIC).withCapacity(2).withFamily("Gen5"))
.create();
}
// Use "Map.of" if available
@SuppressWarnings("unchecked")
private static <T> Map<String, T> mapOf(Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0; i < inputs.length; i += 2) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from typing import Any, IO, Union
from azure.identity import DefaultAzureCredential
from azure.mgmt.rdbms.postgresql import PostgreSQLManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-rdbms
# USAGE
python server_create_point_in_time_restore.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 = PostgreSQLManagementClient(
credential=DefaultAzureCredential(),
subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.servers.begin_create(
resource_group_name="TargetResourceGroup",
server_name="targetserver",
parameters={
"location": "brazilsouth",
"properties": {
"createMode": "PointInTimeRestore",
"restorePointInTime": "2017-12-14T00:00:37.467Z",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver",
},
"sku": {"capacity": 2, "family": "Gen5", "name": "B_Gen5_2", "tier": "Basic"},
"tags": {"ElasticServer": "1"},
},
).result()
print(response)
# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreatePointInTimeRestore.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armpostgresql_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/postgresql/armpostgresql"
)
// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c767823fdfd9d5e96bad245e3ea4d14d94a716bb/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreatePointInTimeRestore.json
func ExampleServersClient_BeginCreate_createADatabaseAsAPointInTimeRestore() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresql.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "TargetResourceGroup", "targetserver", armpostgresql.ServerForCreate{
Location: to.Ptr("brazilsouth"),
Properties: &armpostgresql.ServerPropertiesForRestore{
CreateMode: to.Ptr(armpostgresql.CreateModePointInTimeRestore),
RestorePointInTime: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-12-14T00:00:37.467Z"); return t }()),
SourceServerID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"),
},
SKU: &armpostgresql.SKU{
Name: to.Ptr("B_Gen5_2"),
Capacity: to.Ptr[int32](2),
Family: to.Ptr("Gen5"),
Tier: to.Ptr(armpostgresql.SKUTierBasic),
},
Tags: map[string]*string{
"ElasticServer": to.Ptr("1"),
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to 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.Server = armpostgresql.Server{
// Name: to.Ptr("targetserver"),
// Type: to.Ptr("Microsoft.DBforPostgreSQL/servers"),
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver"),
// Location: to.Ptr("brazilsouth"),
// Tags: map[string]*string{
// "ElasticServer": to.Ptr("1"),
// },
// Properties: &armpostgresql.ServerProperties{
// AdministratorLogin: to.Ptr("cloudsa"),
// EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2017-12-14T21:08:24.637Z"); return t}()),
// FullyQualifiedDomainName: to.Ptr("targetserver.postgres.database.azure.com"),
// SSLEnforcement: to.Ptr(armpostgresql.SSLEnforcementEnumEnabled),
// StorageProfile: &armpostgresql.StorageProfile{
// BackupRetentionDays: to.Ptr[int32](7),
// GeoRedundantBackup: to.Ptr(armpostgresql.GeoRedundantBackupDisabled),
// StorageMB: to.Ptr[int32](128000),
// },
// UserVisibleState: to.Ptr(armpostgresql.ServerStateReady),
// Version: to.Ptr(armpostgresql.ServerVersionNine6),
// },
// SKU: &armpostgresql.SKU{
// Name: to.Ptr("B_Gen5_2"),
// Capacity: to.Ptr[int32](2),
// Family: to.Ptr("Gen5"),
// Tier: to.Ptr(armpostgresql.SKUTierBasic),
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { PostgreSQLManagementClient } = require("@azure/arm-postgresql");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to Creates a new server, or will overwrite an existing server.
*
* @summary Creates a new server, or will overwrite an existing server.
* x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreatePointInTimeRestore.json
*/
async function createADatabaseAsAPointInTimeRestore() {
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const resourceGroupName = "TargetResourceGroup";
const serverName = "targetserver";
const parameters = {
location: "brazilsouth",
properties: {
createMode: "PointInTimeRestore",
restorePointInTime: new Date("2017-12-14T00:00:37.467Z"),
sourceServerId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver",
},
sku: { name: "B_Gen5_2", capacity: 2, family: "Gen5", tier: "Basic" },
tags: { elasticServer: "1" },
};
const credential = new DefaultAzureCredential();
const client = new PostgreSQLManagementClient(credential, subscriptionId);
const result = await client.servers.beginCreateAndWait(resourceGroupName, serverName, parameters);
console.log(result);
}
createADatabaseAsAPointInTimeRestore().catch(console.error);
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.PostgreSql.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql;
// Generated from example definition: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreatePointInTimeRestore.json
// this example is just showing the usage of "Servers_Create" operation, for the dependent resources, they will have to be created separately.
// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);
// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
string resourceGroupName = "TargetResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
// get the collection of this PostgreSqlServerResource
PostgreSqlServerCollection collection = resourceGroupResource.GetPostgreSqlServers();
// invoke the operation
string serverName = "targetserver";
PostgreSqlServerCreateOrUpdateContent content = new PostgreSqlServerCreateOrUpdateContent(new PostgreSqlServerPropertiesForRestore(new ResourceIdentifier("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"), DateTimeOffset.Parse("2017-12-14T00:00:37.467Z")), new AzureLocation("brazilsouth"))
{
Sku = new PostgreSqlSku("B_Gen5_2")
{
Tier = PostgreSqlSkuTier.Basic,
Capacity = 2,
Family = "Gen5",
},
Tags =
{
["ElasticServer"] = "1",
},
};
ArmOperation<PostgreSqlServerResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, serverName, content);
PostgreSqlServerResource result = lro.Value;
// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
PostgreSqlServerData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Risposta di esempio
{
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "targetserver.postgres.database.azure.com",
"earliestRestoreDate": "2017-12-14T21:08:24.637+00:00"
},
"location": "brazilsouth",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver",
"name": "targetserver",
"type": "Microsoft.DBforPostgreSQL/servers"
}
{
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "targetserver.postgres.database.azure.com",
"earliestRestoreDate": "2017-12-14T21:08:24.637+00:00"
},
"location": "brazilsouth",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver",
"name": "targetserver",
"type": "Microsoft.DBforPostgreSQL/servers"
}
Create a new server
Esempio di richiesta
PUT https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup/providers/Microsoft.DBforPostgreSQL/servers/pgtestsvc4?api-version=2017-12-01
{
"location": "westus",
"properties": {
"administratorLogin": "cloudsa",
"administratorLoginPassword": "<administratorLoginPassword>",
"sslEnforcement": "Enabled",
"minimalTlsVersion": "TLS1_2",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"createMode": "Default"
},
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"capacity": 2,
"family": "Gen5"
},
"tags": {
"ElasticServer": "1"
}
}
import com.azure.resourcemanager.postgresql.models.GeoRedundantBackup;
import com.azure.resourcemanager.postgresql.models.MinimalTlsVersionEnum;
import com.azure.resourcemanager.postgresql.models.ServerPropertiesForDefaultCreate;
import com.azure.resourcemanager.postgresql.models.Sku;
import com.azure.resourcemanager.postgresql.models.SkuTier;
import com.azure.resourcemanager.postgresql.models.SslEnforcementEnum;
import com.azure.resourcemanager.postgresql.models.StorageProfile;
import java.util.HashMap;
import java.util.Map;
/**
* Samples for Servers Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreate.json
*/
/**
* Sample code: Create a new server.
*
* @param manager Entry point to PostgreSqlManager.
*/
public static void createANewServer(com.azure.resourcemanager.postgresql.PostgreSqlManager manager) {
manager.servers().define("pgtestsvc4").withRegion("westus").withExistingResourceGroup("TestGroup")
.withProperties(new ServerPropertiesForDefaultCreate().withSslEnforcement(SslEnforcementEnum.ENABLED)
.withMinimalTlsVersion(MinimalTlsVersionEnum.TLS1_2)
.withStorageProfile(new StorageProfile().withBackupRetentionDays(7)
.withGeoRedundantBackup(GeoRedundantBackup.DISABLED).withStorageMB(128000))
.withAdministratorLogin("cloudsa").withAdministratorLoginPassword("fakeTokenPlaceholder"))
.withTags(mapOf("ElasticServer", "1"))
.withSku(new Sku().withName("B_Gen5_2").withTier(SkuTier.BASIC).withCapacity(2).withFamily("Gen5"))
.create();
}
// Use "Map.of" if available
@SuppressWarnings("unchecked")
private static <T> Map<String, T> mapOf(Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0; i < inputs.length; i += 2) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from typing import Any, IO, Union
from azure.identity import DefaultAzureCredential
from azure.mgmt.rdbms.postgresql import PostgreSQLManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-rdbms
# USAGE
python server_create.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main():
client = PostgreSQLManagementClient(
credential=DefaultAzureCredential(),
subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.servers.begin_create(
resource_group_name="TestGroup",
server_name="pgtestsvc4",
parameters={
"location": "westus",
"properties": {
"administratorLogin": "cloudsa",
"administratorLoginPassword": "<administratorLoginPassword>",
"createMode": "Default",
"minimalTlsVersion": "TLS1_2",
"sslEnforcement": "Enabled",
"storageProfile": {"backupRetentionDays": 7, "geoRedundantBackup": "Disabled", "storageMB": 128000},
},
"sku": {"capacity": 2, "family": "Gen5", "name": "B_Gen5_2", "tier": "Basic"},
"tags": {"ElasticServer": "1"},
},
).result()
print(response)
# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreate.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armpostgresql_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/postgresql/armpostgresql"
)
// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c767823fdfd9d5e96bad245e3ea4d14d94a716bb/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreate.json
func ExampleServersClient_BeginCreate_createANewServer() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresql.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "TestGroup", "pgtestsvc4", armpostgresql.ServerForCreate{
Location: to.Ptr("westus"),
Properties: &armpostgresql.ServerPropertiesForDefaultCreate{
CreateMode: to.Ptr(armpostgresql.CreateModeDefault),
MinimalTLSVersion: to.Ptr(armpostgresql.MinimalTLSVersionEnumTLS12),
SSLEnforcement: to.Ptr(armpostgresql.SSLEnforcementEnumEnabled),
StorageProfile: &armpostgresql.StorageProfile{
BackupRetentionDays: to.Ptr[int32](7),
GeoRedundantBackup: to.Ptr(armpostgresql.GeoRedundantBackupDisabled),
StorageMB: to.Ptr[int32](128000),
},
AdministratorLogin: to.Ptr("cloudsa"),
AdministratorLoginPassword: to.Ptr("<administratorLoginPassword>"),
},
SKU: &armpostgresql.SKU{
Name: to.Ptr("B_Gen5_2"),
Capacity: to.Ptr[int32](2),
Family: to.Ptr("Gen5"),
Tier: to.Ptr(armpostgresql.SKUTierBasic),
},
Tags: map[string]*string{
"ElasticServer": to.Ptr("1"),
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to 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.Server = armpostgresql.Server{
// Name: to.Ptr("pgtestsvc4"),
// Type: to.Ptr("Microsoft.DBforPostgreSQL/servers"),
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/pgtestsvc4"),
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "ElasticServer": to.Ptr("1"),
// },
// Properties: &armpostgresql.ServerProperties{
// AdministratorLogin: to.Ptr("cloudsa"),
// EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-03-14T21:08:24.637Z"); return t}()),
// FullyQualifiedDomainName: to.Ptr("pgtestsvc4.postgres.database.azure.com"),
// SSLEnforcement: to.Ptr(armpostgresql.SSLEnforcementEnumEnabled),
// StorageProfile: &armpostgresql.StorageProfile{
// BackupRetentionDays: to.Ptr[int32](7),
// GeoRedundantBackup: to.Ptr(armpostgresql.GeoRedundantBackupDisabled),
// StorageMB: to.Ptr[int32](128000),
// },
// UserVisibleState: to.Ptr(armpostgresql.ServerStateReady),
// Version: to.Ptr(armpostgresql.ServerVersionNine6),
// },
// SKU: &armpostgresql.SKU{
// Name: to.Ptr("B_Gen5_2"),
// Capacity: to.Ptr[int32](2),
// Family: to.Ptr("Gen5"),
// Tier: to.Ptr(armpostgresql.SKUTierBasic),
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { PostgreSQLManagementClient } = require("@azure/arm-postgresql");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to Creates a new server, or will overwrite an existing server.
*
* @summary Creates a new server, or will overwrite an existing server.
* x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreate.json
*/
async function createANewServer() {
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const resourceGroupName = "TestGroup";
const serverName = "pgtestsvc4";
const parameters = {
location: "westus",
properties: {
administratorLogin: "cloudsa",
administratorLoginPassword: "<administratorLoginPassword>",
createMode: "Default",
minimalTlsVersion: "TLS1_2",
sslEnforcement: "Enabled",
storageProfile: {
backupRetentionDays: 7,
geoRedundantBackup: "Disabled",
storageMB: 128000,
},
},
sku: { name: "B_Gen5_2", capacity: 2, family: "Gen5", tier: "Basic" },
tags: { elasticServer: "1" },
};
const credential = new DefaultAzureCredential();
const client = new PostgreSQLManagementClient(credential, subscriptionId);
const result = await client.servers.beginCreateAndWait(resourceGroupName, serverName, parameters);
console.log(result);
}
createANewServer().catch(console.error);
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.PostgreSql.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql;
// Generated from example definition: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreate.json
// this example is just showing the usage of "Servers_Create" operation, for the dependent resources, they will have to be created separately.
// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);
// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
string resourceGroupName = "TestGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
// get the collection of this PostgreSqlServerResource
PostgreSqlServerCollection collection = resourceGroupResource.GetPostgreSqlServers();
// invoke the operation
string serverName = "pgtestsvc4";
PostgreSqlServerCreateOrUpdateContent content = new PostgreSqlServerCreateOrUpdateContent(new PostgreSqlServerPropertiesForDefaultCreate("cloudsa", "<administratorLoginPassword>")
{
SslEnforcement = PostgreSqlSslEnforcementEnum.Enabled,
MinimalTlsVersion = PostgreSqlMinimalTlsVersionEnum.Tls1_2,
StorageProfile = new PostgreSqlStorageProfile()
{
BackupRetentionDays = 7,
GeoRedundantBackup = PostgreSqlGeoRedundantBackup.Disabled,
StorageInMB = 128000,
},
}, new AzureLocation("westus"))
{
Sku = new PostgreSqlSku("B_Gen5_2")
{
Tier = PostgreSqlSkuTier.Basic,
Capacity = 2,
Family = "Gen5",
},
Tags =
{
["ElasticServer"] = "1",
},
};
ArmOperation<PostgreSqlServerResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, serverName, content);
PostgreSqlServerResource result = lro.Value;
// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
PostgreSqlServerData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Risposta di esempio
{
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"minimalTlsVersion": "TLS1_2",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "pgtestsvc4.postgres.database.azure.com",
"earliestRestoreDate": "2018-03-14T21:08:24.637+00:00"
},
"location": "westus",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/pgtestsvc4",
"name": "pgtestsvc4",
"type": "Microsoft.DBforPostgreSQL/servers"
}
{
"sku": {
"name": "B_Gen5_2",
"tier": "Basic",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "pgtestsvc4.postgres.database.azure.com",
"earliestRestoreDate": "2018-03-14T21:08:24.637+00:00"
},
"location": "westus",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/pgtestsvc4",
"name": "pgtestsvc4",
"type": "Microsoft.DBforPostgreSQL/servers"
}
Create a replica server
Esempio di richiesta
PUT https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-replica1?api-version=2017-12-01
{
"location": "westcentralus",
"properties": {
"createMode": "Replica",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master"
},
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen5",
"capacity": 2
}
}
import com.azure.resourcemanager.postgresql.models.ServerPropertiesForReplica;
import com.azure.resourcemanager.postgresql.models.Sku;
import com.azure.resourcemanager.postgresql.models.SkuTier;
import java.util.HashMap;
import java.util.Map;
/**
* Samples for Servers Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/
* ServerCreateReplicaMode.json
*/
/**
* Sample code: Create a replica server.
*
* @param manager Entry point to PostgreSqlManager.
*/
public static void createAReplicaServer(com.azure.resourcemanager.postgresql.PostgreSqlManager manager) {
manager.servers().define("testserver-replica1").withRegion("westcentralus")
.withExistingResourceGroup("TestGroup_WestCentralUS")
.withProperties(new ServerPropertiesForReplica().withSourceServerId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master"))
.withSku(
new Sku().withName("GP_Gen5_2").withTier(SkuTier.GENERAL_PURPOSE).withCapacity(2).withFamily("Gen5"))
.create();
}
// Use "Map.of" if available
@SuppressWarnings("unchecked")
private static <T> Map<String, T> mapOf(Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0; i < inputs.length; i += 2) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from typing import Any, IO, Union
from azure.identity import DefaultAzureCredential
from azure.mgmt.rdbms.postgresql import PostgreSQLManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-rdbms
# USAGE
python server_create_replica_mode.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 = PostgreSQLManagementClient(
credential=DefaultAzureCredential(),
subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.servers.begin_create(
resource_group_name="TestGroup_WestCentralUS",
server_name="testserver-replica1",
parameters={
"location": "westcentralus",
"properties": {
"createMode": "Replica",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master",
},
"sku": {"capacity": 2, "family": "Gen5", "name": "GP_Gen5_2", "tier": "GeneralPurpose"},
},
).result()
print(response)
# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateReplicaMode.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armpostgresql_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/postgresql/armpostgresql"
)
// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c767823fdfd9d5e96bad245e3ea4d14d94a716bb/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateReplicaMode.json
func ExampleServersClient_BeginCreate_createAReplicaServer() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresql.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "TestGroup_WestCentralUS", "testserver-replica1", armpostgresql.ServerForCreate{
Location: to.Ptr("westcentralus"),
Properties: &armpostgresql.ServerPropertiesForReplica{
CreateMode: to.Ptr(armpostgresql.CreateModeReplica),
SourceServerID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master"),
},
SKU: &armpostgresql.SKU{
Name: to.Ptr("GP_Gen5_2"),
Capacity: to.Ptr[int32](2),
Family: to.Ptr("Gen5"),
Tier: to.Ptr(armpostgresql.SKUTierGeneralPurpose),
},
}, 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.Server = armpostgresql.Server{
// Name: to.Ptr("testserver-replica1"),
// Type: to.Ptr("Microsoft.DBforPostgreSQL/servers"),
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-replica1"),
// Location: to.Ptr("westcentralus"),
// Properties: &armpostgresql.ServerProperties{
// AdministratorLogin: to.Ptr("postgres"),
// EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-06-20T00:17:56.677Z"); return t}()),
// FullyQualifiedDomainName: to.Ptr("testserver-replica1.postgres.database.azure.com"),
// MasterServerID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master"),
// ReplicaCapacity: to.Ptr[int32](0),
// ReplicationRole: to.Ptr("Replica"),
// SSLEnforcement: to.Ptr(armpostgresql.SSLEnforcementEnumDisabled),
// StorageProfile: &armpostgresql.StorageProfile{
// BackupRetentionDays: to.Ptr[int32](7),
// GeoRedundantBackup: to.Ptr(armpostgresql.GeoRedundantBackupDisabled),
// StorageMB: to.Ptr[int32](2048000),
// },
// UserVisibleState: to.Ptr(armpostgresql.ServerStateReady),
// Version: to.Ptr(armpostgresql.ServerVersionNine6),
// },
// SKU: &armpostgresql.SKU{
// Name: to.Ptr("GP_Gen5_2"),
// Capacity: to.Ptr[int32](2),
// Family: to.Ptr("Gen4"),
// Tier: to.Ptr(armpostgresql.SKUTierGeneralPurpose),
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { PostgreSQLManagementClient } = require("@azure/arm-postgresql");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to Creates a new server, or will overwrite an existing server.
*
* @summary Creates a new server, or will overwrite an existing server.
* x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateReplicaMode.json
*/
async function createAReplicaServer() {
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const resourceGroupName = "TestGroup_WestCentralUS";
const serverName = "testserver-replica1";
const parameters = {
location: "westcentralus",
properties: {
createMode: "Replica",
sourceServerId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master",
},
sku: {
name: "GP_Gen5_2",
capacity: 2,
family: "Gen5",
tier: "GeneralPurpose",
},
};
const credential = new DefaultAzureCredential();
const client = new PostgreSQLManagementClient(credential, subscriptionId);
const result = await client.servers.beginCreateAndWait(resourceGroupName, serverName, parameters);
console.log(result);
}
createAReplicaServer().catch(console.error);
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.PostgreSql.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql;
// Generated from example definition: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateReplicaMode.json
// this example is just showing the usage of "Servers_Create" operation, for the dependent resources, they will have to be created separately.
// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);
// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
string resourceGroupName = "TestGroup_WestCentralUS";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
// get the collection of this PostgreSqlServerResource
PostgreSqlServerCollection collection = resourceGroupResource.GetPostgreSqlServers();
// invoke the operation
string serverName = "testserver-replica1";
PostgreSqlServerCreateOrUpdateContent content = new PostgreSqlServerCreateOrUpdateContent(new PostgreSqlServerPropertiesForReplica(new ResourceIdentifier("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master")), new AzureLocation("westcentralus"))
{
Sku = new PostgreSqlSku("GP_Gen5_2")
{
Tier = PostgreSqlSkuTier.GeneralPurpose,
Capacity = 2,
Family = "Gen5",
},
};
ArmOperation<PostgreSqlServerResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, serverName, content);
PostgreSqlServerResource result = lro.Value;
// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
PostgreSqlServerData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Risposta di esempio
{
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "postgres",
"storageProfile": {
"storageMB": 2048000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Disabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "testserver-replica1.postgres.database.azure.com",
"earliestRestoreDate": "2018-06-20T00:17:56.677+00:00",
"replicationRole": "Replica",
"masterServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master",
"replicaCapacity": 0
},
"location": "westcentralus",
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-replica1",
"name": "testserver-replica1",
"type": "Microsoft.DBforPostgreSQL/servers"
}
{
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen4",
"capacity": 2
},
"properties": {
"administratorLogin": "postgres",
"storageProfile": {
"storageMB": 2048000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Disabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "testserver-replica1.postgres.database.azure.com",
"earliestRestoreDate": "2018-06-20T00:17:56.677+00:00",
"replicationRole": "Replica",
"masterServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-master",
"replicaCapacity": 0
},
"location": "westcentralus",
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TestGroup_WestCentralUS/providers/Microsoft.DBforPostgreSQL/servers/testserver-replica1",
"name": "testserver-replica1",
"type": "Microsoft.DBforPostgreSQL/servers"
}
Create a server as a geo restore
Esempio di richiesta
PUT https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/TargetResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/targetserver?api-version=2017-12-01
{
"location": "westus",
"properties": {
"createMode": "GeoRestore",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"
},
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen5",
"capacity": 2
},
"tags": {
"ElasticServer": "1"
}
}
import com.azure.resourcemanager.postgresql.models.ServerPropertiesForGeoRestore;
import com.azure.resourcemanager.postgresql.models.Sku;
import com.azure.resourcemanager.postgresql.models.SkuTier;
import java.util.HashMap;
import java.util.Map;
/**
* Samples for Servers Create.
*/
public final class Main {
/*
* x-ms-original-file:
* specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/
* ServerCreateGeoRestoreMode.json
*/
/**
* Sample code: Create a server as a geo restore.
*
* @param manager Entry point to PostgreSqlManager.
*/
public static void createAServerAsAGeoRestore(com.azure.resourcemanager.postgresql.PostgreSqlManager manager) {
manager.servers().define("targetserver").withRegion("westus").withExistingResourceGroup("TargetResourceGroup")
.withProperties(new ServerPropertiesForGeoRestore().withSourceServerId(
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"))
.withTags(mapOf("ElasticServer", "1"))
.withSku(
new Sku().withName("GP_Gen5_2").withTier(SkuTier.GENERAL_PURPOSE).withCapacity(2).withFamily("Gen5"))
.create();
}
// Use "Map.of" if available
@SuppressWarnings("unchecked")
private static <T> Map<String, T> mapOf(Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0; i < inputs.length; i += 2) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
from typing import Any, IO, Union
from azure.identity import DefaultAzureCredential
from azure.mgmt.rdbms.postgresql import PostgreSQLManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-rdbms
# USAGE
python server_create_geo_restore_mode.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 = PostgreSQLManagementClient(
credential=DefaultAzureCredential(),
subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
)
response = client.servers.begin_create(
resource_group_name="TargetResourceGroup",
server_name="targetserver",
parameters={
"location": "westus",
"properties": {
"createMode": "GeoRestore",
"sourceServerId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver",
},
"sku": {"capacity": 2, "family": "Gen5", "name": "GP_Gen5_2", "tier": "GeneralPurpose"},
"tags": {"ElasticServer": "1"},
},
).result()
print(response)
# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateGeoRestoreMode.json
if __name__ == "__main__":
main()
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
package armpostgresql_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/postgresql/armpostgresql"
)
// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/c767823fdfd9d5e96bad245e3ea4d14d94a716bb/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateGeoRestoreMode.json
func ExampleServersClient_BeginCreate_createAServerAsAGeoRestore() {
cred, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
log.Fatalf("failed to obtain a credential: %v", err)
}
ctx := context.Background()
clientFactory, err := armpostgresql.NewClientFactory("<subscription-id>", cred, nil)
if err != nil {
log.Fatalf("failed to create client: %v", err)
}
poller, err := clientFactory.NewServersClient().BeginCreate(ctx, "TargetResourceGroup", "targetserver", armpostgresql.ServerForCreate{
Location: to.Ptr("westus"),
Properties: &armpostgresql.ServerPropertiesForGeoRestore{
CreateMode: to.Ptr(armpostgresql.CreateModeGeoRestore),
SourceServerID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver"),
},
SKU: &armpostgresql.SKU{
Name: to.Ptr("GP_Gen5_2"),
Capacity: to.Ptr[int32](2),
Family: to.Ptr("Gen5"),
Tier: to.Ptr(armpostgresql.SKUTierGeneralPurpose),
},
Tags: map[string]*string{
"ElasticServer": to.Ptr("1"),
},
}, nil)
if err != nil {
log.Fatalf("failed to finish the request: %v", err)
}
res, err := poller.PollUntilDone(ctx, nil)
if err != nil {
log.Fatalf("failed to 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.Server = armpostgresql.Server{
// Name: to.Ptr("targetserver"),
// Type: to.Ptr("Microsoft.DBforPostgreSQL/servers"),
// ID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver"),
// Location: to.Ptr("westus"),
// Tags: map[string]*string{
// "ElasticServer": to.Ptr("1"),
// },
// Properties: &armpostgresql.ServerProperties{
// AdministratorLogin: to.Ptr("cloudsa"),
// EarliestRestoreDate: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-03-14T21:08:24.637Z"); return t}()),
// FullyQualifiedDomainName: to.Ptr("targetserver.postgres.database.azure.com"),
// SSLEnforcement: to.Ptr(armpostgresql.SSLEnforcementEnumEnabled),
// StorageProfile: &armpostgresql.StorageProfile{
// BackupRetentionDays: to.Ptr[int32](7),
// GeoRedundantBackup: to.Ptr(armpostgresql.GeoRedundantBackupDisabled),
// StorageMB: to.Ptr[int32](128000),
// },
// UserVisibleState: to.Ptr(armpostgresql.ServerStateReady),
// Version: to.Ptr(armpostgresql.ServerVersionNine6),
// },
// SKU: &armpostgresql.SKU{
// Name: to.Ptr("GP_Gen5_2"),
// Capacity: to.Ptr[int32](2),
// Family: to.Ptr("Gen5"),
// Tier: to.Ptr(armpostgresql.SKUTierGeneralPurpose),
// },
// }
}
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
const { PostgreSQLManagementClient } = require("@azure/arm-postgresql");
const { DefaultAzureCredential } = require("@azure/identity");
/**
* This sample demonstrates how to Creates a new server, or will overwrite an existing server.
*
* @summary Creates a new server, or will overwrite an existing server.
* x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateGeoRestoreMode.json
*/
async function createAServerAsAGeoRestore() {
const subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
const resourceGroupName = "TargetResourceGroup";
const serverName = "targetserver";
const parameters = {
location: "westus",
properties: {
createMode: "GeoRestore",
sourceServerId:
"/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver",
},
sku: {
name: "GP_Gen5_2",
capacity: 2,
family: "Gen5",
tier: "GeneralPurpose",
},
tags: { elasticServer: "1" },
};
const credential = new DefaultAzureCredential();
const client = new PostgreSQLManagementClient(credential, subscriptionId);
const result = await client.servers.beginCreateAndWait(resourceGroupName, serverName, parameters);
console.log(result);
}
createAServerAsAGeoRestore().catch(console.error);
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.PostgreSql.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.PostgreSql;
// Generated from example definition: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2017-12-01/examples/ServerCreateGeoRestoreMode.json
// this example is just showing the usage of "Servers_Create" operation, for the dependent resources, they will have to be created separately.
// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);
// this example assumes you already have this ResourceGroupResource created on azure
// for more information of creating ResourceGroupResource, please refer to the document of ResourceGroupResource
string subscriptionId = "ffffffff-ffff-ffff-ffff-ffffffffffff";
string resourceGroupName = "TargetResourceGroup";
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
// get the collection of this PostgreSqlServerResource
PostgreSqlServerCollection collection = resourceGroupResource.GetPostgreSqlServers();
// invoke the operation
string serverName = "targetserver";
PostgreSqlServerCreateOrUpdateContent content = new PostgreSqlServerCreateOrUpdateContent(new PostgreSqlServerPropertiesForGeoRestore(new ResourceIdentifier("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforPostgreSQL/servers/sourceserver")), new AzureLocation("westus"))
{
Sku = new PostgreSqlSku("GP_Gen5_2")
{
Tier = PostgreSqlSkuTier.GeneralPurpose,
Capacity = 2,
Family = "Gen5",
},
Tags =
{
["ElasticServer"] = "1",
},
};
ArmOperation<PostgreSqlServerResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, serverName, content);
PostgreSqlServerResource result = lro.Value;
// the variable result is a resource, you could call other operations on this instance as well
// but just for demo, we get its data from this resource instance
PostgreSqlServerData resourceData = result.Data;
// for demo we just print out the id
Console.WriteLine($"Succeeded on id: {resourceData.Id}");
To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue
Risposta di esempio
{
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "targetserver.postgres.database.azure.com",
"earliestRestoreDate": "2018-03-14T21:08:24.637+00:00"
},
"location": "westus",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver",
"name": "targetserver",
"type": "Microsoft.DBforPostgreSQL/servers"
}
{
"sku": {
"name": "GP_Gen5_2",
"tier": "GeneralPurpose",
"family": "Gen5",
"capacity": 2
},
"properties": {
"administratorLogin": "cloudsa",
"storageProfile": {
"storageMB": 128000,
"backupRetentionDays": 7,
"geoRedundantBackup": "Disabled"
},
"version": "9.6",
"sslEnforcement": "Enabled",
"userVisibleState": "Ready",
"fullyQualifiedDomainName": "targetserver.postgres.database.azure.com",
"earliestRestoreDate": "2018-03-14T21:08:24.637+00:00"
},
"location": "westus",
"tags": {
"ElasticServer": "1"
},
"id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/testrg/providers/Microsoft.DBforPostgreSQL/servers/targetserver",
"name": "targetserver",
"type": "Microsoft.DBforPostgreSQL/servers"
}
Definizioni
CloudError
Risposta di errore dal servizio Batch.
| Nome |
Tipo |
Descrizione |
|
error
|
ErrorResponse
|
Risposta di errore
Risposta di errore comune per tutte le API Resource Manager di Azure per restituire i dettagli dell'errore per le operazioni non riuscite. Segue anche il formato di risposta di errore OData.
|
ErrorAdditionalInfo
Informazioni aggiuntive sulla gestione delle risorse.
| Nome |
Tipo |
Descrizione |
|
info
|
object
|
Informazioni aggiuntive.
|
|
type
|
string
|
Tipo di informazioni aggiuntive.
|
ErrorResponse
Risposta di errore
| Nome |
Tipo |
Descrizione |
|
additionalInfo
|
ErrorAdditionalInfo[]
|
Informazioni aggiuntive sull'errore.
|
|
code
|
string
|
Codice di errore.
|
|
details
|
ErrorResponse[]
|
Dettagli dell'errore.
|
|
message
|
string
|
Messaggio di errore.
|
|
target
|
string
|
Destinazione dell'errore.
|
GeoRedundantBackup
Abilitare la ridondanza geografica o meno per il backup del server.
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
|
|
Enabled
|
string
|
|
IdentityType
Tipo di identità. Impostare questa opzione su "SystemAssigned" per creare e assegnare automaticamente un'entità di Azure Active Directory per la risorsa.
| Nome |
Tipo |
Descrizione |
|
SystemAssigned
|
string
|
|
InfrastructureEncryption
Aggiungere un secondo livello di crittografia per i dati usando un nuovo algoritmo di crittografia che offre ulteriore protezione dei dati. Il valore è facoltativo, ma se passato, deve essere "Disabilitato" o "Abilitato".
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
Livello aggiuntivo (2°) di crittografia per i dati inattivi
|
|
Enabled
|
string
|
Valore predefinito per un singolo livello di crittografia per i dati inattivi.
|
MinimalTlsVersionEnum
Applicare una versione minima di Tls per il server.
| Nome |
Tipo |
Descrizione |
|
TLS1_0
|
string
|
|
|
TLS1_1
|
string
|
|
|
TLS1_2
|
string
|
|
|
TLSEnforcementDisabled
|
string
|
|
PrivateEndpointProperty
| Nome |
Tipo |
Descrizione |
|
id
|
string
|
ID risorsa dell'endpoint privato.
|
PrivateEndpointProvisioningState
Stato della connessione dell'endpoint privato.
| Nome |
Tipo |
Descrizione |
|
Approving
|
string
|
|
|
Dropping
|
string
|
|
|
Failed
|
string
|
|
|
Ready
|
string
|
|
|
Rejecting
|
string
|
|
PrivateLinkServiceConnectionStateActionsRequire
Azioni necessarie per la connessione al servizio di collegamento privato.
| Nome |
Tipo |
Descrizione |
|
None
|
string
|
|
PrivateLinkServiceConnectionStateStatus
Stato di connessione del servizio di collegamento privato.
| Nome |
Tipo |
Descrizione |
|
Approved
|
string
|
|
|
Disconnected
|
string
|
|
|
Pending
|
string
|
|
|
Rejected
|
string
|
|
PublicNetworkAccessEnum
Se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere "Abilitato" o "Disabilitato"
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
|
|
Enabled
|
string
|
|
ResourceIdentity
Configurazione dell'identità di Azure Active Directory per una risorsa.
| Nome |
Tipo |
Descrizione |
|
principalId
|
string
|
ID entità di Azure Active Directory.
|
|
tenantId
|
string
|
ID tenant di Azure Active Directory.
|
|
type
|
IdentityType
|
Tipo di identità. Impostare questa opzione su "SystemAssigned" per creare e assegnare automaticamente un'entità di Azure Active Directory per la risorsa.
|
Server
Rappresenta un server.
| Nome |
Tipo |
Descrizione |
|
id
|
string
|
ID di risorsa completo per la risorsa. Ad esempio - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
|
|
identity
|
ResourceIdentity
|
Identità di Azure Active Directory del server.
|
|
location
|
string
|
Posizione geografica in cui risiede la risorsa
|
|
name
|
string
|
nome della risorsa.
|
|
properties.administratorLogin
|
string
|
Nome di accesso dell'amministratore di un server. Può essere specificato solo quando il server viene creato (ed è necessario per la creazione).
|
|
properties.byokEnforcement
|
string
|
Stato che indica se la crittografia dei dati del server è abilitata con chiavi gestite dal cliente.
|
|
properties.earliestRestoreDate
|
string
|
Tempo di creazione del punto di ripristino meno recente (formato ISO8601)
|
|
properties.fullyQualifiedDomainName
|
string
|
Nome di dominio completo di un server.
|
|
properties.infrastructureEncryption
|
InfrastructureEncryption
|
Stato che indica se la crittografia dell'infrastruttura è abilitata per il server.
|
|
properties.masterServerId
|
string
|
ID server master di un server di replica.
|
|
properties.minimalTlsVersion
|
MinimalTlsVersionEnum
|
Applicare una versione minima di Tls per il server.
|
|
properties.privateEndpointConnections
|
ServerPrivateEndpointConnection[]
|
Elenco di connessioni di endpoint privato in un server
|
|
properties.publicNetworkAccess
|
PublicNetworkAccessEnum
|
Indica se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere 'Enabled' o 'Disabled'
|
|
properties.replicaCapacity
|
integer
|
Numero massimo di repliche che un server master può avere.
|
|
properties.replicationRole
|
string
|
Ruolo di replica del server.
|
|
properties.sslEnforcement
|
SslEnforcementEnum
|
Abilitare o meno l'imposizione ssl quando ci si connette al server.
|
|
properties.storageProfile
|
StorageProfile
|
Profilo di archiviazione di un server.
|
|
properties.userVisibleState
|
ServerState
|
Stato di un server visibile all'utente.
|
|
properties.version
|
ServerVersion
|
Versione del server.
|
|
sku
|
Sku
|
SKU (piano tariffario) del server.
|
|
tags
|
object
|
Tag delle risorse.
|
|
type
|
string
|
Tipo di risorsa. Ad esempio, "Microsoft.Compute/virtualMachines" o "Microsoft.Storage/storageAccounts"
|
ServerForCreate
Rappresenta un server da creare.
| Nome |
Tipo |
Descrizione |
|
identity
|
ResourceIdentity
|
Identità di Azure Active Directory del server.
|
|
location
|
string
|
Posizione in cui risiede la risorsa.
|
|
properties
|
ServerPropertiesForCreate:
|
Proprietà del server.
|
|
sku
|
Sku
|
SKU (piano tariffario) del server.
|
|
tags
|
object
|
Metadati specifici dell'applicazione sotto forma di coppie chiave-valore.
|
ServerPrivateEndpointConnection
Connessione endpoint privato in un server
ServerPrivateEndpointConnectionProperties
Proprietà di una connessione endpoint privato.
ServerPrivateLinkServiceConnectionStateProperty
ServerPropertiesForDefaultCreate
Proprietà utilizzate per creare un nuovo server.
| Nome |
Tipo |
Descrizione |
|
administratorLogin
|
string
|
Nome di accesso dell'amministratore di un server. Può essere specificato solo quando il server viene creato (ed è necessario per la creazione).
|
|
administratorLoginPassword
|
string
|
Password dell'account di accesso dell'amministratore.
|
|
createMode
|
string:
Default
|
Modalità di creazione di un nuovo server.
|
|
infrastructureEncryption
|
InfrastructureEncryption
|
Stato che indica se la crittografia dell'infrastruttura è abilitata per il server.
|
|
minimalTlsVersion
|
MinimalTlsVersionEnum
|
Applicare una versione minima di Tls per il server.
|
|
publicNetworkAccess
|
PublicNetworkAccessEnum
|
Indica se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere 'Enabled' o 'Disabled'
|
|
sslEnforcement
|
SslEnforcementEnum
|
Abilitare o meno l'imposizione ssl quando ci si connette al server.
|
|
storageProfile
|
StorageProfile
|
Profilo di archiviazione di un server.
|
|
version
|
ServerVersion
|
Versione del server.
|
ServerPropertiesForGeoRestore
Proprietà usate per creare un nuovo server ripristinando un'area diversa da un backup con replica geografica.
| Nome |
Tipo |
Descrizione |
|
createMode
|
string:
GeoRestore
|
Modalità di creazione di un nuovo server.
|
|
infrastructureEncryption
|
InfrastructureEncryption
|
Stato che indica se la crittografia dell'infrastruttura è abilitata per il server.
|
|
minimalTlsVersion
|
MinimalTlsVersionEnum
|
Applicare una versione minima di Tls per il server.
|
|
publicNetworkAccess
|
PublicNetworkAccessEnum
|
Indica se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere 'Enabled' o 'Disabled'
|
|
sourceServerId
|
string
|
ID del server di origine da cui eseguire il ripristino.
|
|
sslEnforcement
|
SslEnforcementEnum
|
Abilitare o meno l'imposizione ssl quando ci si connette al server.
|
|
storageProfile
|
StorageProfile
|
Profilo di archiviazione di un server.
|
|
version
|
ServerVersion
|
Versione del server.
|
ServerPropertiesForReplica
Proprietà per creare una nuova replica.
| Nome |
Tipo |
Descrizione |
|
createMode
|
string:
Replica
|
Modalità di creazione di un nuovo server.
|
|
infrastructureEncryption
|
InfrastructureEncryption
|
Stato che indica se la crittografia dell'infrastruttura è abilitata per il server.
|
|
minimalTlsVersion
|
MinimalTlsVersionEnum
|
Applicare una versione minima di Tls per il server.
|
|
publicNetworkAccess
|
PublicNetworkAccessEnum
|
Indica se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere 'Enabled' o 'Disabled'
|
|
sourceServerId
|
string
|
ID server master da cui creare la replica.
|
|
sslEnforcement
|
SslEnforcementEnum
|
Abilitare o meno l'imposizione ssl quando ci si connette al server.
|
|
storageProfile
|
StorageProfile
|
Profilo di archiviazione di un server.
|
|
version
|
ServerVersion
|
Versione del server.
|
ServerPropertiesForRestore
Proprietà utilizzate per creare un nuovo server ripristinando da un backup.
| Nome |
Tipo |
Descrizione |
|
createMode
|
string:
PointInTimeRestore
|
Modalità di creazione di un nuovo server.
|
|
infrastructureEncryption
|
InfrastructureEncryption
|
Stato che indica se la crittografia dell'infrastruttura è abilitata per il server.
|
|
minimalTlsVersion
|
MinimalTlsVersionEnum
|
Applicare una versione minima di Tls per il server.
|
|
publicNetworkAccess
|
PublicNetworkAccessEnum
|
Indica se l'accesso alla rete pubblica è consentito per questo server. Il valore è facoltativo, ma se passato, deve essere 'Enabled' o 'Disabled'
|
|
restorePointInTime
|
string
|
Tempo di creazione del punto di ripristino (formato ISO8601), specificando il tempo da cui eseguire il ripristino.
|
|
sourceServerId
|
string
|
ID del server di origine da cui eseguire il ripristino.
|
|
sslEnforcement
|
SslEnforcementEnum
|
Abilitare o meno l'imposizione ssl quando ci si connette al server.
|
|
storageProfile
|
StorageProfile
|
Profilo di archiviazione di un server.
|
|
version
|
ServerVersion
|
Versione del server.
|
ServerState
Stato di un server visibile all'utente.
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
|
|
Dropping
|
string
|
|
|
Inaccessible
|
string
|
|
|
Ready
|
string
|
|
ServerVersion
Versione di un server.
| Nome |
Tipo |
Descrizione |
|
10
|
string
|
|
|
10.0
|
string
|
|
|
10.2
|
string
|
|
|
11
|
string
|
|
|
9.5
|
string
|
|
|
9.6
|
string
|
|
Sku
Proprietà correlate alle informazioni di fatturazione di un server.
| Nome |
Tipo |
Descrizione |
|
capacity
|
integer
|
Capacità di aumento/riduzione, che rappresenta le unità di calcolo del server.
|
|
family
|
string
|
Famiglia di hardware.
|
|
name
|
string
|
Nome dello SKU, in genere, tier + family + cores, ad esempio B_Gen4_1, GP_Gen5_8.
|
|
size
|
string
|
Codice delle dimensioni da interpretare in base alla risorsa in base alle esigenze.
|
|
tier
|
SkuTier
|
Livello dello SKU specifico, ad esempio Basic.
|
SkuTier
Livello dello SKU specifico, ad esempio Basic.
| Nome |
Tipo |
Descrizione |
|
Basic
|
string
|
|
|
GeneralPurpose
|
string
|
|
|
MemoryOptimized
|
string
|
|
SslEnforcementEnum
Abilitare o meno l'imposizione ssl quando ci si connette al server.
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
|
|
Enabled
|
string
|
|
StorageAutogrow
Abilitare l'aumento automatico dell'archiviazione.
| Nome |
Tipo |
Descrizione |
|
Disabled
|
string
|
|
|
Enabled
|
string
|
|
StorageProfile
Proprietà del profilo di archiviazione di un server
| Nome |
Tipo |
Descrizione |
|
backupRetentionDays
|
integer
|
Giorni di conservazione dei backup per il server.
|
|
geoRedundantBackup
|
GeoRedundantBackup
|
Abilitare la ridondanza geografica o meno per il backup del server.
|
|
storageAutogrow
|
StorageAutogrow
|
Abilitare l'aumento automatico dell'archiviazione.
|
|
storageMB
|
integer
|
Spazio di archiviazione massimo consentito per un server.
|