Servers - Update

Dienst:: PostgreSQL

API-Version:: 2025-08-01

Aktualisiert einen vorhandenen Server. Der Anforderungstext kann eine oder mehrere der Eigenschaften enthalten, die in der normalen Serverdefinition vorhanden sind.

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

URI-Parameter

Name	In	Erforderlich	Typ	Beschreibung
resourceGroupName	path	True	string minLength: 1 maxLength: 90	Der Name der Ressourcengruppe. Bei dem Namen wird die Groß-/Kleinschreibung nicht beachtet.
serverName	path	True	string minLength: 3 maxLength: 63 pattern: ^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*	Name des Servers
subscriptionId	path	True	string (uuid)	Die ID des Zielabonnements. Der Wert muss eine UUID sein.
api-version	query	True	string minLength: 1	Hierbei handelt es sich um die für diesen Vorgang zu verwendende API-Version.

Anforderungstext

Name	Typ	Beschreibung
identity	UserAssignedIdentity	Beschreibt die Identität der Anwendung.
properties.administratorLoginPassword	string (password)	Passwort, das dem Administrator-Login zugewiesen ist. Solange die Passwortauthentifizierung aktiviert ist, kann dieses Passwort jederzeit geändert werden.
properties.authConfig	AuthConfigForPatch	Authentifizierungskonfigurationseigenschaften eines Servers.
properties.availabilityZone	string	Verfügbarkeitszone eines Servers.
properties.backup	BackupForPatch	Sicherungseigenschaften eines Servers.
properties.cluster	Cluster	Clustereigenschaften eines Servers.
properties.createMode	CreateModeForPatch	Aktualisierungsmodus eines vorhandenen Servers.
properties.dataEncryption	DataEncryption	Datenverschlüsselungseigenschaften eines Servers.
properties.highAvailability	HighAvailabilityForPatch	Eigenschaften mit hoher Verfügbarkeit eines Servers.
properties.maintenanceWindow	MaintenanceWindowForPatch	Wartungsfenstereigenschaften eines Servers.
properties.network	Network	Netzwerkeigenschaften eines Servers. Nur erforderlich, wenn der Server in ein vom Kunden bereitgestelltes virtuelles Netzwerk integriert werden soll.
properties.replica	Replica	Lesen Sie die Replikateigenschaften eines Servers. Nur erforderlich, wenn Sie einen Server heraufstufen möchten.
properties.replicationRole	ReplicationRole	Rolle des Servers in einer Replikationsgruppe.
properties.storage	Storage	Speichereigenschaften eines Servers.
properties.version	PostgresMajorVersion	Hauptversion der PostgreSQL-Datenbank-Engine.
sku	SkuForPatch	Computeebene und -größe eines Servers.
tags	object	Anwendungsspezifische Metadaten in Form von Schlüsselwertpaaren.

Antworten

Name	Typ	Beschreibung
202 Accepted		Ressourcenvorgang akzeptiert. Header Azure-AsyncOperation: string Location: string Retry-After: integer
Other Status Codes	ErrorResponse	Unerwartete Fehlerantwort.

Name

Typ

Beschreibung

202 Accepted

Ressourcenvorgang akzeptiert.

Header

Azure-AsyncOperation: string
Location: string
Retry-After: integer

Other Status Codes

ErrorResponse

Unerwartete Fehlerantwort.

Sicherheit

azure_auth

Azure Active Directory OAuth2-Fluss.

Typ: oauth2
Ablauf: implicit
Autorisierungs-URL: https://login.microsoftonline.com/common/oauth2/authorize

Bereiche

Name	Beschreibung
user_impersonation	Identitätswechsel ihres Benutzerkontos

Beispiele

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedStandaloneServer.json
func ExampleServersClient_BeginUpdate_promoteAReadReplicaToAStandaloneServerWithForcedDataSynchronizationMeaningThatItDoesntWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			Replica: &armpostgresqlflexibleservers.Replica{
				PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeStandalone),
				PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteOptionForced),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedStandaloneServer.json
func ExampleServersClient_BeginUpdate_promoteAReadReplicaToAStandaloneServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesThePromotionToAStandaloneServer() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			Replica: &armpostgresqlflexibleservers.Replica{
				PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeStandalone),
				PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteOptionPlanned),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsForcedSwitchover.json
func ExampleServersClient_BeginUpdate_switchOverAReadReplicaToPrimaryServerWithForcedDataSynchronizationMeaningThatItDoesntWaitForDataInTheReadReplicaToBeSynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			Replica: &armpostgresqlflexibleservers.Replica{
				PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeSwitchover),
				PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteOptionForced),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersPromoteReplicaAsPlannedSwitchover.json
