Servers - Update

Service:: PostgreSQL

API-versie:: 2025-08-01

Hiermee werkt u een bestaande server bij. De aanvraagbody kan een of meer van de eigenschappen bevatten die aanwezig zijn in de normale serverdefinitie.

PATCH https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.DBforPostgreSQL/flexibleServers/{serverName}?api-version=2025-08-01

URI-parameters

Name	In	Vereist	Type	Description
resourceGroupName	path	True	string minLength: 1 maxLength: 90	De naam van de resourcegroep. De naam is hoofdletterongevoelig.
serverName	path	True	string minLength: 3 maxLength: 63 pattern: ^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*	De naam van de server.
subscriptionId	path	True	string (uuid)	De id van het doelabonnement. De waarde moet een UUID zijn.
api-version	query	True	string minLength: 1	De API-versie die voor deze bewerking moet worden gebruikt.

Aanvraagbody

Name	Type	Description
identity	UserAssignedIdentity	Beschrijft de identiteit van de toepassing.
properties.administratorLogin	string	Naam van de login die is aangewezen als de eerste beheerder op basis van een wachtwoord die is toegewezen aan uw exemplaar van PostgreSQL. Moet worden opgegeven wanneer u verificatie op basis van een wachtwoord voor de eerste keer inschakelt op een server. Eenmaal ingesteld op een bepaalde waarde, kan deze niet meer worden gewijzigd voor de rest van de levensduur van een server. Als u verificatie op basis van een wachtwoord uitschakelt op een server waarop deze is ingeschakeld, wordt deze op wachtwoord gebaseerde rol niet verwijderd.
properties.administratorLoginPassword	string (password)	Wachtwoord toegewezen aan de beheerderslogin. Zolang wachtwoordverificatie is ingeschakeld, kan dit wachtwoord op elk moment worden gewijzigd.
properties.authConfig	AuthConfigForPatch	Configuratie-eigenschappen voor verificatie van een server.
properties.availabilityZone	string	Beschikbaarheidszone van een server.
properties.backup	BackupForPatch	Back-upeigenschappen van een server.
properties.cluster	Cluster	Clustereigenschappen van een server.
properties.createMode	CreateModeForPatch	Updatemodus van een bestaande server.
properties.dataEncryption	DataEncryption	Eigenschappen van gegevensversleuteling van een server.
properties.highAvailability	HighAvailabilityForPatch	Eigenschappen van hoge beschikbaarheid van een server.
properties.maintenanceWindow	MaintenanceWindowForPatch	Eigenschappen van een onderhoudsvenster van een server.
properties.network	Network	Netwerkeigenschappen van een server. Alleen nodig als u wilt dat uw server wordt geïntegreerd in een virtueel netwerk dat door de klant wordt aangeboden.
properties.replica	Replica	Lees replica-eigenschappen van een server. Alleen vereist als u een server wilt promoten.
properties.replicationRole	ReplicationRole	Rol van de server in een replicatieset.
properties.storage	Storage	Opslageigenschappen van een server.
properties.version	PostgresMajorVersion	Primaire versie van de PostgreSQL-database-engine.
sku	SkuForPatch	Rekenlaag en grootte van een server.
tags	object	Toepassingsspecifieke metagegevens in de vorm van sleutel-waardeparen.

Antwoorden

Name	Type	Description
202 Accepted		Geaccepteerd. Kopteksten Location: string Azure-AsyncOperation: string
Other Status Codes	ErrorResponse	Foutreactie waarin wordt beschreven waarom de bewerking is mislukt.

Name

Type

Description

202 Accepted

Geaccepteerd.

Kopteksten

Location: string
Azure-AsyncOperation: string

Other Status Codes

ErrorResponse

Foutreactie waarin wordt beschreven waarom de bewerking is mislukt.

Beveiliging

azure_auth

Microsoft Entra OAuth2 Flow

Type: oauth2
Stroom: implicit
Autorisatie-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiken

Name	Description
user_impersonation	zich voordoen als uw gebruikersaccount

Voorbeelden

Promote a read replica to a standalone server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the promotion to a standalone server.

Promote a read replica to a standalone server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the promotion to a standalone server.

Switch over a read replica to primary server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Switch over a read replica to primary server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Update an existing server to upgrade the major version of PostgreSQL database engine.

Update an existing server with custom maintenance window.

Update an existing server with data encryption based on customer managed key with automatic key version update.

Update an existing server with data encryption based on customer managed key.

Update an existing server with Microsoft Entra authentication enabled.

Update an existing server.