func ExampleServersClient_BeginUpdate_switchOverAReadReplicaToPrimaryServerWithPlannedDataSynchronizationMeaningThatItWaitsForDataInTheReadReplicaToBeFullySynchronizedWithItsSourceServerBeforeItInitiatesTheSwitchingOfRolesBetweenTheReadReplicaAndThePrimaryServer() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			Replica: &armpostgresqlflexibleservers.Replica{
				PromoteMode:   to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteModeSwitchover),
				PromoteOption: to.Ptr(armpostgresqlflexibleservers.ReadReplicaPromoteOptionPlanned),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMajorVersionUpgrade.json
func ExampleServersClient_BeginUpdate_updateAnExistingServerToUpgradeTheMajorVersionOfPostgreSqlDatabaseEngine() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			Version:    to.Ptr(armpostgresqlflexibleservers.PostgresMajorVersionSeventeen),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithCustomMaintenanceWindow.json
func ExampleServersClient_BeginUpdate_updateAnExistingServerWithCustomMaintenanceWindow() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			MaintenanceWindow: &armpostgresqlflexibleservers.MaintenanceWindowForPatch{
				CustomWindow: to.Ptr("Enabled"),
				DayOfWeek:    to.Ptr[int32](0),
				StartHour:    to.Ptr[int32](8),
				StartMinute:  to.Ptr[int32](0),
			},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