Promote a read replica to a standalone server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the promotion to a standalone server.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "replica": {
      "promoteMode": "Standalone",
      "promoteOption": "Forced"
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteMode;
import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteOption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Replica;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersPromoteReplicaAsForcedStandaloneServer.json
     */
    /**
     * Sample code: Promote a read replica to a standalone server with forced data synchronization. Meaning that it
     * doesn't wait for data in the read replica to be synchronized with its source server before it initiates the
     * promotion to a standalone server.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void
        promoteAReadReplicaToAStandaloneServerWithForcedDataSynchronizationMeaningThatItDoesnTWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer(
            com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withReplica(new Replica().withPromoteMode(ReadReplicaPromoteMode.STANDALONE)
            .withPromoteOption(ReadReplicaPromoteOption.FORCED)).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_promote_replica_as_forced_standalone_server.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={"properties": {"replica": {"promoteMode": "Standalone", "promoteOption": "Forced"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedStandaloneServer.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedStandaloneServer.json
 */
async function promoteAReadReplicaToAStandaloneServerWithForcedDataSynchronizationMeaningThatItDoesnTWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    replica: { promoteMode: "Standalone", promoteOption: "Forced" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Promote a read replica to a standalone server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the promotion to a standalone server.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "replica": {
      "promoteMode": "Standalone",
      "promoteOption": "Planned"
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteMode;
import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteOption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Replica;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersPromoteReplicaAsPlannedStandaloneServer.json
     */
    /**
     * Sample code: Promote a read replica to a standalone server with planned data synchronization. Meaning that it
     * waits for data in the read replica to be fully synchronized with its source server before it initiates the
     * promotion to a standalone server.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void
        promoteAReadReplicaToAStandaloneServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer(
            com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withReplica(new Replica().withPromoteMode(ReadReplicaPromoteMode.STANDALONE)
            .withPromoteOption(ReadReplicaPromoteOption.PLANNED)).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_promote_replica_as_planned_standalone_server.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={"properties": {"replica": {"promoteMode": "Standalone", "promoteOption": "Planned"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedStandaloneServer.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedStandaloneServer.json
 */
async function promoteAReadReplicaToAStandaloneServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    replica: { promoteMode: "Standalone", promoteOption: "Planned" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Switch over a read replica to primary server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "replica": {
      "promoteMode": "Switchover",
      "promoteOption": "Forced"
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteMode;
import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteOption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Replica;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersPromoteReplicaAsForcedSwitchover.json
     */
    /**
     * Sample code: Switch over a read replica to primary server with forced data synchronization. Meaning that it
     * doesn't wait for data in the read replica to be synchronized with its source server before it initiates the
     * switching of roles between the read replica and the primary server.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void
        switchOverAReadReplicaToPrimaryServerWithForcedDataSynchronizationMeaningThatItDoesnTWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer(
            com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withReplica(new Replica().withPromoteMode(ReadReplicaPromoteMode.SWITCHOVER)
            .withPromoteOption(ReadReplicaPromoteOption.FORCED)).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_promote_replica_as_forced_switchover.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={"properties": {"replica": {"promoteMode": "Switchover", "promoteOption": "Forced"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedSwitchover.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedSwitchover.json
 */
async function switchOverAReadReplicaToPrimaryServerWithForcedDataSynchronizationMeaningThatItDoesnTWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    replica: { promoteMode: "Switchover", promoteOption: "Forced" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Switch over a read replica to primary server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "replica": {
      "promoteMode": "Switchover",
      "promoteOption": "Planned"
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteMode;
import com.azure.resourcemanager.postgresqlflexibleserver.models.ReadReplicaPromoteOption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Replica;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersPromoteReplicaAsPlannedSwitchover.json
     */
    /**
     * Sample code: Switch over a read replica to primary server with planned data synchronization. Meaning that it
     * waits for data in the read replica to be fully synchronized with its source server before it initiates the
     * switching of roles between the read replica and the primary server.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void
        switchOverAReadReplicaToPrimaryServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer(
            com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withReplica(new Replica().withPromoteMode(ReadReplicaPromoteMode.SWITCHOVER)
            .withPromoteOption(ReadReplicaPromoteOption.PLANNED)).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_promote_replica_as_planned_switchover.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={"properties": {"replica": {"promoteMode": "Switchover", "promoteOption": "Planned"}}},
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedSwitchover.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedSwitchover.json
 */
async function switchOverAReadReplicaToPrimaryServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    replica: { promoteMode: "Switchover", promoteOption: "Planned" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server to upgrade the major version of PostgreSQL database engine.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "createMode": "Update",
    "version": "17"
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.PostgresMajorVersion;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersUpdateWithMajorVersionUpgrade.json
     */
    /**
     * Sample code: Update an existing server to upgrade the major version of PostgreSQL database engine.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void updateAnExistingServerToUpgradeTheMajorVersionOfPostgreSQLDatabaseEngine(
        com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withVersion(PostgresMajorVersion.ONE_SEVEN).withCreateMode(CreateModeForPatch.UPDATE).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_update_with_major_version_upgrade.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={"properties": {"createMode": "Update", "version": "17"}},
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMajorVersionUpgrade.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMajorVersionUpgrade.json
 */
async function updateAnExistingServerToUpgradeTheMajorVersionOfPostgreSqlDatabaseEngine() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = { createMode: "Update", version: "17" };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server with custom maintenance window.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "properties": {
    "createMode": "Update",
    "maintenanceWindow": {
      "customWindow": "Enabled",
      "dayOfWeek": 0,
      "startHour": 8,
      "startMinute": 0
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.MaintenanceWindowForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersUpdateWithCustomMaintenanceWindow.json
     */
    /**
     * Sample code: Update an existing server with custom maintenance window.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void updateAnExistingServerWithCustomMaintenanceWindow(
        com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withMaintenanceWindow(new MaintenanceWindowForPatch().withCustomWindow("Enabled")
            .withStartHour(8).withStartMinute(0).withDayOfWeek(0)).withCreateMode(CreateModeForPatch.UPDATE).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_update_with_custom_maintenance_window.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={
            "properties": {
                "createMode": "Update",
                "maintenanceWindow": {"customWindow": "Enabled", "dayOfWeek": 0, "startHour": 8, "startMinute": 0},
            }
        },
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithCustomMaintenanceWindow.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithCustomMaintenanceWindow.json
 */
async function updateAnExistingServerWithCustomMaintenanceWindow() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    createMode: "Update",
    maintenanceWindow: {
      customWindow: "Enabled",
      dayOfWeek: 0,
      startHour: 8,
      startMinute: 0,
    },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server with data encryption based on customer managed key with automatic key version update.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "sku": {
    "tier": "GeneralPurpose",
    "name": "Standard_D8s_v3"
  },
  "identity": {
    "userAssignedIdentities": {
      "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity": {},
      "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity": {}
    },
    "type": "UserAssigned"
  },
  "properties": {
    "administratorLoginPassword": "examplenewpassword",
    "createMode": "Update",
    "dataEncryption": {
      "type": "AzureKeyVault",
      "primaryKeyURI": "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey",
      "primaryUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
      "geoBackupKeyURI": "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey",
      "geoBackupUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity"
    },
    "backup": {
      "backupRetentionDays": 20
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.BackupForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.DataEncryption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.DataEncryptionType;
import com.azure.resourcemanager.postgresqlflexibleserver.models.IdentityType;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.UserAssignedIdentity;
import com.azure.resourcemanager.postgresqlflexibleserver.models.UserIdentity;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersUpdateWithDataEncryptionEnabledAutoUpdate.json
     */
    /**
     * Sample code: Update an existing server with data encryption based on customer managed key with automatic key
     * version update.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKeyWithAutomaticKeyVersionUpdate(
        com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withSku(new SkuForPatch().withName("Standard_D8s_v3").withTier(SkuTier.GENERAL_PURPOSE))
            .withIdentity(new UserAssignedIdentity().withUserAssignedIdentities(mapOf(
                "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
                new UserIdentity(),
                "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
                new UserIdentity())).withType(IdentityType.USER_ASSIGNED))
            .withAdministratorLoginPassword("examplenewpassword")
            .withBackup(new BackupForPatch().withBackupRetentionDays(20))
            .withDataEncryption(new DataEncryption().withPrimaryKeyUri("fakeTokenPlaceholder")
                .withPrimaryUserAssignedIdentityId(
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity")
                .withGeoBackupKeyUri("fakeTokenPlaceholder")
                .withGeoBackupUserAssignedIdentityId(
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity")
                .withType(DataEncryptionType.AZURE_KEY_VAULT))
            .withCreateMode(CreateModeForPatch.UPDATE).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_update_with_data_encryption_enabled_auto_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 = PostgreSQLManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
    )

    response = client.servers.begin_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity": {},
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity": {},
                },
            },
            "properties": {
                "administratorLoginPassword": "examplenewpassword",
                "backup": {"backupRetentionDays": 20},
                "createMode": "Update",
                "dataEncryption": {
                    "geoBackupKeyURI": "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey",
                    "geoBackupUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
                    "primaryKeyURI": "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey",
                    "primaryUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
                    "type": "AzureKeyVault",
                },
            },
            "sku": {"name": "Standard_D8s_v3", "tier": "GeneralPurpose"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabledAutoUpdate.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabledAutoUpdate.json
 */
async function updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKeyWithAutomaticKeyVersionUpdate() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    administratorLoginPassword: "examplenewpassword",
    backup: { backupRetentionDays: 20 },
    createMode: "Update",
    dataEncryption: {
      type: "AzureKeyVault",
      geoBackupKeyURI: "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey",
      geoBackupUserAssignedIdentityId:
        "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
      primaryKeyURI: "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey",
      primaryUserAssignedIdentityId:
        "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
    },
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/ffffffffFfffFfffFfffFfffffffffff/resourceGroups/exampleresourcegroup/providers/MicrosoftManagedIdentity/userAssignedIdentities/examplegeoredundantidentity":
          {},
        "/subscriptions/ffffffffFfffFfffFfffFfffffffffff/resourceGroups/exampleresourcegroup/providers/MicrosoftManagedIdentity/userAssignedIdentities/exampleprimaryidentity":
          {},
      },
    },
    sku: { name: "Standard_D8s_v3", tier: "GeneralPurpose" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server with data encryption based on customer managed key.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "sku": {
    "tier": "GeneralPurpose",
    "name": "Standard_D8s_v3"
  },
  "identity": {
    "userAssignedIdentities": {
      "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity": {},
      "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity": {}
    },
    "type": "UserAssigned"
  },
  "properties": {
    "administratorLoginPassword": "examplenewpassword",
    "createMode": "Update",
    "dataEncryption": {
      "type": "AzureKeyVault",
      "primaryKeyURI": "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "primaryUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
      "geoBackupKeyURI": "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
      "geoBackupUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity"
    },
    "backup": {
      "backupRetentionDays": 20
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.BackupForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.DataEncryption;
import com.azure.resourcemanager.postgresqlflexibleserver.models.DataEncryptionType;
import com.azure.resourcemanager.postgresqlflexibleserver.models.IdentityType;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.UserAssignedIdentity;
import com.azure.resourcemanager.postgresqlflexibleserver.models.UserIdentity;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersUpdateWithDataEncryptionEnabled.json
     */
    /**
     * Sample code: Update an existing server with data encryption based on customer managed key.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKey(
        com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withSku(new SkuForPatch().withName("Standard_D8s_v3").withTier(SkuTier.GENERAL_PURPOSE))
            .withIdentity(new UserAssignedIdentity().withUserAssignedIdentities(mapOf(
                "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
                new UserIdentity(),
                "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
                new UserIdentity())).withType(IdentityType.USER_ASSIGNED))
            .withAdministratorLoginPassword("examplenewpassword")
            .withBackup(new BackupForPatch().withBackupRetentionDays(20))
            .withDataEncryption(new DataEncryption().withPrimaryKeyUri("fakeTokenPlaceholder")
                .withPrimaryUserAssignedIdentityId(
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity")
                .withGeoBackupKeyUri("fakeTokenPlaceholder")
                .withGeoBackupUserAssignedIdentityId(
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity")
                .withType(DataEncryptionType.AZURE_KEY_VAULT))
            .withCreateMode(CreateModeForPatch.UPDATE).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_update_with_data_encryption_enabled.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={
            "identity": {
                "type": "UserAssigned",
                "userAssignedIdentities": {
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity": {},
                    "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity": {},
                },
            },
            "properties": {
                "administratorLoginPassword": "examplenewpassword",
                "backup": {"backupRetentionDays": 20},
                "createMode": "Update",
                "dataEncryption": {
                    "geoBackupKeyURI": "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
                    "geoBackupUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
                    "primaryKeyURI": "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                    "primaryUserAssignedIdentityId": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
                    "type": "AzureKeyVault",
                },
            },
            "sku": {"name": "Standard_D8s_v3", "tier": "GeneralPurpose"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabled.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabled.json
 */
async function updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKey() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    administratorLoginPassword: "examplenewpassword",
    backup: { backupRetentionDays: 20 },
    createMode: "Update",
    dataEncryption: {
      type: "AzureKeyVault",
      geoBackupKeyURI:
        "https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy",
      geoBackupUserAssignedIdentityId:
        "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity",
      primaryKeyURI:
        "https://exampleprimarykeyvault.vault.azure.net/keys/examplekey/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      primaryUserAssignedIdentityId:
        "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity",
    },
    identity: {
      type: "UserAssigned",
      userAssignedIdentities: {
        "/subscriptions/ffffffffFfffFfffFfffFfffffffffff/resourceGroups/exampleresourcegroup/providers/MicrosoftManagedIdentity/userAssignedIdentities/examplegeoredundantidentity":
          {},
        "/subscriptions/ffffffffFfffFfffFfffFfffffffffff/resourceGroups/exampleresourcegroup/providers/MicrosoftManagedIdentity/userAssignedIdentities/exampleprimaryidentity":
          {},
      },
    },
    sku: { name: "Standard_D8s_v3", tier: "GeneralPurpose" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server with Microsoft Entra authentication enabled.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "sku": {
    "tier": "GeneralPurpose",
    "name": "Standard_D8s_v3"
  },
  "properties": {
    "administratorLoginPassword": "examplenewpassword",
    "createMode": "Update",
    "authConfig": {
      "activeDirectoryAuth": "Enabled",
      "passwordAuth": "Enabled",
      "tenantId": "tttttt-tttt-tttt-tttt-tttttttttttt"
    },
    "storage": {
      "storageSizeGB": 1024,
      "autoGrow": "Disabled",
      "tier": "P30"
    },
    "backup": {
      "backupRetentionDays": 20
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.AuthConfigForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.AzureManagedDiskPerformanceTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.BackupForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.MicrosoftEntraAuth;
import com.azure.resourcemanager.postgresqlflexibleserver.models.PasswordBasedAuth;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Storage;
import com.azure.resourcemanager.postgresqlflexibleserver.models.StorageAutoGrow;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/
     * ServersUpdateWithMicrosoftEntraEnabled.json
     */
    /**
     * Sample code: Update an existing server with Microsoft Entra authentication enabled.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void updateAnExistingServerWithMicrosoftEntraAuthenticationEnabled(
        com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withSku(new SkuForPatch().withName("Standard_D8s_v3").withTier(SkuTier.GENERAL_PURPOSE))
            .withAdministratorLoginPassword("examplenewpassword")
            .withStorage(new Storage().withStorageSizeGB(1024).withAutoGrow(StorageAutoGrow.DISABLED)
                .withTier(AzureManagedDiskPerformanceTier.P30))
            .withBackup(new BackupForPatch().withBackupRetentionDays(20))
            .withAuthConfig(new AuthConfigForPatch().withActiveDirectoryAuth(MicrosoftEntraAuth.ENABLED)
                .withPasswordAuth(PasswordBasedAuth.ENABLED).withTenantId("tttttt-tttt-tttt-tttt-tttttttttttt"))
            .withCreateMode(CreateModeForPatch.UPDATE).apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_update_with_microsoft_entra_enabled.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_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={
            "properties": {
                "administratorLoginPassword": "examplenewpassword",
                "authConfig": {
                    "activeDirectoryAuth": "Enabled",
                    "passwordAuth": "Enabled",
                    "tenantId": "tttttt-tttt-tttt-tttt-tttttttttttt",
                },
                "backup": {"backupRetentionDays": 20},
                "createMode": "Update",
                "storage": {"autoGrow": "Disabled", "storageSizeGB": 1024, "tier": "P30"},
            },
            "sku": {"name": "Standard_D8s_v3", "tier": "GeneralPurpose"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMicrosoftEntraEnabled.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMicrosoftEntraEnabled.json
 */
async function updateAnExistingServerWithMicrosoftEntraAuthenticationEnabled() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    administratorLoginPassword: "examplenewpassword",
    authConfig: {
      activeDirectoryAuth: "Enabled",
      passwordAuth: "Enabled",
      tenantId: "tttttt-tttt-tttt-tttt-tttttttttttt",
    },
    backup: { backupRetentionDays: 20 },
    createMode: "Update",
    sku: { name: "Standard_D8s_v3", tier: "GeneralPurpose" },
    storage: { autoGrow: "Disabled", storageSizeGB: 1024, tier: "P30" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Update an existing server.

Voorbeeldaanvraag

PATCH https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.DBforPostgreSQL/flexibleServers/exampleserver?api-version=2025-08-01

{
  "sku": {
    "tier": "GeneralPurpose",
    "name": "Standard_D8s_v3"
  },
  "properties": {
    "administratorLoginPassword": "examplenewpassword",
    "createMode": "Update",
    "storage": {
      "storageSizeGB": 1024,
      "autoGrow": "Enabled",
      "tier": "P30"
    },
    "backup": {
      "backupRetentionDays": 20
    }
  }
}


import com.azure.resourcemanager.postgresqlflexibleserver.models.AzureManagedDiskPerformanceTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.BackupForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.CreateModeForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Server;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuForPatch;
import com.azure.resourcemanager.postgresqlflexibleserver.models.SkuTier;
import com.azure.resourcemanager.postgresqlflexibleserver.models.Storage;
import com.azure.resourcemanager.postgresqlflexibleserver.models.StorageAutoGrow;
import java.util.HashMap;
import java.util.Map;

/**
 * Samples for Servers Update.
 */
public final class Main {
    /*
     * x-ms-original-file:
     * specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdate.json
     */
    /**
     * Sample code: Update an existing server.
     * 
     * @param manager Entry point to PostgreSqlManager.
     */
    public static void
        updateAnExistingServer(com.azure.resourcemanager.postgresqlflexibleserver.PostgreSqlManager manager) {
        Server resource = manager.servers()
            .getByResourceGroupWithResponse("exampleresourcegroup", "exampleserver", com.azure.core.util.Context.NONE)
            .getValue();
        resource.update().withSku(new SkuForPatch().withName("Standard_D8s_v3").withTier(SkuTier.GENERAL_PURPOSE))
            .withAdministratorLoginPassword("examplenewpassword")
            .withStorage(new Storage().withStorageSizeGB(1024).withAutoGrow(StorageAutoGrow.ENABLED)
                .withTier(AzureManagedDiskPerformanceTier.P30))
            .withBackup(new BackupForPatch().withBackupRetentionDays(20)).withCreateMode(CreateModeForPatch.UPDATE)
            .apply();
    }

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

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

from azure.identity import DefaultAzureCredential

from azure.mgmt.postgresqlflexibleservers import PostgreSQLManagementClient

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-postgresqlflexibleservers
# USAGE
    python servers_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 = PostgreSQLManagementClient(
        credential=DefaultAzureCredential(),
        subscription_id="ffffffff-ffff-ffff-ffff-ffffffffffff",
    )

    response = client.servers.begin_update(
        resource_group_name="exampleresourcegroup",
        server_name="exampleserver",
        parameters={
            "properties": {
                "administratorLoginPassword": "examplenewpassword",
                "backup": {"backupRetentionDays": 20},
                "createMode": "Update",
                "storage": {"autoGrow": "Enabled", "storageSizeGB": 1024, "tier": "P30"},
            },
            "sku": {"name": "Standard_D8s_v3", "tier": "GeneralPurpose"},
        },
    ).result()
    print(response)


# x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdate.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

const { PostgreSQLManagementFlexibleServerClient } = require("@azure/arm-postgresql-flexible");
const { DefaultAzureCredential } = require("@azure/identity");
require("dotenv/config");

/**
 * This sample demonstrates how to Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 *
 * @summary Updates an existing server. The request body can contain one or multiple of the properties present in the normal server definition.
 * x-ms-original-file: specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdate.json
 */
async function updateAnExistingServer() {
  const subscriptionId =
    process.env["POSTGRESQL_SUBSCRIPTION_ID"] || "ffffffff-ffff-ffff-ffff-ffffffffffff";
  const resourceGroupName = process.env["POSTGRESQL_RESOURCE_GROUP"] || "exampleresourcegroup";
  const serverName = "exampleserver";
  const parameters = {
    administratorLoginPassword: "examplenewpassword",
    backup: { backupRetentionDays: 20 },
    createMode: "Update",
    sku: { name: "Standard_D8s_v3", tier: "GeneralPurpose" },
    storage: { autoGrow: "Enabled", storageSizeGB: 1024, tier: "P30" },
  };
  const credential = new DefaultAzureCredential();
  const client = new PostgreSQLManagementFlexibleServerClient(credential, subscriptionId);
  const result = await client.servers.beginUpdateAndWait(resourceGroupName, serverName, parameters);
  console.log(result);
}

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

Voorbeeldrespons

Statuscode:: 202

Azure-AsyncOperation: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/azureAsyncOperation/aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa?api-version=2025-06-01-preview
Location: https://management.azure.com/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/providers/Microsoft.DBforPostgreSQL/locations/eastus/operationResults/bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb?api-version=2025-06-01-preview

Definities

Name	Description
AuthConfigForPatch	Configuratie-eigenschappen voor verificatie van een server.
AzureManagedDiskPerformanceTier	Opslaglaag van een server.
BackupForPatch	Back-upeigenschappen van een server.
Cluster	Clustereigenschappen van een server.
CreateModeForPatch	Updatemodus van een bestaande server.
DataEncryption	Eigenschappen van gegevensversleuteling van een server.
DataEncryptionType	Het type gegevensversleuteling dat door een server wordt gebruikt.
EncryptionKeyStatus	Status van de sleutel die wordt gebruikt door een server die is geconfigureerd met gegevensversleuteling op basis van een door de klant beheerde sleutel om de primaire opslag te versleutelen die aan de server is gekoppeld.
ErrorAdditionalInfo	Aanvullende informatie over de resourcebeheerfout.
ErrorDetail	De foutdetails.
ErrorResponse	Foutreactie
GeographicallyRedundantBackup	Geeft aan of de server is geconfigureerd voor het maken van geografisch redundante back-ups.
HighAvailabilityForPatch	Eigenschappen van hoge beschikbaarheid van een server.
HighAvailabilityMode	Modus voor hoge beschikbaarheid voor een server.
HighAvailabilityState	Mogelijke statussen van de stand-byserver die zijn gemaakt wanneer hoge beschikbaarheid is ingesteld op SameZone of ZoneRedundant.
IdentityType	Typen identiteiten die aan een server zijn gekoppeld.
MaintenanceWindowForPatch	Eigenschappen van een onderhoudsvenster van een server.
MicrosoftEntraAuth	Geeft aan of de server Microsoft Entra-verificatie ondersteunt.
Network	Netwerkeigenschappen van een server.
PasswordBasedAuth	Geeft aan of de server verificatie op basis van een wachtwoord ondersteunt.
PostgresMajorVersion	Primaire versie van de PostgreSQL-database-engine.
ReadReplicaPromoteMode	Type bewerking die op de gelezen replica moet worden toegepast. Deze eigenschap is alleen geschreven. Standalone betekent dat de gelezen replica wordt gepromoveerd tot een standalone server en een volledig onafhankelijke entiteit wordt van de replicatieset. Omschakeling betekent dat de gelezen replica rollen krijgt met de primaire server.
ReadReplicaPromoteOption	Optie voor gegevenssynchronisatie die u kunt gebruiken bij het verwerken van de bewerking die is opgegeven in de eigenschap promoteMode. Deze eigenschap is alleen geschreven.
Replica	Replica-eigenschappen van een server.
ReplicationRole	Rol van de server in een replicatieset.
ReplicationState	Geeft de replicatiestatus van een gelezen replica aan. Deze eigenschap wordt alleen geretourneerd als de doelserver een leesreplica is. Mogelijke waarden zijn Actief, Verbroken, Inhalen, Inrichting, Herconfigureren en Bijwerken
ServerForPatch	Vertegenwoordigt een server die moet worden bijgewerkt.
ServerPublicNetworkAccessState	Geeft aan of openbare netwerktoegang is ingeschakeld of niet. Dit wordt alleen ondersteund voor servers die niet zijn geïntegreerd in een virtueel netwerk dat eigendom is van en wordt geleverd door de klant wanneer de server wordt geïmplementeerd.
SkuForPatch	Bereken informatie van een server.
SkuTier	Laag van de rekenkracht die aan een server is toegewezen.
Storage	Opslageigenschappen van een server.
StorageAutoGrow	Markeren om de automatische groei van de opslagruimte van een server in of uit te schakelen wanneer de beschikbare ruimte bijna nul is en de voorwaarden toestaan dat de opslagruimte automatisch wordt vergroot.
StorageType	Type opslag dat aan een server is toegewezen. Toegestane waarden zijn Premium_LRS, PremiumV2_LRS of UltraSSD_LRS. Als dit niet is opgegeven, staat het standaard op Premium_LRS.
UserAssignedIdentity	Identiteiten die aan een server zijn gekoppeld.
UserIdentity	Door de gebruiker toegewezen beheerde identiteit die is gekoppeld aan een server.

AuthConfigForPatch

Object

Configuratie-eigenschappen voor verificatie van een server.

Name	Type	Description
activeDirectoryAuth	MicrosoftEntraAuth	Geeft aan of de server Microsoft Entra-verificatie ondersteunt.
passwordAuth	PasswordBasedAuth	Geeft aan of de server verificatie op basis van een wachtwoord ondersteunt.
tenantId	string	Id van de tenant van de gedelegeerde resource.

AzureManagedDiskPerformanceTier

Opsomming

Opslaglaag van een server.

Waarde	Description
P1	SSD op instapniveau voor minimale IOPS, ideaal voor lichte ontwikkelings- of testworkloads.
P2	Iets hogere IOPS voor kleinschalige applicaties die een consistente lage latentie nodig hebben.
P3	Uitgebalanceerde prestaties voor basisproductieworkloads met matige doorvoer.
P4	Verbeterde IOPS voor groeiende apps met voorspelbare prestatiebehoeften.
P6	Mid-tier SSD voor stabiele workloads die betrouwbare doorvoer en latentie vereisen.
P10	Populaire keuze voor algemene productieworkloads met schaalbare prestaties.
P15	Hoge IOPS-laag voor veeleisende apps met frequente lees-/schrijfbewerkingen.
P20	Toegangspunt voor krachtige Solid State Disks (SSD's), geschikt voor kleinschalige I/O-intensieve workloads.
P30	Uitgebalanceerde laag voor matige doorvoer en latentiegevoelige toepassingen.
P40	Verbeterde prestaties voor groeiende productieworkloads met consistente IOPS-vereisten.
P50	Geoptimaliseerd voor toepassingen op bedrijfsniveau die een aanhoudend hoge doorvoer vereisen.
P60	Laag met hoge capaciteit voor grote databases en analyseworkloads met verhoogde IOPS.
P70	Ontworpen voor bedrijfskritische systemen die ultralage latentie en hoge gelijktijdigheid vereisen.
P80	SSD van het hoogste niveau voor maximale IOPS en doorvoer, ideaal voor de meest veeleisende workloads.

BackupForPatch

Object

Back-upeigenschappen van een server.

Name	Type	Description
backupRetentionDays	integer (int32)	Bewaardagen voor back-ups voor de server.
earliestRestoreDate	string (date-time)	Vroegste herstelpunttijd (ISO8601 formaat) voor een server.
geoRedundantBackup	GeographicallyRedundantBackup	Geeft aan of de server is geconfigureerd voor het maken van geografisch redundante back-ups.

Cluster

Object

Clustereigenschappen van een server.

Name	Type	Default value	Description
clusterSize	integer (int32)	0	Aantal knooppunten toegewezen aan de elastische cluster.
defaultDatabaseName	string		Standaarddatabasenaam voor het elastische cluster.

CreateModeForPatch

Opsomming

Updatemodus van een bestaande server.

Waarde	Description
Default	Dit komt overeen met 'Update'.
Update	Bewerking werkt een bestaande server bij.

DataEncryption

Object

Eigenschappen van gegevensversleuteling van een server.

Name	Type	Description
geoBackupEncryptionKeyStatus	EncryptionKeyStatus	Status van de sleutel die wordt gebruikt door een server die is geconfigureerd met gegevensversleuteling op basis van een door de klant beheerde sleutel, om de geografisch redundante opslag te versleutelen die aan de server is gekoppeld wanneer deze is geconfigureerd om geografisch redundante back-ups te ondersteunen.
geoBackupKeyURI	string	Id van de door de gebruiker toegewezen beheerde identiteit die wordt gebruikt om toegang te krijgen tot de sleutel in Azure Key Vault voor gegevensversleuteling van de geografisch redundante opslag die is gekoppeld aan een server die is geconfigureerd voor ondersteuning van geografisch redundante back-ups.
geoBackupUserAssignedIdentityId	string	Id van de door de gebruiker toegewezen beheerde identiteit die wordt gebruikt om toegang te krijgen tot de sleutel in Azure Key Vault voor gegevensversleuteling van de geografisch redundante opslag die is gekoppeld aan een server die is geconfigureerd voor ondersteuning van geografisch redundante back-ups.
primaryEncryptionKeyStatus	EncryptionKeyStatus	Status van de sleutel die wordt gebruikt door een server die is geconfigureerd met gegevensversleuteling op basis van een door de klant beheerde sleutel om de primaire opslag te versleutelen die aan de server is gekoppeld.
primaryKeyURI	string	URI van de sleutel in Azure Key Vault die wordt gebruikt voor gegevensversleuteling van de primaire opslag die aan een server is gekoppeld.
primaryUserAssignedIdentityId	string	Id van de aan de gebruiker toegewezen beheerde identiteit die wordt gebruikt om toegang te krijgen tot de sleutel in Azure Key Vault voor gegevensversleuteling van de primaire opslag die aan een server is gekoppeld.
type	DataEncryptionType	Het type gegevensversleuteling dat door een server wordt gebruikt.

DataEncryptionType

Opsomming

Het type gegevensversleuteling dat door een server wordt gebruikt.

Waarde	Description
SystemManaged	Versleuteling beheerd door Azure met behulp van door het platform beheerde sleutels voor eenvoud en naleving.
AzureKeyVault	Versleuteling met behulp van door de klant beheerde sleutels die zijn opgeslagen in Azure Key Vault voor verbeterde controle en beveiliging.

EncryptionKeyStatus

Opsomming

Status van de sleutel die wordt gebruikt door een server die is geconfigureerd met gegevensversleuteling op basis van een door de klant beheerde sleutel om de primaire opslag te versleutelen die aan de server is gekoppeld.

Waarde	Description
Valid	De sleutel is geldig en kan worden gebruikt voor codering.
Invalid	De sleutel is ongeldig en kan niet worden gebruikt voor versleuteling. Mogelijke oorzaken zijn het verwijderen van sleutels, wijzigingen in machtigingen, het uitschakelen van de sleutel, het sleuteltype dat niet wordt ondersteund of de huidige datum die buiten de geldigheidsperiode valt die aan de sleutel is gekoppeld.

ErrorAdditionalInfo

Object

Aanvullende informatie over de resourcebeheerfout.

Name	Type	Description
info	object	De aanvullende informatie.
type	string	Het extra informatietype.

ErrorDetail

Object

De foutdetails.

Name	Type	Description
additionalInfo	ErrorAdditionalInfo[]	De fout bevat aanvullende informatie.
code	string	De foutcode.
details	ErrorDetail[]	De foutdetails.
message	string	Het foutbericht.
target	string	Het foutdoel.

ErrorResponse

Object

Foutreactie

Name	Type	Description
error	ErrorDetail	Het foutobject.

GeographicallyRedundantBackup

Opsomming

Geeft aan of de server is geconfigureerd voor het maken van geografisch redundante back-ups.

Waarde	Description
Enabled	De server is geconfigureerd om geografisch redundante back-ups te maken.
Disabled	De server is niet geconfigureerd voor het maken van geografisch redundante back-ups.

HighAvailabilityForPatch

Object

Eigenschappen van hoge beschikbaarheid van een server.

Name	Type	Description
mode	HighAvailabilityMode	Modus voor hoge beschikbaarheid voor een server.
standbyAvailabilityZone	string	Beschikbaarheidszone die is gekoppeld aan de stand-byserver die is gemaakt wanneer hoge beschikbaarheid is ingesteld op SameZone of ZoneRedundant.
state	HighAvailabilityState	Mogelijke statussen van de stand-byserver die zijn gemaakt wanneer hoge beschikbaarheid is ingesteld op SameZone of ZoneRedundant.

HighAvailabilityMode

Opsomming

Modus voor hoge beschikbaarheid voor een server.

Waarde	Description
Disabled	Hoge beschikbaarheid is uitgeschakeld voor de server.
ZoneRedundant	Hoge beschikbaarheid is ingeschakeld voor de server, met stand-byserver in een andere beschikbaarheidszone dan die van de primaire server.
SameZone	Hoge beschikbaarheid is ingeschakeld voor de server, met stand-byserver in dezelfde beschikbaarheidszone als de primaire server.

HighAvailabilityState

Opsomming

Mogelijke statussen van de stand-byserver die zijn gemaakt wanneer hoge beschikbaarheid is ingesteld op SameZone of ZoneRedundant.

Waarde	Description
NotEnabled	Hoge beschikbaarheid is niet ingeschakeld voor de server.
CreatingStandby	Er wordt een stand-byserver gemaakt.
ReplicatingData	Gegevens worden gerepliceerd naar de stand-byserver.
FailingOver	De failover-bewerking naar de stand-byserver is aan de gang.
Healthy	De stand-byserver is gezond en klaar om het over te nemen in geval van een failover.
RemovingStandby	De stand-byserver wordt verwijderd.

IdentityType

Opsomming

Typen identiteiten die aan een server zijn gekoppeld.

Waarde	Description
None	Er is geen beheerde identiteit toegewezen aan de server.
UserAssigned	Een of meer beheerde identiteiten die door de gebruiker worden opgegeven, worden toegewezen aan de server.
SystemAssigned	Azure maakt en beheert automatisch de identiteit die is gekoppeld aan de levenscyclus van de server.
SystemAssigned,UserAssigned	Zowel door het systeem toegewezen als door de gebruiker toegewezen identiteiten worden aan de server toegewezen.

MaintenanceWindowForPatch

Object

Eigenschappen van een onderhoudsvenster van een server.

Name	Type	Description
customWindow	string	Geeft aan of een aangepast venster is in- of uitgeschakeld.
dayOfWeek	integer (int32)	Dag van de week te gebruiken voor onderhoudsvenster.
startHour	integer (int32)	Startuur te gebruiken voor onderhoudsvenster.
startMinute	integer (int32)	Startminuut te gebruiken voor onderhoudsvenster.

MicrosoftEntraAuth

Opsomming

Geeft aan of de server Microsoft Entra-verificatie ondersteunt.

Waarde	Description
Enabled	Server ondersteunt Microsoft Entra-verificatie.
Disabled	Server biedt geen ondersteuning voor Microsoft Entra-verificatie.

Network

Object

Netwerkeigenschappen van een server.

Name	Type	Description
delegatedSubnetResourceId	string	Bron-ID van het gedelegeerde subnet. Vereist tijdens het maken van een nieuwe server, voor het geval u wilt dat de server wordt geïntegreerd in uw eigen virtuele netwerk. Voor een updatebewerking hoeft u deze eigenschap alleen op te geven als u de waarde wilt wijzigen die is toegewezen voor de privé-DNS-zone.
privateDnsZoneArmResourceId	string	Identificatie van de privé-DNS-zone. Vereist tijdens het maken van een nieuwe server, voor het geval u wilt dat de server wordt geïntegreerd in uw eigen virtuele netwerk. Voor een updatebewerking hoeft u deze eigenschap alleen op te geven als u de waarde wilt wijzigen die is toegewezen voor de privé-DNS-zone.
publicNetworkAccess	ServerPublicNetworkAccessState	Geeft aan of openbare netwerktoegang is ingeschakeld of niet. Dit wordt alleen ondersteund voor servers die niet zijn geïntegreerd in een virtueel netwerk dat eigendom is van en wordt geleverd door de klant wanneer de server wordt geïmplementeerd.

PasswordBasedAuth

Opsomming

Geeft aan of de server verificatie op basis van een wachtwoord ondersteunt.

Waarde	Description
Enabled	De server ondersteunt verificatie op basis van wachtwoorden.
Disabled	De server biedt geen ondersteuning voor verificatie op basis van wachtwoorden.

PostgresMajorVersion

Opsomming

Primaire versie van de PostgreSQL-database-engine.

Waarde	Description
18	PostgreSQL 18.
17	PostgreSQL 17.
16	PostgreSQL 16.
15	PostgreSQL 15.
14	PostgreSQL 14.
13	PostgreSQL 13.
12	PostgreSQL 12.
11	PostgreSQL 11.

ReadReplicaPromoteMode

Opsomming

Type bewerking die op de gelezen replica moet worden toegepast. Deze eigenschap is alleen geschreven. Standalone betekent dat de gelezen replica wordt gepromoveerd tot een standalone server en een volledig onafhankelijke entiteit wordt van de replicatieset. Omschakeling betekent dat de gelezen replica rollen krijgt met de primaire server.

Waarde	Description
Standalone	Read replica wordt een onafhankelijke server.
Switchover	Read replica wisselt rollen met de primaire server.

ReadReplicaPromoteOption

Opsomming

Optie voor gegevenssynchronisatie die u kunt gebruiken bij het verwerken van de bewerking die is opgegeven in de eigenschap promoteMode. Deze eigenschap is alleen geschreven.

Waarde	Description
Planned	De bewerking wacht tot de gegevens in de leesreplica volledig zijn gesynchroniseerd met de bronserver, voordat de bewerking wordt gestart.
Forced	De bewerking wacht niet tot de gegevens in de leesreplica zijn gesynchroniseerd met de bronserver voordat de bewerking wordt gestart.

Replica

Object

Replica-eigenschappen van een server.

Name	Type	Description
capacity	integer (int32)	Maximaal aantal leesreplica's dat is toegestaan voor een server.
promoteMode	ReadReplicaPromoteMode	Type bewerking die op de gelezen replica moet worden toegepast. Deze eigenschap is alleen geschreven. Standalone betekent dat de gelezen replica wordt gepromoveerd tot een standalone server en een volledig onafhankelijke entiteit wordt van de replicatieset. Omschakeling betekent dat de gelezen replica rollen krijgt met de primaire server.
promoteOption	ReadReplicaPromoteOption	Optie voor gegevenssynchronisatie die u kunt gebruiken bij het verwerken van de bewerking die is opgegeven in de eigenschap promoteMode. Deze eigenschap is alleen geschreven.
replicationState	ReplicationState	Geeft de replicatiestatus van een gelezen replica aan. Deze eigenschap wordt alleen geretourneerd als de doelserver een leesreplica is. Mogelijke waarden zijn Actief, Verbroken, Inhalen, Inrichting, Herconfigureren en Bijwerken
role	ReplicationRole	Rol van de server in een replicatieset.

ReplicationRole

Opsomming

Rol van de server in een replicatieset.

Waarde	Description
None	Er is geen replicatierol toegewezen; De server werkt onafhankelijk.
Primary	Fungeert als de bronserver voor replicatie naar een of meer replica's.
AsyncReplica	Ontvangt asynchroon gegevens van een primaire server binnen dezelfde regio.
GeoAsyncReplica	Ontvangt asynchroon gegevens van een primaire server in een andere regio voor geografische redundantie.

ReplicationState

Opsomming

Geeft de replicatiestatus van een gelezen replica aan. Deze eigenschap wordt alleen geretourneerd als de doelserver een leesreplica is. Mogelijke waarden zijn Actief, Verbroken, Inhalen, Inrichting, Herconfigureren en Bijwerken

Waarde	Description
Active	Leesreplica is volledig gesynchroniseerde en actief replicerende gegevens van de primaire server.
Catchup	Read replica bevindt zich achter de primaire server en is momenteel bezig met het inhalen van wijzigingen die in behandeling zijn.
Provisioning	De leesreplica wordt gemaakt en wordt momenteel geïnitialiseerd.
Updating	Read replica ondergaat enkele wijzigingen, het kan de rekengrootte veranderen door deze te promoveren naar de primaire server.
Broken	De replicatie is mislukt of onderbroken.
Reconfiguring	Leesreplica wordt opnieuw geconfigureerd, mogelijk als gevolg van wijzigingen in de bron of instellingen.

ServerForPatch

Object

Vertegenwoordigt een server die moet worden bijgewerkt.

Name	Type	Description
identity	UserAssignedIdentity	Beschrijft de identiteit van de toepassing.
properties.administratorLogin	string	Naam van de login die is aangewezen als de eerste beheerder op basis van een wachtwoord die is toegewezen aan uw exemplaar van PostgreSQL. Moet worden opgegeven wanneer u verificatie op basis van een wachtwoord voor de eerste keer inschakelt op een server. Eenmaal ingesteld op een bepaalde waarde, kan deze niet meer worden gewijzigd voor de rest van de levensduur van een server. Als u verificatie op basis van een wachtwoord uitschakelt op een server waarop deze is ingeschakeld, wordt deze op wachtwoord gebaseerde rol niet verwijderd.
properties.administratorLoginPassword	string (password)	Wachtwoord toegewezen aan de beheerderslogin. Zolang wachtwoordverificatie is ingeschakeld, kan dit wachtwoord op elk moment worden gewijzigd.
properties.authConfig	AuthConfigForPatch	Configuratie-eigenschappen voor verificatie van een server.
properties.availabilityZone	string	Beschikbaarheidszone van een server.
properties.backup	BackupForPatch	Back-upeigenschappen van een server.
properties.cluster	Cluster	Clustereigenschappen van een server.
properties.createMode	CreateModeForPatch	Updatemodus van een bestaande server.
properties.dataEncryption	DataEncryption	Eigenschappen van gegevensversleuteling van een server.
properties.highAvailability	HighAvailabilityForPatch	Eigenschappen van hoge beschikbaarheid van een server.
properties.maintenanceWindow	MaintenanceWindowForPatch	Eigenschappen van een onderhoudsvenster van een server.
properties.network	Network	Netwerkeigenschappen van een server. Alleen nodig als u wilt dat uw server wordt geïntegreerd in een virtueel netwerk dat door de klant wordt aangeboden.
properties.replica	Replica	Lees replica-eigenschappen van een server. Alleen vereist als u een server wilt promoten.
properties.replicationRole	ReplicationRole	Rol van de server in een replicatieset.
properties.storage	Storage	Opslageigenschappen van een server.
properties.version	PostgresMajorVersion	Primaire versie van de PostgreSQL-database-engine.
sku	SkuForPatch	Rekenlaag en grootte van een server.
tags	object	Toepassingsspecifieke metagegevens in de vorm van sleutel-waardeparen.

ServerPublicNetworkAccessState

Opsomming

Geeft aan of openbare netwerktoegang is ingeschakeld of niet. Dit wordt alleen ondersteund voor servers die niet zijn geïntegreerd in een virtueel netwerk dat eigendom is van en wordt geleverd door de klant wanneer de server wordt geïmplementeerd.

Waarde	Description
Enabled	Toegang tot het openbare netwerk is ingeschakeld. Hierdoor kan de server worden benaderd vanaf het openbare internet, op voorwaarde dat de benodigde firewallregel aanwezig is die inkomend verkeer van de verbindende client toestaat. Dit is compatibel met het gebruik van privé-eindpunten om verbinding te maken met deze server.
Disabled	Openbare netwerktoegang is uitgeschakeld. Dit betekent dat de server niet toegankelijk is vanaf het openbare internet, maar alleen via private endpoints.

SkuForPatch

Object

Bereken informatie van een server.

Name	Type	Description
name	string	Naam waaronder een bepaalde rekengrootte bekend is die aan een server is toegewezen.
tier	SkuTier	Laag van de rekenkracht die aan een server is toegewezen.

SkuTier

Opsomming

Laag van de rekenkracht die aan een server is toegewezen.

Waarde	Description
Burstable	Kosteneffectieve laag voor onregelmatig CPU-gebruik, ideaal voor het ontwikkelen en testen van workloads met lage prestatievereisten.
GeneralPurpose	Gebalanceerde rekenkracht en geheugen voor de meeste workloads, met schaalbare prestaties en I/O-doorvoer.
MemoryOptimized	Hoge geheugen-tot-coreverhouding voor veeleisende workloads die snelle in-memory verwerking en hoge gelijktijdigheid vereisen.

Storage

Object

Opslageigenschappen van een server.

Name	Type	Description
autoGrow	StorageAutoGrow	Markeren om de automatische groei van de opslagruimte van een server in of uit te schakelen wanneer de beschikbare ruimte bijna nul is en de voorwaarden toestaan dat de opslagruimte automatisch wordt vergroot.
iops	integer (int32)	Maximale IOPS ondersteund voor opslag. Vereist wanneer het type opslag PremiumV2_LRS of UltraSSD_LRS is.
storageSizeGB	integer (int32)	Grootte van de opslagruimte die aan een server is toegewezen.
throughput	integer (int32)	Maximale doorvoer ondersteund voor opslag. Vereist wanneer het type opslag PremiumV2_LRS of UltraSSD_LRS is.
tier	AzureManagedDiskPerformanceTier	Opslaglaag van een server.
type	StorageType	Type opslag dat aan een server is toegewezen. Toegestane waarden zijn Premium_LRS, PremiumV2_LRS of UltraSSD_LRS. Als dit niet is opgegeven, staat het standaard op Premium_LRS.

StorageAutoGrow

Opsomming

Markeren om de automatische groei van de opslagruimte van een server in of uit te schakelen wanneer de beschikbare ruimte bijna nul is en de voorwaarden toestaan dat de opslagruimte automatisch wordt vergroot.

Waarde	Description
Enabled	De server moet de opslagruimte automatisch vergroten wanneer de beschikbare ruimte bijna nul is en de omstandigheden het mogelijk maken om de opslagruimte automatisch te vergroten.
Disabled	De server mag de opslagruimte niet automatisch vergroten wanneer de beschikbare ruimte bijna nul is.

StorageType

Opsomming

Type opslag dat aan een server is toegewezen. Toegestane waarden zijn Premium_LRS, PremiumV2_LRS of UltraSSD_LRS. Als dit niet is opgegeven, staat het standaard op Premium_LRS.

Waarde	Description
Premium_LRS	Standaard opslag met SSD-back-up (Solid State Disk) die consistente prestaties biedt voor algemene workloads.
PremiumV2_LRS	Solid State Disk (SSD)-opslag van de volgende generatie met verbeterde schaalbaarheid en prestaties voor veeleisende bedrijfsworkloads.
UltraSSD_LRS	Hoogwaardige Solid State Disk (SSD)-opslag, ontworpen voor extreme IOPS- en latentiegevoelige toepassingen.

UserAssignedIdentity

Object

Identiteiten die aan een server zijn gekoppeld.

Name	Type	Description
principalId	string	Id van het object van de service-principal die is gekoppeld aan de gebruiker waaraan de beheerde identiteit is toegewezen.
tenantId	string	Identificatie van de tenant van een server.
type	IdentityType	Typen identiteiten die aan een server zijn gekoppeld.
userAssignedIdentities	<string, UserIdentity>	Toewijzing van door de gebruiker toegewezen beheerde identiteiten.

UserIdentity

Object

Door de gebruiker toegewezen beheerde identiteit die is gekoppeld aan een server.

Name	Type	Description
clientId	string	Id van de client van de service-principal die is gekoppeld aan de gebruiker waaraan de beheerde identiteit is toegewezen.
principalId	string	Id van het object van de service-principal die is gekoppeld aan de gebruiker waaraan de beheerde identiteit is toegewezen.

Delen via

Servers - Update

URI-parameters

Aanvraagbody

Antwoorden

Beveiliging

azure_auth

Bereiken

Voorbeelden

Promote a read replica to a standalone server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the promotion to a standalone server.

Voorbeeldaanvraag

Voorbeeldrespons

Promote a read replica to a standalone server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the promotion to a standalone server.

Voorbeeldaanvraag

Voorbeeldrespons

Switch over a read replica to primary server with forced data synchronization. Meaning that it doesn't wait for data in the read replica to be synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Voorbeeldaanvraag

Voorbeeldrespons

Switch over a read replica to primary server with planned data synchronization. Meaning that it waits for data in the read replica to be fully synchronized with its source server before it initiates the switching of roles between the read replica and the primary server.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server to upgrade the major version of PostgreSQL database engine.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server with custom maintenance window.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server with data encryption based on customer managed key with automatic key version update.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server with data encryption based on customer managed key.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server with Microsoft Entra authentication enabled.

Voorbeeldaanvraag

Voorbeeldrespons

Update an existing server.

Voorbeeldaanvraag

Voorbeeldrespons

Definities

AuthConfigForPatch

AzureManagedDiskPerformanceTier

BackupForPatch

Cluster

CreateModeForPatch

DataEncryption

DataEncryptionType

EncryptionKeyStatus

ErrorAdditionalInfo

ErrorDetail

ErrorResponse

GeographicallyRedundantBackup

HighAvailabilityForPatch

HighAvailabilityMode

HighAvailabilityState

IdentityType

MaintenanceWindowForPatch

MicrosoftEntraAuth

Network

PasswordBasedAuth

PostgresMajorVersion

ReadReplicaPromoteMode

ReadReplicaPromoteOption

Replica

ReplicationRole

ReplicationState

ServerForPatch

ServerPublicNetworkAccessState

SkuForPatch

SkuTier

Storage

StorageAutoGrow

StorageType

UserAssignedIdentity

UserIdentity