{
  "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": {
      "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"
    }
  },
  "sku": {
    "name": "Standard_D8s_v3",
    "tier": "GeneralPurpose"
  }
}


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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabledAutoUpdate.json
func ExampleServersClient_BeginUpdate_updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKeyWithAutomaticKeyVersionUpdate() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
			Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
				"/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: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			AdministratorLoginPassword: to.Ptr("examplenewpassword"),
			Backup: &armpostgresqlflexibleservers.BackupForPatch{
				BackupRetentionDays: to.Ptr[int32](20),
			},
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
				Type:                            to.Ptr(armpostgresqlflexibleservers.DataEncryptionTypeAzureKeyVault),
				GeoBackupKeyURI:                 to.Ptr("https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey"),
				GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity"),
				PrimaryKeyURI:                   to.Ptr("https://exampleprimarykeyvault.vault.azure.net/keys/examplekey"),
				PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity"),
			},
		},
		SKU: &armpostgresqlflexibleservers.SKUForPatch{
			Name: to.Ptr("Standard_D8s_v3"),
			Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

{
  "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": {
      "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"
    }
  },
  "sku": {
    "name": "Standard_D8s_v3",
    "tier": "GeneralPurpose"
  }
}


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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithDataEncryptionEnabled.json
func ExampleServersClient_BeginUpdate_updateAnExistingServerWithDataEncryptionBasedOnCustomerManagedKey() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Identity: &armpostgresqlflexibleservers.UserAssignedIdentity{
			Type: to.Ptr(armpostgresqlflexibleservers.IdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armpostgresqlflexibleservers.UserIdentity{
				"/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: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			AdministratorLoginPassword: to.Ptr("examplenewpassword"),
			Backup: &armpostgresqlflexibleservers.BackupForPatch{
				BackupRetentionDays: to.Ptr[int32](20),
			},
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			DataEncryption: &armpostgresqlflexibleservers.DataEncryption{
				Type:                            to.Ptr(armpostgresqlflexibleservers.DataEncryptionTypeAzureKeyVault),
				GeoBackupKeyURI:                 to.Ptr("https://examplegeoredundantkeyvault.vault.azure.net/keys/examplekey/yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy"),
				GeoBackupUserAssignedIdentityID: to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/examplegeoredundantidentity"),
				PrimaryKeyURI:                   to.Ptr("https://exampleprimarykeyvault.vault.azure.net/keys/examplekey/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"),
				PrimaryUserAssignedIdentityID:   to.Ptr("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/exampleresourcegroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/exampleprimaryidentity"),
			},
		},
		SKU: &armpostgresqlflexibleservers.SKUForPatch{
			Name: to.Ptr("Standard_D8s_v3"),
			Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

{
  "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"
  }
}


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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdateWithMicrosoftEntraEnabled.json
func ExampleServersClient_BeginUpdate_updateAnExistingServerWithMicrosoftEntraAuthenticationEnabled() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			AdministratorLoginPassword: to.Ptr("examplenewpassword"),
			AuthConfig: &armpostgresqlflexibleservers.AuthConfigForPatch{
				ActiveDirectoryAuth: to.Ptr(armpostgresqlflexibleservers.MicrosoftEntraAuthEnabled),
				PasswordAuth:        to.Ptr(armpostgresqlflexibleservers.PasswordBasedAuthEnabled),
				TenantID:            to.Ptr("tttttt-tttt-tttt-tttt-tttttttttttt"),
			},
			Backup: &armpostgresqlflexibleservers.BackupForPatch{
				BackupRetentionDays: to.Ptr[int32](20),
			},
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			Storage: &armpostgresqlflexibleservers.Storage{
				AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowDisabled),
				StorageSizeGB: to.Ptr[int32](1024),
				Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTierP30),
			},
		},
		SKU: &armpostgresqlflexibleservers.SKUForPatch{
			Name: to.Ptr("Standard_D8s_v3"),
			Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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.

Beispielanforderung

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

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


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

package armpostgresqlflexibleservers_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/postgresql/armpostgresqlflexibleservers/v5"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e96c24570a484cff13d153fb472f812878866a39/specification/postgresql/resource-manager/Microsoft.DBforPostgreSQL/stable/2025-08-01/examples/ServersUpdate.json
func ExampleServersClient_BeginUpdate_updateAnExistingServer() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armpostgresqlflexibleservers.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewServersClient().BeginUpdate(ctx, "exampleresourcegroup", "exampleserver", armpostgresqlflexibleservers.ServerForPatch{
		Properties: &armpostgresqlflexibleservers.ServerPropertiesForPatch{
			AdministratorLoginPassword: to.Ptr("examplenewpassword"),
			Backup: &armpostgresqlflexibleservers.BackupForPatch{
				BackupRetentionDays: to.Ptr[int32](20),
			},
			CreateMode: to.Ptr(armpostgresqlflexibleservers.CreateModeForPatchUpdate),
			Storage: &armpostgresqlflexibleservers.Storage{
				AutoGrow:      to.Ptr(armpostgresqlflexibleservers.StorageAutoGrowEnabled),
				StorageSizeGB: to.Ptr[int32](1024),
				Tier:          to.Ptr(armpostgresqlflexibleservers.AzureManagedDiskPerformanceTierP30),
			},
		},
		SKU: &armpostgresqlflexibleservers.SKUForPatch{
			Name: to.Ptr("Standard_D8s_v3"),
			Tier: to.Ptr(armpostgresqlflexibleservers.SKUTierGeneralPurpose),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

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

Beispiel für eine Antwort

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

Definitionen

Name	Beschreibung
AuthConfigForPatch	Authentifizierungskonfigurationseigenschaften eines Servers.
AzureManagedDiskPerformanceTier	Speicherebene eines Servers.
BackupForPatch	Sicherungseigenschaften eines Servers.
Cluster	Clustereigenschaften eines Servers.
CreateModeForPatch	Aktualisierungsmodus eines vorhandenen Servers.
DataEncryption	Datenverschlüsselungseigenschaften eines Servers.
DataEncryptionType	Datenverschlüsselungstyp, der von einem Server verwendet wird.
EncryptionKeyStatus	Status des Schlüssels, der von einem Server verwendet wird, der mit einer Datenverschlüsselung auf der Grundlage eines vom Kunden verwalteten Schlüssels konfiguriert ist, um den primären Speicher zu verschlüsseln, der dem Server zugeordnet ist.
ErrorAdditionalInfo	Der Ressourcenverwaltungsfehler zusätzliche Informationen.
ErrorDetail	Das Fehlerdetails.
ErrorResponse	Fehlerantwort
GeographicallyRedundantBackup	Gibt an, ob der Server so konfiguriert ist, dass geografisch redundante Sicherungen erstellt werden.
HighAvailabilityForPatch	Eigenschaften mit hoher Verfügbarkeit eines Servers.
HighAvailabilityState	Mögliche Zustände des Standbyservers, der erstellt wird, wenn Hochverfügbarkeit auf SameZone oder ZoneRedundant festgelegt ist.
IdentityType	Arten von Identitäten, die einem Server zugeordnet sind.
MaintenanceWindowForPatch	Wartungsfenstereigenschaften eines Servers.
MicrosoftEntraAuth	Gibt an, ob der Server die Microsoft Entra Authentifizierung unterstützt.
Network	Netzwerkeigenschaften eines Servers.
PasswordBasedAuth	Gibt an, ob der Server die kennwortbasierte Authentifizierung unterstützt.
PostgresMajorVersion	Hauptversion der PostgreSQL-Datenbank-Engine.
PostgreSqlFlexibleServerHighAvailabilityMode	Modi der Hochverfügbarkeit, die für diesen Compute unterstützt werden.
ReadReplicaPromoteMode	Typ des Vorgangs, der auf das Read Replica angewendet werden soll. Diese Eigenschaft ist schreibgeschützt. Eigenständig bedeutet, dass das Lesereplikat zu einem eigenständigen Server heraufgestuft wird und zu einer vollständig unabhängigen Entität vom Replikationssatz wird. Switchover bedeutet, dass das Lesereplikat Rollen mit dem primären Server übernimmt.
ReadReplicaPromoteOption	Datensynchronisierungsoption, die beim Verarbeiten des in der promoteMode-Eigenschaft angegebenen Vorgangs verwendet werden soll. Diese Eigenschaft ist schreibgeschützt.
Replica	Replikateigenschaften eines Servers.
ReplicationRole	Rolle des Servers in einer Replikationsgruppe.
ReplicationState	Gibt den Replikationsstatus einer Read Replica an. Diese Eigenschaft wird nur zurückgegeben, wenn es sich bei dem Zielserver um ein Lesereplikat handelt. Mögliche Werte sind "Active", "Broken", "Catchup", "Provisioning", "Reconfiguring" und "Updated".
ServerForPatch	Stellt einen Server dar, der aktualisiert werden soll.
ServerPublicNetworkAccessState	Gibt an, ob der Zugriff auf öffentliche Netzwerke aktiviert ist oder nicht.
SkuForPatch	Berechnen von Informationen eines Servers.
SkuTier	Ebene der Compute, die einem Server zugewiesen ist.
Storage	Speichereigenschaften eines Servers.
StorageAutoGrow	Flag zum Aktivieren oder Deaktivieren des automatischen Vergrößerns der Speichergröße eines Servers, wenn der verfügbare Speicherplatz nahe Null liegt und die Bedingungen das automatische Vergrößern der Speichergröße zulassen.
StorageType	Typ des Speichers, der einem Server zugewiesen ist. Zulässige Werte sind Premium_LRS, PremiumV2_LRS oder UltraSSD_LRS. Wenn nicht angegeben, wird standardmäßig Premium_LRS verwendet.
UserAssignedIdentity	Identitäten, die einem Server zugeordnet sind.
UserIdentity	Benutzerseitig zugewiesene verwaltete Identität, die einem Server zugeordnet ist.

AuthConfigForPatch

Objekt

Authentifizierungskonfigurationseigenschaften eines Servers.

Name	Typ	Beschreibung
activeDirectoryAuth	MicrosoftEntraAuth	Gibt an, ob der Server die Microsoft Entra Authentifizierung unterstützt.
passwordAuth	PasswordBasedAuth	Gibt an, ob der Server die kennwortbasierte Authentifizierung unterstützt.
tenantId	string	Bezeichner des Mandanten der delegierten Ressource.

AzureManagedDiskPerformanceTier

Enumeration

Speicherebene eines Servers.

Wert	Beschreibung
P1
P2
P3
P4
P6
P10
P15
P20
P30
P40
P50
P60
P70
P80

BackupForPatch

Objekt

Sicherungseigenschaften eines Servers.

Name	Typ	Beschreibung
backupRetentionDays	integer (int32)	Sicherungsaufbewahrungstage für den Server.
earliestRestoreDate	string (date-time)	Frühester Zeitpunkt der Wiederherstellung (ISO8601 Format) für einen Server.
geoRedundantBackup	GeographicallyRedundantBackup	Gibt an, ob der Server so konfiguriert ist, dass geografisch redundante Sicherungen erstellt werden.

Cluster

Objekt

Clustereigenschaften eines Servers.

Name	Typ	Standardwert	Beschreibung
clusterSize	integer (int32)	0	Anzahl der Knoten, die dem elastischen Cluster zugewiesen sind.
defaultDatabaseName	string		Standarddatenbankname für den elastischen Cluster.

CreateModeForPatch

Enumeration

Aktualisierungsmodus eines vorhandenen Servers.

Wert	Beschreibung
Default
Update

DataEncryption

Objekt

Datenverschlüsselungseigenschaften eines Servers.

Name	Typ	Beschreibung
geoBackupEncryptionKeyStatus	EncryptionKeyStatus	Status des Schlüssels, der von einem Server verwendet wird, der mit Datenverschlüsselung basierend auf einem vom Kunden verwalteten Schlüssel konfiguriert ist, um den geografisch redundanten Speicher zu verschlüsseln, der dem Server zugeordnet ist, wenn er für die Unterstützung geografisch redundanter Sicherungen konfiguriert ist.
geoBackupKeyURI	string	Bezeichner der benutzerseitig zugewiesenen verwalteten Identität, die für den Zugriff auf den Schlüssel in Azure Key Vault für die Datenverschlüsselung des geografisch redundanten Speichers verwendet wird, der einem Server zugeordnet ist, der für die Unterstützung geografisch redundanter Sicherungen konfiguriert ist.
geoBackupUserAssignedIdentityId	string	Bezeichner der benutzerseitig zugewiesenen verwalteten Identität, die für den Zugriff auf den Schlüssel in Azure Key Vault für die Datenverschlüsselung des geografisch redundanten Speichers verwendet wird, der einem Server zugeordnet ist, der für die Unterstützung geografisch redundanter Sicherungen konfiguriert ist.
primaryEncryptionKeyStatus	EncryptionKeyStatus	Status des Schlüssels, der von einem Server verwendet wird, der mit einer Datenverschlüsselung auf der Grundlage eines vom Kunden verwalteten Schlüssels konfiguriert ist, um den primären Speicher zu verschlüsseln, der dem Server zugeordnet ist.
primaryKeyURI	string	URI des Schlüssels in Azure Key Vault, der für die Datenverschlüsselung des primären Speichers verwendet wird, der einem Server zugeordnet ist.
primaryUserAssignedIdentityId	string	Bezeichner der benutzerseitig zugewiesenen verwalteten Identität, die für den Zugriff auf den Schlüssel in Azure Key Vault für die Datenverschlüsselung des primären Speichers verwendet wird, der einem Server zugeordnet ist.
type	DataEncryptionType	Datenverschlüsselungstyp, der von einem Server verwendet wird.

DataEncryptionType

Enumeration

Datenverschlüsselungstyp, der von einem Server verwendet wird.

Wert	Beschreibung
SystemManaged
AzureKeyVault

EncryptionKeyStatus

Enumeration

Status des Schlüssels, der von einem Server verwendet wird, der mit einer Datenverschlüsselung auf der Grundlage eines vom Kunden verwalteten Schlüssels konfiguriert ist, um den primären Speicher zu verschlüsseln, der dem Server zugeordnet ist.

Wert	Beschreibung
Valid
Invalid

ErrorAdditionalInfo

Objekt

Der Ressourcenverwaltungsfehler zusätzliche Informationen.

Name	Typ	Beschreibung
info	object	Die zusätzlichen Informationen.
type	string	Der zusätzliche Informationstyp.

ErrorDetail

Objekt

Das Fehlerdetails.

Name	Typ	Beschreibung
additionalInfo	ErrorAdditionalInfo[]	Die zusätzlichen Informationen des Fehlers.
code	string	Der Fehlercode.
details	ErrorDetail[]	Die Fehlerdetails.
message	string	Die Fehlermeldung.
target	string	Das Fehlerziel.

ErrorResponse

Objekt

Fehlerantwort

Name	Typ	Beschreibung
error	ErrorDetail	Das Fehlerobjekt.

GeographicallyRedundantBackup

Enumeration

Gibt an, ob der Server so konfiguriert ist, dass geografisch redundante Sicherungen erstellt werden.

Wert	Beschreibung
Enabled
Disabled

HighAvailabilityForPatch

Objekt

Eigenschaften mit hoher Verfügbarkeit eines Servers.

Name	Typ	Beschreibung
mode	PostgreSqlFlexibleServerHighAvailabilityMode	Hochverfügbarkeitsmodus für einen Server.
standbyAvailabilityZone	string	Verfügbarkeitszone, die dem Standbyserver zugeordnet ist, der erstellt wurde, wenn Hochverfügbarkeit auf SameZone oder ZoneRedundant festgelegt ist.
state	HighAvailabilityState	Mögliche Zustände des Standbyservers, der erstellt wird, wenn Hochverfügbarkeit auf SameZone oder ZoneRedundant festgelegt ist.

HighAvailabilityState

Enumeration

Mögliche Zustände des Standbyservers, der erstellt wird, wenn Hochverfügbarkeit auf SameZone oder ZoneRedundant festgelegt ist.

Wert	Beschreibung
NotEnabled
CreatingStandby
ReplicatingData
FailingOver
Healthy
RemovingStandby

IdentityType

Enumeration

Arten von Identitäten, die einem Server zugeordnet sind.

Wert	Beschreibung
None
UserAssigned
SystemAssigned
SystemAssigned,UserAssigned

MaintenanceWindowForPatch

Objekt

Wartungsfenstereigenschaften eines Servers.

Name	Typ	Beschreibung
customWindow	string	Gibt an, ob das benutzerdefinierte Fenster aktiviert oder deaktiviert ist.
dayOfWeek	integer (int32)	Wochentag, der für das Wartungsfenster verwendet werden soll.
startHour	integer (int32)	Startstunde, die für das Wartungsfenster verwendet werden soll.
startMinute	integer (int32)	Startminute, die für das Wartungsfenster verwendet werden soll.

MicrosoftEntraAuth

Enumeration

Gibt an, ob der Server die Microsoft Entra Authentifizierung unterstützt.

Wert	Beschreibung
Enabled
Disabled

Network

Objekt

Netzwerkeigenschaften eines Servers.

Name	Typ	Beschreibung
delegatedSubnetResourceId	string (arm-id)	Ressourcen-ID des delegierten Subnetzes. Erforderlich bei der Erstellung eines neuen Servers, falls der Server in Ihr eigenes virtuelles Netzwerk integriert werden soll. Für einen Aktualisierungsvorgang müssen Sie diese Eigenschaft nur angeben, wenn Sie den für die private DNS-Zone zugewiesenen Wert ändern möchten.
privateDnsZoneArmResourceId	string (arm-id)	Kennung der privaten DNS-Zone. Erforderlich bei der Erstellung eines neuen Servers, falls der Server in Ihr eigenes virtuelles Netzwerk integriert werden soll. Für einen Aktualisierungsvorgang müssen Sie diese Eigenschaft nur angeben, wenn Sie den für die private DNS-Zone zugewiesenen Wert ändern möchten.
publicNetworkAccess	ServerPublicNetworkAccessState	Gibt an, ob der Zugriff auf öffentliche Netzwerke aktiviert ist oder nicht. Dies wird nur für Server unterstützt, die nicht in ein virtuelles Netzwerk integriert sind, das sich im Besitz des Kunden befindet und von ihm bereitgestellt wird, wenn der Server bereitgestellt wird.

PasswordBasedAuth

Enumeration

Gibt an, ob der Server die kennwortbasierte Authentifizierung unterstützt.

Wert	Beschreibung
Enabled
Disabled

PostgresMajorVersion

Enumeration

Hauptversion der PostgreSQL-Datenbank-Engine.

Wert	Beschreibung
18
17
16
15
14
13
12
11

PostgreSqlFlexibleServerHighAvailabilityMode

Enumeration

Modi der Hochverfügbarkeit, die für diesen Compute unterstützt werden.

Wert	Beschreibung
Disabled
ZoneRedundant
SameZone

ReadReplicaPromoteMode

Enumeration

Typ des Vorgangs, der auf das Read Replica angewendet werden soll. Diese Eigenschaft ist schreibgeschützt. Eigenständig bedeutet, dass das Lesereplikat zu einem eigenständigen Server heraufgestuft wird und zu einer vollständig unabhängigen Entität vom Replikationssatz wird. Switchover bedeutet, dass das Lesereplikat Rollen mit dem primären Server übernimmt.

Wert	Beschreibung
Standalone	Die Read Replica wird zu einem unabhängigen Server.
Switchover	Das Read Replica tauscht die Rollen mit dem primären Server.

ReadReplicaPromoteOption

Enumeration

Datensynchronisierungsoption, die beim Verarbeiten des in der promoteMode-Eigenschaft angegebenen Vorgangs verwendet werden soll. Diese Eigenschaft ist schreibgeschützt.

Wert	Beschreibung
Planned	Der Vorgang wartet, bis die Daten in der Read Replica vollständig mit dem Quellserver synchronisiert sind, bevor der Vorgang initiiert wird.
Forced	Der Vorgang wartet nicht darauf, dass die Daten in der Read Replica mit dem Quellserver synchronisiert sind, bevor er den Vorgang initiiert.

Replica

Objekt

Replikateigenschaften eines Servers.

Name	Typ	Beschreibung
capacity	integer (int32)	Maximale Anzahl von Read Replicas, die für einen Server zulässig sind.
promoteMode	ReadReplicaPromoteMode	Typ des Vorgangs, der auf das Read Replica angewendet werden soll. Diese Eigenschaft ist schreibgeschützt. Eigenständig bedeutet, dass das Lesereplikat zu einem eigenständigen Server heraufgestuft wird und zu einer vollständig unabhängigen Entität vom Replikationssatz wird. Switchover bedeutet, dass das Lesereplikat Rollen mit dem primären Server übernimmt.
promoteOption	ReadReplicaPromoteOption	Datensynchronisierungsoption, die beim Verarbeiten des in der promoteMode-Eigenschaft angegebenen Vorgangs verwendet werden soll. Diese Eigenschaft ist schreibgeschützt.
replicationState	ReplicationState	Gibt den Replikationsstatus einer Read Replica an. Diese Eigenschaft wird nur zurückgegeben, wenn es sich bei dem Zielserver um ein Lesereplikat handelt. Mögliche Werte sind "Active", "Broken", "Catchup", "Provisioning", "Reconfiguring" und "Updated".
role	ReplicationRole	Rolle des Servers in einer Replikationsgruppe.

ReplicationRole

Enumeration

Rolle des Servers in einer Replikationsgruppe.

Wert	Beschreibung
None
Primary
AsyncReplica
GeoAsyncReplica

ReplicationState

Enumeration

Gibt den Replikationsstatus einer Read Replica an. Diese Eigenschaft wird nur zurückgegeben, wenn es sich bei dem Zielserver um ein Lesereplikat handelt. Mögliche Werte sind "Active", "Broken", "Catchup", "Provisioning", "Reconfiguring" und "Updated".

Wert	Beschreibung
Active	Der Read-Replica-Server ist vollständig synchronisiert und repliziert aktiv Daten vom Primärserver.
Catchup	Der Read-Replica-Server liegt hinter dem Hauptserver und holt derzeit mit ausstehenden Änderungen auf.
Provisioning	Der Read-Replica-Server wird gerade erstellt und wird gerade initialisiert.
Updating	Der Read-Replica-Server durchläuft einige Veränderungen, er kann die Rechengröße ändern oder ihn auf den primären Server befördern.
Broken	Die Replikation ist fehlgeschlagen oder wurde unterbrochen.
Reconfiguring	Der Read-Replica-Server wird neu konfiguriert, möglicherweise aufgrund von Quellcode- oder Einstellungsänderungen.

ServerForPatch

Objekt

Stellt einen Server dar, der aktualisiert werden soll.

Name	Typ	Beschreibung
identity	UserAssignedIdentity	Beschreibt die Identität der Anwendung.
properties.administratorLogin	string	Name des Anmeldenamens, der als erster kennwortbasierter Administrator festgelegt ist, der Ihrer PostgreSQL-Instanz zugewiesen ist. Muss angegeben werden, wenn Sie die kennwortbasierte Authentifizierung zum ersten Mal auf einem Server aktivieren. Sobald er auf einen bestimmten Wert festgelegt ist, kann er für den Rest der Lebensdauer eines Servers nicht mehr geändert werden. Wenn Sie die kennwortbasierte Authentifizierung auf einem Server deaktivieren, auf dem sie aktiviert war, wird diese kennwortbasierte Rolle nicht gelöscht.
properties.administratorLoginPassword	string (password)	Passwort, das dem Administrator-Login zugewiesen ist. Solange die Passwortauthentifizierung aktiviert ist, kann dieses Passwort jederzeit geändert werden.
properties.authConfig	AuthConfigForPatch	Authentifizierungskonfigurationseigenschaften eines Servers.
properties.availabilityZone	string	Verfügbarkeitszone eines Servers.
properties.backup	BackupForPatch	Sicherungseigenschaften eines Servers.
properties.cluster	Cluster	Clustereigenschaften eines Servers.
properties.createMode	CreateModeForPatch	Aktualisierungsmodus eines vorhandenen Servers.
properties.dataEncryption	DataEncryption	Datenverschlüsselungseigenschaften eines Servers.
properties.highAvailability	HighAvailabilityForPatch	Eigenschaften mit hoher Verfügbarkeit eines Servers.
properties.maintenanceWindow	MaintenanceWindowForPatch	Wartungsfenstereigenschaften eines Servers.
properties.network	Network	Netzwerkeigenschaften eines Servers. Nur erforderlich, wenn der Server in ein vom Kunden bereitgestelltes virtuelles Netzwerk integriert werden soll.
properties.replica	Replica	Lesen Sie die Replikateigenschaften eines Servers. Nur erforderlich, wenn Sie einen Server heraufstufen möchten.
properties.replicationRole	ReplicationRole	Rolle des Servers in einer Replikationsgruppe.
properties.storage	Storage	Speichereigenschaften eines Servers.
properties.version	PostgresMajorVersion	Hauptversion der PostgreSQL-Datenbank-Engine.
sku	SkuForPatch	Computeebene und -größe eines Servers.
tags	object	Anwendungsspezifische Metadaten in Form von Schlüsselwertpaaren.

ServerPublicNetworkAccessState

Enumeration

Gibt an, ob der Zugriff auf öffentliche Netzwerke aktiviert ist oder nicht.

Wert	Beschreibung
Enabled
Disabled

SkuForPatch

Objekt

Berechnen von Informationen eines Servers.

Name	Typ	Beschreibung
name	string	Name, unter dem eine bestimmte Computegröße bekannt ist, die einem Server zugewiesen ist.
tier	SkuTier	Ebene der Compute, die einem Server zugewiesen ist.

SkuTier

Enumeration

Ebene der Compute, die einem Server zugewiesen ist.

Wert	Beschreibung
Burstable
GeneralPurpose
MemoryOptimized

Storage

Objekt

Speichereigenschaften eines Servers.

Name	Typ	Beschreibung
autoGrow	StorageAutoGrow	Flag zum Aktivieren oder Deaktivieren des automatischen Vergrößerns der Speichergröße eines Servers, wenn der verfügbare Speicherplatz nahe Null liegt und die Bedingungen das automatische Vergrößern der Speichergröße zulassen.
iops	integer (int32)	Maximale IOPS-Unterstützung, die für den Speicher unterstützt wird. Erforderlich, wenn der Speichertyp PremiumV2_LRS oder UltraSSD_LRS ist.
storageSizeGB	integer (int32)	Größe des Speichers, der einem Server zugewiesen ist.
throughput	integer (int32)	Maximaler Durchsatz wird für den Speicher unterstützt. Erforderlich, wenn der Speichertyp PremiumV2_LRS oder UltraSSD_LRS ist.
tier	AzureManagedDiskPerformanceTier	Speicherebene eines Servers.
type	StorageType	Typ des Speichers, der einem Server zugewiesen ist. Zulässige Werte sind Premium_LRS, PremiumV2_LRS oder UltraSSD_LRS. Wenn nicht angegeben, wird standardmäßig Premium_LRS verwendet.

StorageAutoGrow

Enumeration

Flag zum Aktivieren oder Deaktivieren des automatischen Vergrößerns der Speichergröße eines Servers, wenn der verfügbare Speicherplatz nahe Null liegt und die Bedingungen das automatische Vergrößern der Speichergröße zulassen.

Wert	Beschreibung
Enabled
Disabled

StorageType

Enumeration

Typ des Speichers, der einem Server zugewiesen ist. Zulässige Werte sind Premium_LRS, PremiumV2_LRS oder UltraSSD_LRS. Wenn nicht angegeben, wird standardmäßig Premium_LRS verwendet.

Wert	Beschreibung
Premium_LRS
PremiumV2_LRS
UltraSSD_LRS

UserAssignedIdentity

Objekt

Identitäten, die einem Server zugeordnet sind.

Name	Typ	Beschreibung
principalId	string	Bezeichner des Objekts des Dienstprinzipals, das der vom Benutzer zugewiesenen verwalteten Identität zugeordnet ist.
tenantId	string	Kennung des Mandanten eines Servers.
type	IdentityType	Arten von Identitäten, die einem Server zugeordnet sind.
userAssignedIdentities	<string, UserIdentity>	Zuordnung der benutzerseitig zugewiesenen verwalteten Identitäten.

UserIdentity

Objekt

Benutzerseitig zugewiesene verwaltete Identität, die einem Server zugeordnet ist.

Name	Typ	Beschreibung
clientId	string	Bezeichner des Clients des Dienstprinzipals, der der benutzerseitig zugewiesenen verwalteten Identität zugeordnet ist.
principalId	string	Bezeichner des Objekts des Dienstprinzipals, das der vom Benutzer zugewiesenen verwalteten Identität zugeordnet ist.

Freigeben über

Servers - Update

URI-Parameter

Anforderungstext

Antworten

Sicherheit

azure_auth

Bereiche

Beispiele

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.

Beispielanforderung

Beispiel für eine Antwort

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.

Beispielanforderung

Beispiel für eine Antwort

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.

Beispielanforderung

Beispiel für eine Antwort

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.

Beispielanforderung

Beispiel für eine Antwort

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

Beispielanforderung

Beispiel für eine Antwort

Update an existing server with custom maintenance window.

Beispielanforderung

Beispiel für eine Antwort

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

Beispielanforderung

Beispiel für eine Antwort

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

Beispielanforderung

Beispiel für eine Antwort

Update an existing server with Microsoft Entra authentication enabled.

Beispielanforderung

Beispiel für eine Antwort

Update an existing server.

Beispielanforderung

Beispiel für eine Antwort

Definitionen

AuthConfigForPatch

AzureManagedDiskPerformanceTier

BackupForPatch

Cluster

CreateModeForPatch

DataEncryption

DataEncryptionType

EncryptionKeyStatus

ErrorAdditionalInfo

ErrorDetail

ErrorResponse

GeographicallyRedundantBackup

HighAvailabilityForPatch

HighAvailabilityState

IdentityType

MaintenanceWindowForPatch

MicrosoftEntraAuth

Network

PasswordBasedAuth

PostgresMajorVersion

PostgreSqlFlexibleServerHighAvailabilityMode

ReadReplicaPromoteMode

ReadReplicaPromoteOption

Replica

ReplicationRole

ReplicationState

ServerForPatch

ServerPublicNetworkAccessState

SkuForPatch

SkuTier

Storage

StorageAutoGrow

StorageType

UserAssignedIdentity

UserIdentity